@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/desktop/desktop-session-manager.test.ts

@@ -203,6 +203,7 @@ describe("DesktopSessionManager process tree", () => {
     // The dock waits on the Chromium path its launcher points at, so it comes
     // up alongside the browser rather than with the rest of the tree.
     expect(h.roles()).toEqual([
+      "session-bus",
       "x-server",
       "window-manager",
       "compositor",
@@ -216,8 +217,9 @@ describe("DesktopSessionManager process tree", () => {
     expect(x).toContain("-localhost");
     expect(x[x.indexOf("-SecurityTypes") + 1]).toBe("None");
     expect(x[x.indexOf("-rfbport") + 1]).toBe(String(DESKTOP_VNC_PORT));
-    expect(x[x.indexOf("-geometry") + 1]).toBe("1600x900");
+    expect(x[x.indexOf("-geometry") + 1]).toBe("1440x810");
     for (const role of [
+      "session-bus",
       "window-manager",
       "compositor",
       "clipboard",
@@ -228,6 +230,11 @@ describe("DesktopSessionManager process tree", () => {
         HOME: "/data",
         LANG: "C.UTF-8",
         DISPLAY: ":99",
+        XDG_CONFIG_HOME: panelConfigDir,
+        XDG_DATA_HOME: panelConfigDir,
+        DBUS_SESSION_BUS_ADDRESS: h.manager.accessibilityBusAddress,
+        NO_AT_BRIDGE: "0",
+        GTK_A11Y: "atspi",
       });
     }
     expect(h.child("window-manager").request.cmd[0]).toBe("/usr/bin/python3");
@@ -239,11 +246,7 @@ describe("DesktopSessionManager process tree", () => {
     ]);
     // The compositor precedes the dock so it has an ARGB visual.
     expect(h.child("compositor").request.cmd).toEqual(["/usr/bin/xcompmgr"]);
-    expect(h.child("panel").request.cmd).toEqual([
-      "/usr/bin/dbus-run-session",
-      "--",
-      "/usr/bin/plank",
-    ]);
+    expect(h.child("panel").request.cmd).toEqual(["/usr/bin/plank"]);
     expect(h.child("panel").request.env).toEqual({
       ...h.child("browser").request.env,
       XDG_CONFIG_HOME: panelConfigDir,
@@ -280,7 +283,7 @@ describe("DesktopSessionManager process tree", () => {
         "plank",
         "tigervncconfig",
         "vncconfig",
-        "xterm",
+        "wezterm",
       ],
     });
     await expect(h.manager.ensureDesktopRunning()).rejects.toThrow(
@@ -306,7 +309,7 @@ describe("DesktopSessionManager process tree", () => {
       join(panelConfigDir, "applications", "xterm.desktop"),
       "utf8",
     );
-    expect(terminal).toContain(`Exec="/usr/bin/xterm"`);
+    expect(terminal).toContain(`Exec="/usr/bin/wezterm"`);
     expect(terminal).toContain(`Icon=${join(panelConfigDir, "terminal.png")}`);
 
     const bytes = readFileSync(join(panelConfigDir, "terminal.png"));
@@ -324,7 +327,10 @@ describe("DesktopSessionManager process tree", () => {
     h.setVncReady(false);
 
     await expect(h.manager.ensureDesktopRunning()).rejects.toThrow(/not ready/);
-    expect(h.terminated()).toEqual([h.child("x-server")]);
+    expect(h.terminated()).toEqual([
+      h.child("session-bus"),
+      h.child("x-server"),
+    ]);
 
     h.setVncReady(true);
     await h.manager.ensureDesktopRunning();
@@ -341,7 +347,9 @@ describe("DesktopSessionManager process tree", () => {
     // The viewer hears about it before the kill grace, not after.
     expect(lost).toEqual([{ code: 4011, reason: "Desktop failed to start" }]);
     const first = h.child("x-server");
-    expect(h.killed).toEqual([{ child: first, signal: "SIGTERM" }]);
+    expect(h.killed.filter((k) => k.child === first)).toEqual([
+      { child: first, signal: "SIGTERM" },
+    ]);
 
     // Reconnect while the first X server is still ignoring its SIGTERM.
     h.setVncReady(true);
@@ -350,8 +358,11 @@ describe("DesktopSessionManager process tree", () => {
     expect(h.count("x-server")).toBe(1);
 
     // The SIGKILL alone does not free the display and port; the exit does.
-    await waitFor(() => h.killed.length === 2, { intervalMs: 1 });
-    expect(h.killed[1]).toEqual({ child: first, signal: "SIGKILL" });
+    await waitFor(
+      () => h.killed.some((k) => k.child === first && k.signal === "SIGKILL"),
+      { intervalMs: 1 },
+    );
+    expect(h.killed).toContainEqual({ child: first, signal: "SIGKILL" });
     expect(h.count("x-server")).toBe(1);
 
     first.exit(0);
@@ -368,7 +379,12 @@ describe("DesktopSessionManager process tree", () => {
     const started = Date.now();
     await h.manager.ensureDesktopRunning();
     expect(Date.now() - started).toBeGreaterThanOrEqual(KILL_GRACE_MS * 2 - 4);
-    expect(h.killed.map((k) => k.signal)).toEqual(["SIGTERM", "SIGKILL"]);
+    expect(h.killed.map((k) => k.signal)).toEqual([
+      "SIGTERM",
+      "SIGTERM",
+      "SIGKILL",
+      "SIGKILL",
+    ]);
     expect(h.count("x-server")).toBe(2);
   });
 
@@ -386,13 +402,14 @@ describe("DesktopSessionManager process tree", () => {
         .terminated()
         .map((c) => c.role)
         .sort(),
-    ).toEqual(["compositor", "window-manager", "x-server"]);
+    ).toEqual(["compositor", "session-bus", "window-manager", "x-server"]);
     expect(lost).toEqual([{ code: 4011, reason: "Desktop failed to start" }]);
 
     failSpawn.length = 0;
     await h.manager.ensureDesktopRunning();
     await settle();
-    expect(h.roles().slice(3)).toEqual([
+    expect(h.roles().slice(4)).toEqual([
+      "session-bus",
       "x-server",
       "window-manager",
       "compositor",
@@ -400,7 +417,7 @@ describe("DesktopSessionManager process tree", () => {
       "panel",
       "browser",
     ]);
-    expect(h.terminated()).toHaveLength(3);
+    expect(h.terminated()).toHaveLength(4);
   });
 
   test("a dock or compositor that will not spawn leaves the desktop up", async () => {
@@ -414,6 +431,7 @@ describe("DesktopSessionManager process tree", () => {
     expect(lost).toEqual([]);
     expect(h.killed).toEqual([]);
     expect(h.roles()).toEqual([
+      "session-bus",
       "x-server",
       "window-manager",
       "clipboard",
@@ -444,6 +462,7 @@ describe("DesktopSessionManager process tree", () => {
       "clipboard",
       "compositor",
       "panel",
+      "session-bus",
       "window-manager",
     ]);
     // The slot is free and the next start builds a fresh tree.
@@ -647,7 +666,13 @@ describe("DesktopSessionManager process tree", () => {
         .terminated()
         .map((c) => c.role)
         .sort(),
-    ).toEqual(["clipboard", "compositor", "window-manager", "x-server"]);
+    ).toEqual([
+      "clipboard",
+      "compositor",
+      "session-bus",
+      "window-manager",
+      "x-server",
+    ]);
   });
 
   test("destroy terminates, hard-kills stragglers after the grace, and refuses what comes after", async () => {
@@ -665,8 +690,8 @@ describe("DesktopSessionManager process tree", () => {
       { code: 1001, reason: "The assistant is shutting down" },
     ]);
     expect(h.killed.map((k) => k.signal)).toEqual([
-      ...Array(6).fill("SIGTERM"),
-      ...Array(6).fill("SIGKILL"),
+      ...Array(7).fill("SIGTERM"),
+      ...Array(7).fill("SIGKILL"),
     ]);
     expect(h.manager.acquireViewerSlot(newViewer().viewer)).toEqual(
       SHUTTING_DOWN,
@@ -682,8 +707,9 @@ describe("DesktopSessionManager process tree", () => {
     await settle();
 
     await h.manager.destroy();
-    expect(h.killed.filter((k) => k.signal === "SIGTERM")).toHaveLength(6);
+    expect(h.killed.filter((k) => k.signal === "SIGTERM")).toHaveLength(7);
     expect(h.killed.filter((k) => k.signal === "SIGKILL")).toEqual([
+      { child: h.child("session-bus"), signal: "SIGKILL" },
       { child: h.child("panel"), signal: "SIGKILL" },
     ]);
   });
@@ -716,7 +742,7 @@ describe("DesktopSessionManager viewer slot", () => {
     expect(h.killed).toEqual([]);
 
     await sleep(LINGER_MS * 2);
-    expect(h.terminated()).toHaveLength(6);
+    expect(h.terminated()).toHaveLength(7);
     await h.manager.ensureDesktopRunning();
     expect(h.count("x-server")).toBe(2);
   });
@@ -811,3 +837,25 @@ test.each([undefined, 4321])(
     }
   },
 );
+
+test("losing the accessibility session bus tears down apps and the next desktop gets a new bus", async () => {
+  const h = newManager({ exitOnTerm: true });
+  const { viewer, lost } = newViewer();
+  h.manager.acquireViewerSlot(viewer);
+  await h.manager.ensureDesktopRunning();
+  await settle();
+  const firstAddress = h.manager.accessibilityBusAddress;
+  for (const role of ["window-manager", "panel", "browser"] as const) {
+    expect(h.child(role).request.env.DBUS_SESSION_BUS_ADDRESS).toBe(
+      firstAddress,
+    );
+  }
+  h.child("session-bus").exit(1);
+  await settle();
+  expect(lost).toEqual([
+    { code: 4011, reason: "Desktop stopped: session-bus exited" },
+  ]);
+  expect(h.terminated()).toContain(h.child("browser"));
+  await h.manager.ensureDesktopRunning();
+  expect(h.manager.accessibilityBusAddress).not.toBe(firstAddress);
+});

package/src/desktop/desktop-session-manager.ts

@@ -6,16 +6,16 @@
  * last one leaves so a reconnect is instant.
  */
 
+import { randomUUID } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
+import { createConnection } from "node:net";
 import { join } from "node:path";
 
-import { readAvatarState } from "../avatar/avatar-manifest.js";
-import { resolveNotificationAccentHex } from "../avatar/notification-avatar.js";
 import { getIsContainerized } from "../config/env-registry.js";
 import { connectCdpWsTransport } from "../tools/browser/cdp-client/cdp-inspect/ws-transport.js";
 import { terminateProcessTree } from "../util/host-process.js";
 import { getLogger } from "../util/logger.js";
-import { getDataDir } from "../util/platform.js";
+import { getDataDir, getWorkspaceDir } from "../util/platform.js";
 import { sleep } from "../util/retry.js";
 import { DesktopBrowserClient } from "./desktop-browser-client.js";
 import {
@@ -46,7 +46,7 @@ const log = getLogger("desktop-session");
 
 export const DESKTOP_VNC_PORT = 5999;
 const DESKTOP_GEOMETRY = `${DESKTOP_WIDTH}x${DESKTOP_HEIGHT}`;
-const DESKTOP_LINGER_MS = 5 * 60_000;
+const DESKTOP_LINGER_MS = 24 * 60 * 60_000;
 const VNC_READY_DEADLINE_MS = 10_000;
 const VNC_PROBE_INTERVAL_MS = 100;
 const KILL_GRACE_MS = 2_000;
@@ -96,6 +96,7 @@ const BUSY_LOSS: DesktopLoss = {
 };
 
 export type DesktopChildRole =
+  | "session-bus"
   | "x-server"
   | "window-manager"
   | "compositor"
@@ -172,6 +173,7 @@ interface DesktopSessionManagerOptions {
   /** PATH lookup for the desktop binaries; `null` when one is missing. */
   readonly which?: (binary: string) => string | null;
   /** Whether the VNC server accepts connections on `port`. */
+  readonly probeSessionBus?: (address: string) => Promise<boolean>;
   readonly probeVncPort?: (port: number) => Promise<boolean>;
   /** Path of the installed Google Chrome binary. */
   readonly resolveChromePath?: () => Promise<string>;
@@ -218,7 +220,7 @@ export class DesktopSessionManager {
     chromiumPath: string;
     env: Record<string, string>;
   } | null = null;
-  private readonly retiredPanels = new Set<DesktopChild>();
+  private readonly retiredLaunchers = new Map<DesktopChild, DesktopChildRole>();
   private wallpaperStarting: {
     generation: number;
     refreshQueued: boolean;
@@ -288,6 +290,13 @@ export class DesktopSessionManager {
     }
   });
 
+  private busName = "";
+  private readonly probeSessionBus: (address: string) => Promise<boolean>;
+
+  get accessibilityBusAddress(): string {
+    return `unix:abstract=${this.busName}`;
+  }
+
   private readonly spawn: NonNullable<DesktopSessionManagerOptions["spawn"]>;
   private readonly which: NonNullable<DesktopSessionManagerOptions["which"]>;
   private readonly probeVncPort: NonNullable<
@@ -315,6 +324,7 @@ export class DesktopSessionManager {
     this.allocateDebugPort =
       options.allocateDebugPort ?? allocateDesktopDebugPort;
     this.spawn = options.spawn ?? spawnDetached;
+    this.probeSessionBus = options.probeSessionBus ?? probeSessionBus;
     this.which = options.which ?? Bun.which;
     this.probeVncPort = options.probeVncPort ?? probeLoopbackPort;
     this.resolveChromePath =
@@ -346,11 +356,7 @@ export class DesktopSessionManager {
       ((configDir) => {
         let sourcePath: string | undefined;
         try {
-          sourcePath = writeDesktopWindowTheme(
-            configDir,
-            this.sourceEnv.HOME,
-            resolveNotificationAccentHex(readAvatarState()),
-          );
+          sourcePath = writeDesktopWindowTheme(configDir, this.sourceEnv.HOME);
         } catch (err) {
           log.warn({ err }, "Desktop window theme could not be applied");
         }
@@ -454,7 +460,28 @@ export class DesktopSessionManager {
     let env: Record<string, string>;
     try {
       this.binaries = resolveDesktopBinaries(this.which);
+      this.busName = `vellum-desktop-${randomUUID()}`;
       env = this.childEnv();
+      this.launch(
+        "session-bus",
+        [
+          this.binaries.sessionBus,
+          "--session",
+          "--nofork",
+          `--address=${this.accessibilityBusAddress}`,
+        ],
+        env,
+      );
+      const busDeadline = Date.now() + this.readyDeadlineMs;
+      while (!(await this.probeSessionBus(this.accessibilityBusAddress))) {
+        if (this.generation !== generation || Date.now() >= busDeadline) {
+          throw new Error("Desktop session bus did not start");
+        }
+        await sleep(VNC_PROBE_INTERVAL_MS);
+      }
+      if (this.generation !== generation) {
+        throw new Error("Desktop was torn down while starting");
+      }
       this.launch("x-server", xServerCommand(this.binaries.xServer), env);
       const ready = await this.waitForVnc(generation);
       if (this.generation !== generation) {
@@ -618,11 +645,11 @@ export class DesktopSessionManager {
         chromiumProfileDir: this.profileDir,
         debugPort: this.debugPort,
         terminalPath: binaries.terminal,
+        fileManagerPath: binaries.fileManager,
+        workspaceDir: getWorkspaceDir(),
       });
-      this.launch("panel", [binaries.panelSession, "--", binaries.panel], {
+      this.launch("panel", [binaries.panel], {
         ...env,
-        XDG_CONFIG_HOME: this.panelConfigDir,
-        XDG_DATA_HOME: this.panelConfigDir,
         GSETTINGS_BACKEND: "keyfile",
       });
     } catch (err) {
@@ -694,11 +721,14 @@ export class DesktopSessionManager {
     this.children.delete(role);
     if (role === "panel") {
       // Keep dock-launched applications alive until desktop teardown.
-      this.retiredPanels.add(child);
+      this.retiredLaunchers.set(child, role);
       log.warn({ outcome }, "Desktop dock exited, scheduling restart");
       this.schedulePanelRestart();
       return;
     }
+    if (role === "session-bus") {
+      this.retiredLaunchers.set(child, role);
+    }
     if (role === "wallpaper" && outcome === 0) {
       return;
     }
@@ -737,8 +767,8 @@ export class DesktopSessionManager {
     }
     this.panelRestartAttempts = 0;
     this.panelLaunch = null;
-    const retiredPanels = [...this.retiredPanels];
-    this.retiredPanels.clear();
+    const retiredLaunchers = [...this.retiredLaunchers];
+    this.retiredLaunchers.clear();
     const children = new Map(this.children);
     this.children.clear();
     const viewer = this.viewer;
@@ -755,8 +785,8 @@ export class DesktopSessionManager {
     const done: Promise<void> = Promise.all([
       this.tearingDown,
       this.killAll(children),
-      ...retiredPanels.map((child) =>
-        this.killAll(new Map([["panel", child]])),
+      ...retiredLaunchers.map(([child, role]) =>
+        this.killAll(new Map([[role, child]])),
       ),
     ])
       .then(() => undefined)
@@ -787,13 +817,16 @@ export class DesktopSessionManager {
         return child.exited.catch(() => 0).then(() => alive.delete(role));
       }),
     );
-    const panel = children.get("panel");
+    const hasServiceChildren =
+      children.has("panel") || children.has("session-bus");
     await this.waitForExits(
-      panel ? Promise.all([exits, sleep(this.killGraceMs)]) : exits,
+      hasServiceChildren
+        ? Promise.all([exits, sleep(this.killGraceMs)])
+        : exits,
     );
     for (const [role, child] of children) {
-      // A reaped panel does not prove its application process group is empty.
-      if (role === "panel" || alive.has(role)) {
+      // Launchers can leave descendants after their own exit.
+      if (role === "panel" || role === "session-bus" || alive.has(role)) {
         this.killProcessGroup(child, "SIGKILL");
       }
     }
@@ -843,6 +876,12 @@ export class DesktopSessionManager {
       }
     }
     env.DISPLAY = DESKTOP_DISPLAY;
+    // D-Bus services share app preferences and launchers.
+    env.XDG_CONFIG_HOME = this.panelConfigDir;
+    env.XDG_DATA_HOME = this.panelConfigDir;
+    env.DBUS_SESSION_BUS_ADDRESS = this.accessibilityBusAddress;
+    env.NO_AT_BRIDGE = "0";
+    env.GTK_A11Y = "atspi";
     return env;
   }
 }
@@ -949,6 +988,21 @@ async function probeLoopbackPort(port: number): Promise<boolean> {
   }
 }
 
+function probeSessionBus(address: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = createConnection({
+      path: `\0${address.slice("unix:abstract=".length)}`,
+    });
+    const finish = (ready: boolean) => {
+      socket.destroy();
+      resolve(ready);
+    };
+    socket.setTimeout(200, () => finish(false));
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Singleton
 // ---------------------------------------------------------------------------

package/src/desktop/desktop-stream-bridge.test.ts

@@ -6,7 +6,6 @@ import { afterAll, describe, expect, mock, spyOn, test } from "bun:test";
 
 import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
 import { newFakeDesktop, newViewer, settle } from "./__tests__/fake-desktop.js";
-import { DesktopDependencyInstaller } from "./desktop-dependencies.js";
 import {
   type DesktopSessionManager,
   type DesktopTcpHandlers,
@@ -57,7 +56,7 @@ class FakeTcp implements DesktopTcpSocket {
 
 function newBridge(
   manager: DesktopSessionManager,
-  ensureInstalled: () => Promise<void> = async () => {},
+  assertReady: () => void = () => {},
   isEnabled: () => boolean = () => true,
 ) {
   const ws = new FakeWs();
@@ -68,7 +67,7 @@ function newBridge(
   });
   const bridge = new DesktopStreamBridge(ws, {
     manager,
-    ensureInstalled,
+    assertReady,
     isEnabled,
     connect: async (_port, handlers) => {
       tcp.handlers = handlers;
@@ -147,42 +146,23 @@ describe("DesktopStreamBridge", () => {
     }
   });
 
-  test("refuses a disabled desktop before installation or process startup", async () => {
+  test("refuses a disabled desktop before checking components or starting processes", async () => {
     const h = newFakeDesktop({ profileDir });
-    let installs = 0;
+    let checks = 0;
     const b = newBridge(
       h.manager,
       async () => {
-        installs++;
+        checks++;
       },
       () => false,
     );
     await b.bridge.start();
     expect(b.ws.closeCode).toBe(4008);
-    expect(installs).toBe(0);
+    expect(checks).toBe(0);
     expect(h.spawned).toEqual([]);
     expect(slotIsFree(h.manager)).toBe(true);
   });
 
-  test("does not start the desktop when disabled during installation", async () => {
-    const h = newFakeDesktop({ profileDir });
-    let enabled = true;
-    const install = Promise.withResolvers<void>();
-    const b = newBridge(
-      h.manager,
-      () => install.promise,
-      () => enabled,
-    );
-    const started = b.bridge.start();
-    enabled = false;
-    install.resolve();
-    await started;
-    expect(b.ws.closeCode).toBe(4008);
-    expect(slotIsFree(h.manager)).toBe(true);
-    expect(b.tcp.handlers).toBeUndefined();
-    expect(h.spawned).toEqual([]);
-  });
-
   for (const direction of ["viewer", "desktop"] as const) {
     test(`ignores ${direction} frames after the stream closes`, async () => {
       const h = newFakeDesktop({ profileDir });
@@ -205,106 +185,15 @@ describe("DesktopStreamBridge", () => {
     });
   }
 
-  test("direct viewers share background setup across a timeout and reconnect", async () => {
-    const h = newFakeDesktop({ profileDir });
-    let ready = false;
-    let installs = 0;
-    const install = Promise.withResolvers<void>();
-    const installer = new DesktopDependencyInstaller({
-      supported: () => true,
-      ready: () => ready,
-      install: async () => {
-        installs++;
-        await install.promise;
-        ready = true;
-      },
-      notify: async () => {},
-    });
-    const ensureInstalled = () => installer.ensureReady();
-    const first = newBridge(h.manager, ensureInstalled);
-    const firstStart = first.bridge.start();
-    await settle();
-    expect(installs).toBe(1);
-    expect(h.spawned).toEqual([]);
-
-    const busy = newBridge(h.manager, async () => {
-      throw new Error("A rejected viewer must not start setup");
-    });
-    await busy.bridge.start();
-    expect(busy.ws.closeCode).toBe(4013);
-
-    first.bridge.handleClose();
-    expect(slotIsFree(h.manager)).toBe(true);
-    const retry = newBridge(h.manager, ensureInstalled);
-    const retryStart = retry.bridge.start();
-    await settle();
-    expect(installs).toBe(1);
-    expect(h.spawned).toEqual([]);
-
-    install.resolve();
-    retry.connectNow();
-    await Promise.all([firstStart, retryStart]);
-    expect(retry.ws.closeCode).toBeNull();
-    expect(h.spawned.length).toBeGreaterThan(0);
-    retry.tcp.handlers.onData(new Uint8Array([1, 2, 3]));
-    expect(retry.ws.sent).toEqual([new Uint8Array([1, 2, 3])]);
-    expect(first.ws.sent).toEqual([]);
-    expect(first.tcp.handlers).toBeUndefined();
-    retry.bridge.handleClose();
-  });
-
-  test("setup continues after the last viewer closes without starting a desktop", async () => {
-    const h = newFakeDesktop({ profileDir });
-    const install = Promise.withResolvers<void>();
-    const b = newBridge(h.manager, () => install.promise);
-    const started = b.bridge.start();
-    b.bridge.handleClose();
-    install.resolve();
-    await started;
-    expect(h.spawned).toEqual([]);
-    expect(slotIsFree(h.manager)).toBe(true);
-  });
-
-  test("setup failure releases the slot and permits a successful retry", async () => {
+  test("missing image components release the viewer slot without starting processes", async () => {
     const h = newFakeDesktop({ profileDir });
-    let ready = false;
-    let attempts = 0;
-    const installer = new DesktopDependencyInstaller({
-      supported: () => true,
-      ready: () => ready,
-      install: async () => {
-        if (++attempts === 1) {
-          throw new Error("Download failed");
-        }
-        ready = true;
-      },
-      notify: async () => {},
+    const b = newBridge(h.manager, () => {
+      throw new Error("Missing image components");
     });
-    const ensureInstalled = () => installer.ensureReady();
-    const first = newBridge(h.manager, ensureInstalled);
-    await first.bridge.start();
-    expect(first.ws.closeCode).toBe(4011);
+    await b.bridge.start();
+    expect(b.ws.closeCode).toBe(4011);
     expect(slotIsFree(h.manager)).toBe(true);
     expect(h.spawned).toEqual([]);
-
-    const retry = newBridge(h.manager, ensureInstalled);
-    retry.connectNow();
-    await retry.bridge.start();
-    expect(attempts).toBe(2);
-    expect(retry.ws.closeCode).toBeNull();
-    retry.bridge.handleClose();
-  });
-
-  test("shutdown during setup closes the viewer without starting a desktop", async () => {
-    const h = newFakeDesktop({ profileDir });
-    const install = Promise.withResolvers<void>();
-    const b = newBridge(h.manager, () => install.promise);
-    const started = b.bridge.start();
-    await h.manager.destroy();
-    expect(b.ws.closeCode).toBe(1001);
-    install.resolve();
-    await started;
-    expect(h.spawned).toEqual([]);
     expect(b.tcp.handlers).toBeUndefined();
   });
 

package/src/desktop/desktop-stream-bridge.ts

@@ -4,7 +4,7 @@
  * are signaled with close codes only (see `DESKTOP_CLOSE`).
  */
 
-import { desktopDependencyInstaller } from "./desktop-dependencies.js";
+import { desktopDependencies } from "./desktop-dependencies.js";
 import {
   connectLoopback,
   DESKTOP_CLOSE,
@@ -31,7 +31,7 @@ interface DesktopStreamClientSocket {
 interface DesktopStreamBridgeOptions {
   readonly isEnabled: () => boolean;
   readonly manager?: DesktopSessionManager;
-  readonly ensureInstalled?: () => Promise<void>;
+  readonly assertReady?: () => void;
   readonly connect?: (
     port: number,
     handlers: DesktopTcpHandlers,
@@ -42,7 +42,7 @@ export class DesktopStreamBridge {
   private readonly ws: DesktopStreamClientSocket;
   private readonly isEnabled: () => boolean;
   private readonly manager: DesktopSessionManager;
-  private readonly ensureInstalled: () => Promise<void>;
+  private readonly assertReady: () => void;
   private readonly connect: NonNullable<DesktopStreamBridgeOptions["connect"]>;
   private readonly viewer: DesktopViewer;
 
@@ -60,9 +60,8 @@ export class DesktopStreamBridge {
     this.ws = ws;
     this.isEnabled = options.isEnabled;
     this.manager = options.manager ?? getDesktopSessionManager();
-    this.ensureInstalled =
-      options.ensureInstalled ??
-      (() => desktopDependencyInstaller.ensureReady());
+    this.assertReady =
+      options.assertReady ?? (() => desktopDependencies.assertReady());
     this.connect = options.connect ?? connectLoopback;
     this.viewer = { onDesktopLost: (loss) => this.lose(loss) };
   }
@@ -80,8 +79,7 @@ export class DesktopStreamBridge {
     this.ownsSlot = true;
 
     try {
-      // Direct viewers share setup with the modal, including across reconnects.
-      await this.ensureInstalled();
+      this.assertReady();
       if (!this.checkEnabled()) {
         return;
       }