perf: desktop and server start without shell and fork waits, and thread views stay mounted

apps/desktop/src/app/DesktopApp.ts

@@ -24,7 +24,6 @@ import * as DesktopLegacyLocalStorage from "./DesktopLegacyLocalStorage.ts";
 import * as DesktopLifecycle from "./DesktopLifecycle.ts";
 import * as DesktopLinuxUrlHandler from "./DesktopLinuxUrlHandler.ts";
 import * as DesktopObservability from "./DesktopObservability.ts";
-import * as DesktopPreReadyPlatform from "./DesktopPreReadyPlatform.ts";
 import * as DesktopShutdown from "./DesktopShutdown.ts";
 import * as DesktopServerExposure from "../backend/DesktopServerExposure.ts";
 import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
@@ -35,7 +34,6 @@ import * as DesktopUpdates from "../updates/DesktopUpdates.ts";
 import * as DesktopSnapShot from "../snapShot/DesktopSnapShot.ts";
 import * as DesktopWslBackend from "../wsl/DesktopWslBackend.ts";
 import * as DesktopRendererHistory from "../telemetry/DesktopRendererHistory.ts";
-import * as HostProcess from "@t3tools/shared/HostProcess";
 
 const DEFAULT_DESKTOP_BACKEND_PORT = 3773;
 const MAX_TCP_PORT = 65_535;
