Desktop: parallel WSL + Windows backends with mode picker

apps/desktop/src/app/DesktopApp.ts

@@ -12,7 +12,7 @@ import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.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";
@@ -21,6 +21,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;
@@ -130,11 +131,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)) {
@@ -178,8 +181,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"));
 
@@ -226,10 +234,20 @@ const scopedProgram = Effect.scoped(
     yield* Effect.annotateCurrentSpan({ scope: "desktop", runId });
 
     const shutdown = yield* DesktopLifecycle.DesktopShutdown;
-    const backendManager = yield* DesktopBackendManager.DesktopBackendManager;
+    const pool = yield* DesktopBackendPool.DesktopBackendPool;
 
     yield* Effect.addFinalizer(() =>
-      backendManager.stop().pipe(Effect.ensuring(shutdown.markComplete)),
+      Effect.gen(function* () {
+        // 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

@@ -13,7 +13,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 +42,23 @@ export interface DesktopBackendOutputLogShape {
   ) => Effect.Effect<void>;
 }
 
-export class DesktopBackendOutputLog extends Context.Service<
-  DesktopBackendOutputLog,
-  DesktopBackendOutputLogShape
->()("t3/desktop/BackendOutputLog") {}
+// 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
+>()("t3/desktop/BackendOutputLogFactory") {}
 
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -293,13 +308,34 @@ 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";
+
+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 makeBackendOutputLogForInstance = (
+  environment: DesktopEnvironment.DesktopEnvironmentShape,
+  id: string,
+): Effect.Effect<
+  DesktopBackendOutputLogShape,
+  never,
+  FileSystem.FileSystem | Path.Path | Scope.Scope
+> =>
+  Effect.gen(function* () {
     const writer = yield* makeRotatingLogFileWriter({
-      filePath: environment.path.join(environment.logDir, "server-child.log"),
+      filePath: backendLogFilePathForInstance(environment, id),
     }).pipe(Effect.option);
 
     return Option.match(writer, {
@@ -316,6 +352,7 @@ const backendOutputLogLayer = Layer.effect(
               annotations: {
                 component: "desktop-backend-child",
                 runId,
+                instanceId: id,
                 phase,
                 details: sanitizeLogValue(details),
               },
@@ -333,6 +370,7 @@ const backendOutputLogLayer = Layer.effect(
                 annotations: {
                   component: "desktop-backend-child",
                   runId,
+                  instanceId: id,
                   stream: streamName,
                   text: textDecoder.decode(chunk),
                 },
@@ -341,6 +379,49 @@ const backendOutputLogLayer = Layer.effect(
           ),
         }) 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-id cache so repeated forInstance(id) calls reuse the same
+    // rotating writer instead of opening a second handle on the same
+    // file. Each writer 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 id.
+    const cacheRef = yield* SynchronizedRef.make<ReadonlyMap<string, DesktopBackendOutputLogShape>>(
+      new Map(),
+    );
+
+    const makeForId = (id: string): Effect.Effect<DesktopBackendOutputLogShape> =>
+      SynchronizedRef.modifyEffect(cacheRef, (cache) => {
+        // Key the cache by the resolved file path, not the raw id.
+        // Otherwise two ids that sanitize to the same filename (e.g.
+        // `wsl:default` and `wsl_default`) would each create their
+        // own RotatingLogFileWriter pointing at the same file, with
+        // independent currentSize tracking and a race on writes.
+        const cacheKey = backendLogFilePathForInstance(environment, id);
+        const cached = cache.get(cacheKey);
+        if (cached !== undefined) return Effect.succeed([cached, cache] as const);
+        return makeBackendOutputLogForInstance(environment, id).pipe(
+          Effect.provideService(FileSystem.FileSystem, fileSystem),
+          Effect.provideService(Path.Path, path),
+          Scope.provide(factoryScope),
+          Effect.map((shape) => {
+            const next = new Map(cache);
+            next.set(cacheKey, shape);
+            return [shape, next as ReadonlyMap<string, DesktopBackendOutputLogShape>] as const;
+          }),
+        );
+      });
+
+    return DesktopBackendOutputLogFactory.of({
+      forInstance: (id) => makeForId(id),
+    });
   }),
 );
 
@@ -387,7 +468,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),
   }),
 );