Desktop: parallel WSL + Windows backends with mode picker

apps/desktop/src/app/DesktopApp.ts

@@ -13,7 +13,7 @@ import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
 import * as DesktopCloudAuth from "./DesktopCloudAuth.ts";
 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
-import * as DesktopBackendManager from "../backend/DesktopBackendManager.ts";
+import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts";
 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
 import * as DesktopLifecycle from "./DesktopLifecycle.ts";
 import * as DesktopObservability from "./DesktopObservability.ts";
@@ -22,6 +22,7 @@ import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
 import * as DesktopShellEnvironment from "../shell/DesktopShellEnvironment.ts";
 import * as DesktopState from "./DesktopState.ts";
 import * as DesktopUpdates from "../updates/DesktopUpdates.ts";
+import * as DesktopWslBackend from "../wsl/DesktopWslBackend.ts";
 
 const DEFAULT_DESKTOP_BACKEND_PORT = 3773;
 const MAX_TCP_PORT = 65_535;
@@ -132,11 +133,13 @@ const fatalStartupCause = <E>(stage: string, cause: Cause.Cause<E>) =>
   handleFatalStartupError(stage, Cause.pretty(cause)).pipe(Effect.andThen(Effect.failCause(cause)));
 
 const bootstrap = Effect.gen(function* () {
-  const backendManager = yield* DesktopBackendManager.DesktopBackendManager;
+  const pool = yield* DesktopBackendPool.DesktopBackendPool;
+  const primaryBackend = yield* pool.primary;
   const state = yield* DesktopState.DesktopState;
   const environment = yield* DesktopEnvironment.DesktopEnvironment;
   const desktopSettings = yield* DesktopAppSettings.DesktopAppSettings;
   const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
+  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
   yield* logBootstrapInfo("bootstrap start");
 
   if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {
@@ -180,8 +183,13 @@ const bootstrap = Effect.gen(function* () {
   yield* logBootstrapInfo("bootstrap ipc handlers registered");
 
   if (!(yield* Ref.get(state.quitting))) {
-    yield* backendManager.start;
+    yield* primaryBackend.start;
     yield* logBootstrapInfo("bootstrap backend start requested");
+    // Bring up the WSL backend if the user previously enabled it. The
+    // primary is already starting; reconcile fires off the WSL register
+    // in parallel rather than blocking primary readiness on a possibly
+    // slow first wsl.exe spawn.
+    yield* Effect.forkScoped(wslBackend.reconcile);
   }
 }).pipe(Effect.withSpan("desktop.bootstrap"));
 
@@ -230,10 +238,20 @@ const scopedProgram = Effect.scoped(
     yield* Effect.annotateCurrentSpan({ scope: "desktop", runId });
 
     const shutdown = yield* DesktopLifecycle.DesktopShutdown;
-    const backendManager = yield* DesktopBackendManager.DesktopBackendManager;
 
     yield* Effect.addFinalizer(() =>
-      backendManager.stop().pipe(Effect.ensuring(shutdown.markComplete)),
+      Effect.gen(function* () {
+        const pool = yield* DesktopBackendPool.DesktopBackendPool;
+        // Stop every backend in the pool, not just the primary. The
+        // electronApp.quit() path can race ahead of the layer-scope
+        // cascade, so leaving the WSL instance for its parent scope
+        // finalizer means it gets hard-killed by the OS instead of
+        // receiving SIGTERM + grace. Stops run concurrently.
+        const instances = yield* pool.list;
+        yield* Effect.forEach(instances, (instance) => instance.stop(), {
+          concurrency: "unbounded",
+        });
+      }).pipe(Effect.ensuring(shutdown.markComplete)),
     );
 
     yield* startup;

apps/desktop/src/app/DesktopObservability.test.ts

@@ -125,7 +125,8 @@ describe("DesktopObservability", () => {
       }).pipe(Effect.provide(environmentLayer));
 
       yield* Effect.gen(function* () {
-        const outputLog = yield* DesktopObservability.DesktopBackendOutputLog;
+        const factory = yield* DesktopObservability.DesktopBackendOutputLogFactory;
+        const outputLog = yield* factory.forInstance("primary");
         yield* outputLog.writeSessionBoundary({
           phase: "START",
           details: "pid=123 port=3773 cwd=/repo",
@@ -145,13 +146,15 @@ describe("DesktopObservability", () => {
       assert.equal(boundary.level, "INFO");
       assert.equal(boundary.annotations.component, "desktop-backend-child");
       assert.equal(boundary.annotations.runId, "test-run");
+      assert.equal(boundary.annotations.instanceId, "primary");
       assert.equal(boundary.annotations.phase, "START");
       assert.equal(boundary.annotations.details, "pid=123 port=3773 cwd=/repo");
 
       assert.equal(output.message, "backend child process output");
       assert.equal(output.level, "INFO");
       assert.equal(output.annotations.component, "desktop-backend-child");
       assert.equal(output.annotations.runId, "test-run");
+      assert.equal(output.annotations.instanceId, "primary");
       assert.equal(output.annotations.stream, "stdout");
       assert.equal(output.annotations.text, "hello server\n");
     }).pipe(

apps/desktop/src/app/DesktopObservability.ts

@@ -1,3 +1,4 @@
+import { PRIMARY_LOCAL_ENVIRONMENT_ID } from "@t3tools/contracts";
 import { makeLocalFileTracer, makeTraceSink } from "@t3tools/shared/observability";
 import { parsePersistedServerObservabilitySettings } from "@t3tools/shared/serverSettings";
 import * as Context from "effect/Context";
@@ -13,7 +14,9 @@ import * as PlatformError from "effect/PlatformError";
 import * as References from "effect/References";
 import * as Ref from "effect/Ref";
 import * as Schema from "effect/Schema";
+import * as Scope from "effect/Scope";
 import * as Semaphore from "effect/Semaphore";
+import * as SynchronizedRef from "effect/SynchronizedRef";
 import * as Tracer from "effect/Tracer";
 import { OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 
@@ -40,10 +43,23 @@ export interface DesktopBackendOutputLogShape {
   ) => Effect.Effect<void>;
 }
 
-export class DesktopBackendOutputLog extends Context.Service<
-  DesktopBackendOutputLog,
-  DesktopBackendOutputLogShape
->()("@t3tools/desktop/app/DesktopObservability/DesktopBackendOutputLog") {}
+// Factory for per-instance backend output logs. `forInstance(id)` returns
+// a writer that targets a distinct rotating log file — the primary
+// instance keeps `server-child.log` so the historical path stays stable
+// for ops; other instances get `server-child-<sanitized-id>.log`.
+//
+// Writers are cached per id within a single factory instance so repeated
+// `forInstance` calls (e.g. during a backend restart that re-resolves
+// services) reuse the same rotating writer rather than racing each other
+// on the same file.
+export interface DesktopBackendOutputLogFactoryShape {
+  readonly forInstance: (id: string) => Effect.Effect<DesktopBackendOutputLogShape>;
+}
+
+export class DesktopBackendOutputLogFactory extends Context.Service<
+  DesktopBackendOutputLogFactory,
+  DesktopBackendOutputLogFactoryShape
+>()("@t3tools/desktop/app/DesktopObservability/DesktopBackendOutputLogFactory") {}
 
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -293,53 +309,133 @@ const writeBackendChildLogRecord = Effect.fn("desktop.observability.writeBackend
   },
 );
 
-const backendOutputLogLayer = Layer.effect(
-  DesktopBackendOutputLog,
-  Effect.gen(function* () {
-    const environment = yield* DesktopEnvironment.DesktopEnvironment;
+const PRIMARY_BACKEND_LOG_INSTANCE_ID = PRIMARY_LOCAL_ENVIRONMENT_ID;
+
+const sanitizeInstanceIdForFileName = (id: string): string => id.replace(/[^a-zA-Z0-9._-]+/g, "_");
+
+const backendLogFilePathForInstance = (
+  environment: DesktopEnvironment.DesktopEnvironmentShape,
+  id: string,
+): string => {
+  // Primary keeps the historical "server-child.log" path so ops scripts
+  // and packaged-build log inspection still find it where it always lived.
+  if (id === PRIMARY_BACKEND_LOG_INSTANCE_ID) {
+    return environment.path.join(environment.logDir, "server-child.log");
+  }
+  const sanitized = sanitizeInstanceIdForFileName(id);
+  return environment.path.join(environment.logDir, `server-child-${sanitized}.log`);
+};
 
-    const writer = yield* makeRotatingLogFileWriter({
-      filePath: environment.path.join(environment.logDir, "server-child.log"),
-    }).pipe(Effect.option);
-
-    return Option.match(writer, {
-      onNone: () => DesktopBackendOutputLogNoop,
-      onSome: (logFile) =>
-        ({
-          writeSessionBoundary: Effect.fn(
-            "desktop.observability.backendOutput.writeSessionBoundary",
-          )(function* ({ phase, details }) {
+// Just the IO sink. Cacheable by resolved file path so two ids that
+// sanitize to the same filename share a single RotatingLogFileWriter
+// (no race on currentSize tracking). Splitting the sink off from the
+// per-call shape lets the shape annotate writes with the *caller's*
+// id rather than whatever id created the cached writer first.
+const makeBackendOutputSinkForInstance = (
+  environment: DesktopEnvironment.DesktopEnvironmentShape,
+  id: string,
+): Effect.Effect<
+  Option.Option<RotatingLogFileWriter>,
+  never,
+  FileSystem.FileSystem | Path.Path | Scope.Scope
+> =>
+  makeRotatingLogFileWriter({
+    filePath: backendLogFilePathForInstance(environment, id),
+  }).pipe(Effect.option);
+
+const makeBackendOutputLogShape = (
+  environment: DesktopEnvironment.DesktopEnvironmentShape,
+  id: string,
+  sink: Option.Option<RotatingLogFileWriter>,
+): DesktopBackendOutputLogShape =>
+  Option.match(sink, {
+    onNone: () => DesktopBackendOutputLogNoop,
+    onSome: (logFile) =>
+      ({
+        writeSessionBoundary: Effect.fn("desktop.observability.backendOutput.writeSessionBoundary")(
+          function* ({ phase, details }) {
             const runId = yield* currentDesktopRunId;
             yield* writeBackendChildLogRecord(logFile, {
               message: `backend child process session ${phase.toLowerCase()}`,
               level: "INFO",
               annotations: {
                 component: "desktop-backend-child",
                 runId,
+                instanceId: id,
                 phase,
                 details: sanitizeLogValue(details),
               },
             });
+          },
+        ),
+        writeOutputChunk: Effect.fn("desktop.observability.backendOutput.writeOutputChunk")(
+          function* (streamName, chunk) {
+            if (environment.isDevelopment) {
+              yield* writeDevelopmentConsoleOutput(streamName, chunk);
+            }
+            const runId = yield* currentDesktopRunId;
+            yield* writeBackendChildLogRecord(logFile, {
+              message: "backend child process output",
+              level: streamName === "stderr" ? "ERROR" : "INFO",
+              annotations: {
+                component: "desktop-backend-child",
+                runId,
+                instanceId: id,
+                stream: streamName,
+                text: textDecoder.decode(chunk),
+              },
+            });
+          },
+        ),
+      }) satisfies DesktopBackendOutputLogShape,
+  });
+
+const backendOutputLogFactoryLayer = Layer.effect(
+  DesktopBackendOutputLogFactory,
+  Effect.gen(function* () {
+    const environment = yield* DesktopEnvironment.DesktopEnvironment;
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const factoryScope = yield* Scope.Scope;
+    // Per-file-path cache of the IO sink only. The per-call shape
+    // wraps the sink with the caller's instance id so a cache hit on
+    // a path collision (e.g. "wsl:default" and "wsl_default" both
+    // resolve to server-child-wsl_default.log) doesn't attribute the
+    // second caller's writes to the first caller's id. Each sink pins
+    // itself to the factory's scope so all log resources tear down
+    // together at app exit. Mutex serializes concurrent first-time
+    // lookups for the same file path.
+    const cacheRef = yield* SynchronizedRef.make<
+      ReadonlyMap<string, Option.Option<RotatingLogFileWriter>>
+    >(new Map());
+
+    const makeForId = (id: string): Effect.Effect<DesktopBackendOutputLogShape> =>
+      SynchronizedRef.modifyEffect(cacheRef, (cache) => {
+        const cacheKey = backendLogFilePathForInstance(environment, id);
+        const cached = cache.get(cacheKey);
+        if (cached !== undefined) {
+          return Effect.succeed([
+            makeBackendOutputLogShape(environment, id, cached),
+            cache,
+          ] as const);
+        }
+        return makeBackendOutputSinkForInstance(environment, id).pipe(
+          Effect.provideService(FileSystem.FileSystem, fileSystem),
+          Effect.provideService(Path.Path, path),
+          Scope.provide(factoryScope),
+          Effect.map((sink) => {
+            const next = new Map(cache);
+            next.set(cacheKey, sink);
+            return [
+              makeBackendOutputLogShape(environment, id, sink),
+              next as ReadonlyMap<string, Option.Option<RotatingLogFileWriter>>,
+            ] as const;
           }),
-          writeOutputChunk: Effect.fn("desktop.observability.backendOutput.writeOutputChunk")(
-            function* (streamName, chunk) {
-              if (environment.isDevelopment) {
-                yield* writeDevelopmentConsoleOutput(streamName, chunk);
-              }
-              const runId = yield* currentDesktopRunId;
-              yield* writeBackendChildLogRecord(logFile, {
-                message: "backend child process output",
-                level: streamName === "stderr" ? "ERROR" : "INFO",
-                annotations: {
-                  component: "desktop-backend-child",
-                  runId,
-                  stream: streamName,
-                  text: textDecoder.decode(chunk),
-                },
-              });
-            },
-          ),
-        }) satisfies DesktopBackendOutputLogShape,
+        );
+      });
+
+    return DesktopBackendOutputLogFactory.of({
+      forInstance: (id) => makeForId(id),
     });
   }),
 );
@@ -387,7 +483,7 @@ const tracerLayer = Layer.unwrap(
 ).pipe(Layer.provideMerge(OtlpSerialization.layerJson));
 
 export const layer = Layer.mergeAll(
-  backendOutputLogLayer,
+  backendOutputLogFactoryLayer,
   desktopLoggerLayer,
   tracerLayer,
   Layer.succeed(Tracer.MinimumTraceLevel, "Info"),

apps/desktop/src/app/DesktopState.ts

@@ -4,7 +4,6 @@ import * as Layer from "effect/Layer";
 import * as Ref from "effect/Ref";
 
 export interface DesktopStateShape {
-  readonly backendReady: Ref.Ref<boolean>;
   readonly quitting: Ref.Ref<boolean>;
 }
 
@@ -15,7 +14,6 @@ export class DesktopState extends Context.Service<DesktopState, DesktopStateShap
 export const layer = Layer.effect(
   DesktopState,
   Effect.all({
-    backendReady: Ref.make(false),
     quitting: Ref.make(false),
   }),
 );