@vellumai/assistant 0.12.2 → 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
 // ---------------------------------------------------------------------------