@@ -166,6 +164,13 @@ const bootstrap = Effect.gen(function* () {
   const desktopWindow = yield* DesktopWindow.DesktopWindow;
   const snapShot = yield* DesktopSnapShot.DesktopSnapShot;
   const appActivation = yield* DesktopAppActivation.DesktopAppActivation;
+  const shellEnvironment = yield* DesktopShellEnvironment.DesktopShellEnvironment;
+  const shutdown = yield* DesktopShutdown.DesktopShutdown;
+  // A quit during shell startup must prevent subsequent bootstrap work.
+  const awaitShellEnvironment = Effect.raceFirst(
+    shellEnvironment.installIntoProcess.pipe(Effect.as(true)),
+    shutdown.awaitRequest.pipe(Effect.as(false)),
+  );
   yield* logBootstrapInfo("bootstrap start");
 
   const settings = yield* desktopSettings.get;
@@ -184,13 +189,14 @@ const bootstrap = Effect.gen(function* () {
     yield* (yield* DesktopAppIdentity.DesktopAppIdentity).resolveUserDataPath,
   );
 
-  yield* snapShot.initialize;
-
   if (!settings.localEnvironmentEnabled) {
     yield* logBootstrapInfo("bootstrap skipping local environment (disabled in settings)");
     if (!(yield* Ref.get(state.quitting))) {
       yield* desktopWindow.createMainIfBackendReady;
     }
+    // Snap Shot reads the desktop session variables the login shell provides.
+    if (!(yield* awaitShellEnvironment)) return;
+    yield* snapShot.initialize;
     return;
   }
 
@@ -239,17 +245,22 @@ const bootstrap = Effect.gen(function* () {
   }
 
   if (!(yield* Ref.get(state.quitting))) {
-    if (settings.wslOnly === true && settings.wslBackendEnabled === true) {
+    const wslOnly = settings.wslOnly === true && settings.wslBackendEnabled === true;
+    // The main window waits for the primary backend. In wsl-only mode that is
+    // the WSL backend, which can be slow to cold-boot — show a "Connecting to
+    // WSL" splash immediately so the app feels responsive instead of presenting
+    // no window until WSL is ready. (Dual mode opens fast off the Windows
+    // primary, so no splash there.)
+    if (wslOnly) {
       yield* desktopWindow.showConnectingSplash;
+      // Resolving the WSL primary's config runs wsl.exe.
+      if (!(yield* awaitShellEnvironment)) return;
     }
     yield* primaryBackend.start;
     yield* logBootstrapInfo("bootstrap backend start requested");
-    // The renderer loads bundled assets and can connect while the backend
-    // boots. Starting first makes its endpoint and bootstrap credential
-    // available before the preload reads them. WSL-only retains its splash
-    // until the primary has a usable endpoint. A failed open is not fatal:
-    // backend readiness tries again.
-    if (!(settings.wslOnly === true && settings.wslBackendEnabled === true)) {
+    // Publish the endpoint and token before preload reads them. Backend readiness
+    // retries a failed window open; WSL keeps its splash until then.
+    if (!wslOnly) {
       yield* desktopWindow.ensureMain.pipe(
         Effect.catch((error) =>
           logBootstrapWarning("failed to open main window while the backend starts", {
@@ -258,6 +269,9 @@ const bootstrap = Effect.gen(function* () {
         ),
       );
     }
+    // Snap Shot reads the desktop session variables the login shell provides.
+    if (!(yield* awaitShellEnvironment)) return;
+    yield* snapShot.initialize;
     yield* appActivation.start.pipe(
       Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
       Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),
@@ -275,50 +289,19 @@ const startup = Effect.gen(function* () {
   const clerk = yield* DesktopClerk.DesktopClerk;
   const shellEnvironment = yield* DesktopShellEnvironment.DesktopShellEnvironment;
   const desktopSettings = yield* DesktopAppSettings.DesktopAppSettings;
-  const preReadyElectronOptions = yield* DesktopPreReadyPlatform.DesktopPreReadyElectronOptions;
   const safeStorage = yield* ElectronSafeStorage.ElectronSafeStorage;
   const updates = yield* DesktopUpdates.DesktopUpdates;
   const environment = yield* DesktopEnvironment.DesktopEnvironment;
   const previewPasskeys = yield* PreviewPasskeys.PreviewPasskeys;
+  const state = yield* DesktopState.DesktopState;
 
-  yield* shellEnvironment.installIntoProcess;
-  const hasCommandLinePasswordStore =
-    preReadyElectronOptions.linuxPasswordStoreCommandLine !== null;
-  const linuxElectronOptions =
-    environment.platform === "linux" && !hasCommandLinePasswordStore
-      ? DesktopPreReadyPlatform.resolveEarlyLinuxElectronOptionsFromProcess(
-          yield* HostProcess.HomeDirectory,
-        )
-      : preReadyElectronOptions.linux;
-  if (linuxElectronOptions !== null && !hasCommandLinePasswordStore) {
-    if (
-      linuxElectronOptions.passwordStore !== null ||
-      preReadyElectronOptions.linux?.passwordStore !== null
-    ) {
-      yield* electronApp.removeCommandLineSwitch("password-store");
-    }
-    if (linuxElectronOptions.passwordStore !== null) {
-      yield* electronApp.appendCommandLineSwitch(
-        "password-store",
-        linuxElectronOptions.passwordStore,
-      );
-    }
-  }
+  // Open the window while the shell loads; spawning work awaits the same run.
+  yield* Effect.forkScoped(shellEnvironment.installIntoProcess);
   const userDataPath = yield* appIdentity.resolveUserDataPath;
   yield* electronApp.setPath("userData", userDataPath);
   yield* logStartupInfo("runtime logging configured", { logDir: environment.logDir });
   yield* desktopSettings.load;
 
-  if (linuxElectronOptions !== null) {
-    yield* logStartupInfo("linux password store configured", {
-      passwordStore: hasCommandLinePasswordStore
-        ? "command-line"
-        : (linuxElectronOptions.passwordStore ?? "electron-default"),
-      xdgCurrentDesktop: process.env.XDG_CURRENT_DESKTOP ?? null,
-      xdgSessionDesktop: process.env.XDG_SESSION_DESKTOP ?? null,
-    });
-  }
-
   yield* appIdentity.configure;
   yield* lifecycle.register;
   yield* clerk.configure;
@@ -329,18 +312,25 @@ const startup = Effect.gen(function* () {
   );
   yield* logStartupInfo("app ready");
   if (environment.platform === "linux") {
-    const selectedBackend = yield* safeStorage.selectedStorageBackend;
-    yield* logStartupInfo("safe storage ready", {
-      backend: Option.getOrElse(selectedBackend, () => "unknown"),
-    });
+    yield* Effect.forkScoped(
+      shellEnvironment.secretStorageReady.pipe(
+        Effect.andThen(safeStorage.selectedStorageBackend),
+        Effect.flatMap((selectedBackend) =>
+          logStartupInfo("safe storage ready", {
+            backend: Option.getOrElse(selectedBackend, () => "unknown"),
+          }),
+        ),
+      ),
+    );
   }
   yield* appIdentity.configure;
   yield* previewPasskeys.configure;
   yield* applicationMenu.configure;
+  yield* bootstrap.pipe(Effect.catchCause((cause) => fatalStartupCause("bootstrap", cause)));
+  if (yield* Ref.get(state.quitting)) return;
   yield* updates.configure;
   yield* DesktopRemoteUpdates.listen;
   yield* linuxUrlHandler.register;
-  yield* bootstrap.pipe(Effect.catchCause((cause) => fatalStartupCause("bootstrap", cause)));
 }).pipe(Effect.withSpan("desktop.startup"));
 
 const scopedProgram = Effect.scoped(

apps/desktop/src/backend/DesktopBackendConfiguration.test.ts

@@ -41,6 +41,7 @@ const isDesktopBackendObservabilitySettingsReadError = Schema.is(
 const layerShellEnvironment = (prepared = true) =>
   Layer.succeed(DesktopShellEnvironment.DesktopShellEnvironment, {
     installIntoProcess: Effect.succeed(prepared),
+    secretStorageReady: Effect.void,
   });
 
 const layerBackendConfiguration = (prepared = true) =>
@@ -124,6 +125,7 @@ const withHarness = <A, E, R>(
     | DesktopBackendConfiguration.DesktopBackendConfiguration
   >,
   prepared = true,
+  platform: NodeJS.Platform = "darwin",
 ) =>
   Effect.gen(function* () {
     const fileSystem = yield* FileSystem.FileSystem;
@@ -138,7 +140,7 @@ const withHarness = <A, E, R>(
           Layer.provideMerge(DesktopAppSettings.layerTest()),
           Layer.provideMerge(DesktopWslEnvironment.layerTest()),
           Layer.provideMerge(DesktopWslServerTree.layerTest()),
-          Layer.provideMerge(layerEnvironment(baseDir)),
+          Layer.provideMerge(layerEnvironment(baseDir, { platform })),
         ),
       ),
     );
@@ -347,14 +349,15 @@ describe("DesktopBackendConfiguration", () => {
     ),
   );
 
-  it.effect("keeps server hydration enabled when desktop preparation failed", () =>
+  it.effect("keeps server hydration enabled when Windows preparation failed", () =>
     withHarness(
       Effect.gen(function* () {
         const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
         const primary = yield* configuration.resolvePrimary;
         assert.equal(primary.bootstrap.shellEnvironmentPrepared, false);
       }),
       false,
+      "win32",
     ),
   );
 

apps/desktop/src/backend/DesktopBackendConfiguration.ts

@@ -820,7 +820,12 @@ export const make = Effect.gen(function* () {
       Effect.provideService(FileSystem.FileSystem, fileSystem),
       Effect.provideService(DesktopEnvironment.DesktopEnvironment, environment),
     );
-    const shellEnvironmentPrepared = yield* shellEnvironment.installIntoProcess;
+    // POSIX installation always returns true and runs at the spawn gate. Keep
+    // Windows probes here so a failure still enables server-side hydration.
+    const shellEnvironmentPrepared =
+      environment.platform === "darwin" ||
+      environment.platform === "linux" ||
+      (yield* shellEnvironment.installIntoProcess);
     return yield* resolvePrimaryStartConfig({
       ...shared,
       resourceMonitorPath,

apps/desktop/src/backend/DesktopBackendManager.test.ts

@@ -141,6 +141,7 @@ interface MakeInstanceInput {
     DesktopTelemetryPublisher.DesktopTelemetryPublisher["Service"]
   >;
   readonly pruneRuntimes?: (distro: string | null, runtimeId: string) => Effect.Effect<void>;
+  readonly beforeSpawn?: Effect.Effect<void>;
 }
 
 function makeTestInstance(input: MakeInstanceInput) {
@@ -187,6 +188,7 @@ function makeTestInstance(input: MakeInstanceInput) {
     ...(input.onShutdown ? { onShutdown: () => input.onShutdown! } : {}),
     ...(input.onStateDirOwned ? { onStateDirOwned: () => input.onStateDirOwned! } : {}),
     ...(input.onPreflightFailed ? { onPreflightFailed: input.onPreflightFailed } : {}),
+    ...(input.beforeSpawn ? { beforeSpawn: input.beforeSpawn } : {}),
   });
 
   return instance.pipe(Effect.provide(layerServices));
@@ -935,6 +937,42 @@ describe("DesktopBackendManager", () => {
     ),
   );
 
+  it.effect("publishes its config before the spawn gate and never spawns once stopped", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const spawned = yield* Queue.unbounded<void>();
+        const gate = yield* Deferred.make<void>();
+        const layerSpawner = Layer.succeed(
+          ChildProcessSpawner.ChildProcessSpawner,
+          ChildProcessSpawner.make(() =>
+            Queue.offer(spawned, undefined).pipe(
+              Effect.as(makeProcess({ exitCode: Effect.never })),
+            ),
+          ),
+        );
+        const instance = yield* makeTestInstance({
+          spawnerLayer: layerSpawner,
+          beforeSpawn: Deferred.await(gate),
+        });
+
+        // The endpoint and token are readable while the spawn waits.
+        yield* instance.start;
+        assert.deepEqual(yield* instance.currentConfig, Option.some(baseConfig));
+        assert.equal(yield* Queue.size(spawned), 0);
+
+        yield* instance.stop().pipe(Effect.timeout("1 second"));
+        yield* Deferred.succeed(gate, undefined);
+        yield* Effect.yieldNow;
+        assert.equal(yield* Queue.size(spawned), 0);
+        assert.isTrue(Option.isNone((yield* instance.snapshot).activePid));
+
+        // A later start spawns as soon as the gate is open.
+        yield* instance.start;
+        yield* Queue.take(spawned).pipe(Effect.timeout("1 second"));
+      }),
+    ),
+  );
+
   it.effect("restarts when start is requested during stop teardown", () =>
     Effect.scoped(
       Effect.gen(function* () {

apps/desktop/src/backend/DesktopBackendManager.ts

@@ -1,5 +1,6 @@
 import * as Brand from "effect/Brand";
 import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
@@ -41,6 +42,10 @@ const DEFAULT_BACKEND_READINESS_REQUEST_TIMEOUT = Duration.seconds(1);
 // and a busy one needs a few seconds to stop every provider session.
 const DEFAULT_BACKEND_TERMINATE_GRACE = Duration.seconds(5);
 const DEFAULT_BACKEND_OUTPUT_DRAIN_TIMEOUT = Duration.seconds(5);
+const STOPPED_BEFORE_SPAWN: BackendProcessExit = {
+  code: Option.none(),
+  reason: "stopped before spawn",
+};
 const BACKEND_READINESS_PATH = "/.well-known/t3/environment";
 const { logWarning: logBackendProcessWarning } =
   DesktopObservability.makeComponentLogger("desktop-backend-process");
@@ -241,6 +246,11 @@ export interface BackendInstanceSpec {
   // between "fired onReady" and "currentConfig already advanced".
   readonly onReady?: (httpBaseUrl: URL) => Effect.Effect<void>;
   readonly onShutdown?: () => Effect.Effect<void>;
+  // Wait after publishing config so preload can read credentials before spawn.
+  readonly beforeSpawn?: Effect.Effect<void>;
+  // Fired once when a fatal or bounded preflight failure has exhausted its
+  // retries. Returns true when the callback changed configuration and the
+  // manager should resolve once more; false stops the failed instance.
   readonly onPreflightFailed?: (failure: PreflightFailure) => Effect.Effect<boolean>;
   readonly onStateDirOwned?: () => Effect.Effect<void>;
 }
@@ -657,6 +667,20 @@ export const makeBackendInstance = Effect.fn("makeBackendInstance")(function* (
     });
   });
 
+  // Stop must release the spawn gate without starting the stopped run.
+  const awaitBeforeSpawn = (runScope: Scope.Scope): Effect.Effect<boolean> => {
+    const beforeSpawn = spec.beforeSpawn;
+    if (beforeSpawn === undefined) return Effect.succeed(true);
+    return Effect.gen(function* () {
+      const stopped = yield* Deferred.make<void>();
+      yield* Scope.addFinalizer(runScope, Deferred.succeed(stopped, undefined));
+      return yield* Effect.raceFirst(
+        beforeSpawn.pipe(Effect.as(true)),
+        Deferred.await(stopped).pipe(Effect.as(false)),
+      );
+    });
+  };
+
   const start: Effect.Effect<void> = Effect.suspend(() =>
     mutex.withPermits(1)(
       Effect.gen(function* () {
@@ -868,7 +892,7 @@ export const makeBackendInstance = Effect.fn("makeBackendInstance")(function* (
           );
         });
 
-        const program = runBackendProcess({
+        const spawnProcess = runBackendProcess({
           ...config.value,
           desktopTelemetryStream: desktopTelemetryPublisher.encoded,
           desktopBrowserStream: desktopBrowserHost.events,
@@ -931,7 +955,9 @@ export const makeBackendInstance = Effect.fn("makeBackendInstance")(function* (
             },
           ),
           onOutput: (streamName, chunk) => backendOutputLog.writeOutputChunk(streamName, chunk),
-        }).pipe(
+        });
+        const program = awaitBeforeSpawn(runScope).pipe(
+          Effect.flatMap((spawn) => (spawn ? spawnProcess : Effect.succeed(STOPPED_BEFORE_SPAWN))),
           Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
           Effect.provideService(HttpClient.HttpClient, httpClient),
           Scope.provide(runScope),

apps/desktop/src/backend/DesktopBackendPool.test.ts

@@ -11,6 +11,7 @@ import { ChildProcessSpawner } from "effect/process";
 
 import * as DesktopObservability from "../app/DesktopObservability.ts";
 import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
+import * as DesktopShellEnvironment from "../shell/DesktopShellEnvironment.ts";
 import * as DesktopTelemetryPublisher from "../telemetry/DesktopTelemetryPublisher.ts";
 import * as DesktopBrowserHost from "../preview/DesktopBrowserHost.ts";
 import * as ElectronDialog from "../electron/ElectronDialog.ts";
@@ -85,6 +86,10 @@ function layerPool(labelRef: Ref.Ref<string>): Layer.Layer<DesktopBackendPool.De
           currentBootstrapToken: Effect.die("unexpected bootstrap token read"),
         } satisfies DesktopBackendConfiguration.DesktopBackendConfiguration["Service"]),
         DesktopAppSettings.layerTest(),
+        Layer.succeed(DesktopShellEnvironment.DesktopShellEnvironment, {
+          installIntoProcess: Effect.succeed(true),
+          secretStorageReady: Effect.void,
+        }),
         DesktopWslEnvironment.layerTest(),
         ElectronDialog.layer,
         ElectronApp.layer,