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

package/src/desktop/desktop-dependencies.ts

@@ -1,28 +1,4 @@
-import { createHash } from "node:crypto";
-import { createReadStream, existsSync } from "node:fs";
-import { chmod, mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { SYNC_TAGS } from "../daemon/message-types/sync.js";
-import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
-import { writeCombinedCABundle } from "../util/ca-bundle.js";
-import { terminateProcessTree } from "../util/host-process.js";
-import { getLogger } from "../util/logger.js";
-import { getExternalDir } from "../util/platform.js";
-
-const log = getLogger("desktop-dependencies");
-const CHROME_VERSION = "153.0.8010.36-1";
-const CHROME_PACKAGES = {
-  x64: {
-    arch: "amd64",
-    sha256: "9bb44e33031c2f2857cf36b4343051a12f93058e4b781e3c76313df87f6c8d32",
-  },
-  arm64: {
-    arch: "arm64",
-    sha256: "1fcf6ec51a9d52e26ff1ad807225f725be55069ad2b68c5d69361a2746665188",
-  },
-} as const;
+import { existsSync } from "node:fs";
 
 const DESKTOP_BINARIES = {
   xServer: ["Xtigervnc"],
@@ -30,45 +6,17 @@ const DESKTOP_BINARIES = {
   python: ["python3"],
   compositor: ["xcompmgr"],
   panel: ["plank"],
-  panelSession: ["dbus-run-session"],
+  sessionBus: ["dbus-daemon"],
   clipboard: ["tigervncconfig", "vncconfig"],
-  terminal: ["xterm"],
+  terminal: ["wezterm"],
+  fileManager: ["thunar"],
   wallpaper: ["feh"],
+  input: ["xdotool"],
+  capture: ["scrot"],
 } as const;
 
-const DESKTOP_PACKAGES = [
-  "dbus-x11",
-  "feh",
-  "gnome-mines",
-  "openbox",
-  "python3",
-  "tigervnc-standalone-server",
-  "tigervnc-common",
-  "plank",
-  "bamfdaemon",
-  "dbus-daemon",
-  "xauth",
-  "xcompmgr",
-  "xfonts-base",
-  "xterm",
-  "fonts-liberation",
-  "libgtk-3-0",
-  "libvulkan1",
-  "libcurl4",
-];
-
-export type DesktopSetupStatus = {
-  state: "required" | "installing" | "ready" | "failed" | "unsupported";
-  stage?: "packages" | "chrome" | "checking";
-};
-
 export function desktopChromePath(): string {
-  return join(
-    getExternalDir(),
-    "desktop",
-    `chrome-${CHROME_VERSION}`,
-    "opt/google/chrome/chrome",
-  );
+  return "/opt/google/chrome/chrome";
 }
 
 export function resolveDesktopBinaries(
@@ -85,245 +33,51 @@ export function resolveDesktopBinaries(
   return resolved;
 }
 
-export class DesktopDependencyInstaller {
-  private installing: Promise<void> | null = null;
-  private status: DesktopSetupStatus | null = null;
-
-  constructor(
-    private readonly dependencies: {
-      supported: () => boolean;
-      ready: () => boolean;
-      install: (
-        onStage: (stage: NonNullable<DesktopSetupStatus["stage"]>) => void,
-      ) => Promise<void>;
-      notify: () => Promise<unknown>;
-    } = {
-      supported: () =>
-        process.platform === "linux" &&
-        process.arch in CHROME_PACKAGES &&
-        process.getuid?.() === 0,
-      ready: () => {
-        try {
-          resolveDesktopBinaries();
-          return (
-            existsSync(desktopChromePath() + ".ready") &&
-            existsSync(desktopChromePath()) &&
-            existsSync("/usr/games/gnome-mines") &&
-            existsSync("/usr/share/fonts/X11/misc/fonts.dir") &&
-            existsSync("/usr/share/dbus-1/services/org.ayatana.bamf.service")
-          );
-        } catch {
-          return false;
-        }
-      },
-      install: installDesktopDependencies,
-      notify: () => publishSyncInvalidation([SYNC_TAGS.assistantDesktop]),
-    },
-  ) {}
-
-  getStatus(): DesktopSetupStatus {
-    if (this.installing) {
-      return this.status!;
-    }
-    if (!this.dependencies.supported()) {
-      return { state: "unsupported" };
-    }
-    if (this.status?.state === "failed") {
-      return this.status;
-    }
-    return { state: this.dependencies.ready() ? "ready" : "required" };
+function desktopSystemDependenciesReady(): boolean {
+  try {
+    resolveDesktopBinaries();
+    return (
+      existsSync("/usr/games/gnome-mines") &&
+      existsSync("/usr/share/dbus-1/services/org.gtk.vfs.Daemon.service") &&
+      existsSync(
+        "/usr/share/dbus-1/services/org.xfce.Tumbler.Thumbnailer1.service",
+      ) &&
+      existsSync("/usr/share/fonts/X11/misc/fonts.dir") &&
+      existsSync("/usr/share/dbus-1/services/org.ayatana.bamf.service") &&
+      existsSync("/usr/share/dbus-1/services/org.a11y.Bus.service") &&
+      existsSync("/usr/lib/python3/dist-packages/dbus/__init__.py")
+    );
+  } catch {
+    return false;
   }
+}
 
-  start(): DesktopSetupStatus {
-    const status = this.getStatus();
+export const desktopDependencies = {
+  getStatus(): { state: "ready" | "failed" | "unsupported" } {
     if (
-      status.state === "ready" ||
-      status.state === "installing" ||
-      status.state === "unsupported"
+      process.platform !== "linux" ||
+      !["x64", "arm64"].includes(process.arch) ||
+      process.getuid?.() !== 0
     ) {
-      return status;
-    }
-    this.status = { state: "installing", stage: "packages" };
-    this.installing = Promise.resolve()
-      .then(async () => {
-        await this.dependencies.install((stage) =>
-          this.update({ state: "installing", stage }),
-        );
-        if (!this.dependencies.ready()) {
-          throw new Error("Desktop components are missing after installation");
-        }
-        this.status = { state: "ready" };
-      })
-      .catch((err: unknown) => {
-        log.warn({ err }, "Desktop installation failed");
-        this.status = { state: "failed", stage: this.status?.stage };
-      })
-      .finally(() => {
-        this.installing = null;
-        this.update(this.status!);
-      });
-    this.update(this.status);
-    return this.status;
-  }
-
-  async ensureReady(signal?: AbortSignal): Promise<void> {
-    signal?.throwIfAborted();
-    this.start();
-    let onAbort: (() => void) | undefined;
-    try {
-      await new Promise<void>((resolve, reject) => {
-        onAbort = () => reject(signal?.reason);
-        signal?.addEventListener("abort", onAbort, { once: true });
-        void Promise.resolve(this.installing).then(() => resolve(), reject);
-      });
-      signal?.throwIfAborted();
-      const status = this.getStatus();
-      if (status.state === "unsupported") {
-        throw new Error(
-          "Virtual desktop installation is unsupported on this assistant.",
-        );
-      }
-      if (status.state !== "ready") {
-        throw new Error(
-          `Virtual desktop setup failed during ${status.stage ?? "installation"}. Open the Virtual desktop panel to retry. Do not launch Chrome manually.`,
-        );
-      }
-    } finally {
-      if (onAbort) {
-        signal?.removeEventListener("abort", onAbort);
-      }
+      return { state: "unsupported" };
     }
-  }
-
-  private update(status: DesktopSetupStatus): void {
-    this.status = status;
-    void this.dependencies.notify().catch((err: unknown) => {
-      log.warn({ err }, "Desktop setup notification failed");
-    });
-  }
-}
+    return {
+      state:
+        desktopSystemDependenciesReady() && existsSync(desktopChromePath())
+          ? "ready"
+          : "failed",
+    };
+  },
 
-async function run(command: string[]): Promise<void> {
-  const proc = Bun.spawn(command, {
-    env: {
-      PATH: "/usr/sbin:/usr/bin:/sbin:/bin",
-      HOME: "/root",
-      DEBIAN_FRONTEND: "noninteractive",
-    },
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-    windowsHide: true,
-    detached: true,
-  });
-  const timeout = setTimeout(() => terminateProcessTree(proc), 10 * 60_000);
-  let output = "";
-  const drain = async (stream: ReadableStream<Uint8Array>) => {
-    for await (const chunk of stream) {
-      output = (output + new TextDecoder().decode(chunk)).slice(-8_000);
+  assertReady(): void {
+    const { state } = this.getStatus();
+    if (state === "unsupported") {
+      throw new Error("Virtual desktop is unsupported on this assistant.");
     }
-  };
-  const [code] = await Promise.all([
-    proc.exited,
-    drain(proc.stdout),
-    drain(proc.stderr),
-  ]).finally(() => clearTimeout(timeout));
-  if (code !== 0) {
-    throw new Error(`Desktop installer exited with ${code}: ${output}`);
-  }
-}
-
-async function installDesktopDependencies(
-  onStage: (stage: NonNullable<DesktopSetupStatus["stage"]>) => void,
-): Promise<void> {
-  const extraCA = process.env.NODE_EXTRA_CA_CERTS;
-  if (!extraCA) {
-    return installDesktopComponents(onStage);
-  }
-  const caDir = await mkdtemp(join(tmpdir(), "desktop-ca-"));
-  try {
-    const caBundle = join(caDir, "ca.pem");
-    await writeCombinedCABundle(
-      "/etc/ssl/certs/ca-certificates.crt",
-      extraCA,
-      caBundle,
-    );
-    // apt's unprivileged downloader must be able to read the public CAs.
-    await chmod(caBundle, 0o644);
-    await chmod(caDir, 0o755);
-    await installDesktopComponents(onStage, caBundle);
-  } finally {
-    await rm(caDir, { recursive: true, force: true });
-  }
-}
-
-async function installDesktopComponents(
-  onStage: (stage: NonNullable<DesktopSetupStatus["stage"]>) => void,
-  caBundle?: string,
-): Promise<void> {
-  const chrome = CHROME_PACKAGES[process.arch as keyof typeof CHROME_PACKAGES];
-  const apt = [
-    "/usr/bin/apt-get",
-    ...(caBundle ? ["-o", `Acquire::https::CaInfo=${caBundle}`] : []),
-  ];
-  await rm(desktopChromePath() + ".ready", { force: true });
-  // Desktop binaries, X assets and the loader share the image root.
-  await run([...apt, "update"]);
-  await run([
-    ...apt,
-    "install",
-    "-y",
-    "--no-install-recommends",
-    "--no-upgrade",
-    "--no-remove",
-    "-o",
-    "DPkg::Lock::Timeout=120",
-    ...DESKTOP_PACKAGES,
-  ]);
-  onStage("chrome");
-  if (!existsSync(desktopChromePath())) {
-    const downloadDir = await mkdtemp(join(tmpdir(), "desktop-chrome-"));
-    const installRoot = join(getExternalDir(), "desktop");
-    await mkdir(installRoot, { recursive: true });
-    const staging = await mkdtemp(join(installRoot, ".install-"));
-    try {
-      const deb = join(downloadDir, "chrome.deb");
-      await run([
-        "curl",
-        ...(caBundle ? ["--cacert", caBundle] : []),
-        "--fail",
-        "--location",
-        "--proto",
-        "=https",
-        "--proto-redir",
-        "=https",
-        "--retry",
-        "2",
-        "--max-time",
-        "300",
-        "--output",
-        deb,
-        `https://dl.google.com/linux/chrome/deb/pool/main/g/google-chrome-stable/google-chrome-stable_${CHROME_VERSION}_${chrome.arch}.deb`,
-      ]);
-      const hash = createHash("sha256");
-      for await (const chunk of createReadStream(deb)) {
-        hash.update(chunk);
-      }
-      if (hash.digest("hex") !== chrome.sha256) {
-        throw new Error("Chrome download checksum mismatch");
-      }
-      await run(["dpkg-deb", "--extract", deb, staging]);
-      await rename(staging, join(installRoot, `chrome-${CHROME_VERSION}`));
-    } finally {
-      await Promise.all([
-        rm(downloadDir, { recursive: true, force: true }),
-        rm(staging, { recursive: true, force: true }),
-      ]);
+    if (state !== "ready") {
+      throw new Error(
+        "Desktop components are missing from the assistant image. Update the assistant image. Do not install packages or launch Chrome manually.",
+      );
     }
-  }
-  onStage("checking");
-  await run([desktopChromePath(), "--version"]);
-  await writeFile(desktopChromePath() + ".ready", "");
-}
-
-export const desktopDependencyInstaller = new DesktopDependencyInstaller();
+  },
+};

package/src/desktop/desktop-display.ts

@@ -1,6 +1,6 @@
 export const DESKTOP_DISPLAY = ":99";
-export const DESKTOP_WIDTH = 1600;
-export const DESKTOP_HEIGHT = 900;
+export const DESKTOP_WIDTH = 1440;
+export const DESKTOP_HEIGHT = 810;
 export const DESKTOP_OVERRIDABLE_PARAMETERS = [
   "desktop",
   "SendCutText",

package/src/desktop/desktop-panel-config.test.ts

@@ -33,7 +33,9 @@ test("initializes the dock and preserves user changes across restarts", () => {
     configDir,
     chromiumPath: "/opt/chrome-v1/chrome",
     chromiumProfileDir: profileDir,
-    terminalPath: "/usr/bin/xterm",
+    terminalPath: "/usr/bin/wezterm",
+    fileManagerPath: "/usr/bin/thunar",
+    workspaceDir: workspace,
   };
   writeDesktopPanelConfig(request);
   const settingsPath = join(configDir, "glib-2.0", "settings", "keyfile");
@@ -59,6 +61,9 @@ test("initializes the dock and preserves user changes across restarts", () => {
   rmSync(join(pinsDir, "mines.dockitem"));
   const customSettings = settings.replace("icon-size=48", "icon-size=64");
   writeFileSync(settingsPath, customSettings);
+  const terminalConfig = join(configDir, "wezterm", "wezterm.lua");
+  const customTerminalConfig = `${readFileSync(terminalConfig, "utf8")}\n-- Custom settings\n`;
+  writeFileSync(terminalConfig, customTerminalConfig);
   writeDesktopPanelConfig({
     ...request,
     chromiumPath: "/opt/chrome-v2/chrome",
@@ -66,6 +71,7 @@ test("initializes the dock and preserves user changes across restarts", () => {
   expect(() => readFileSync(join(pinsDir, "chrome.dockitem"))).toThrow();
   expect(() => readFileSync(join(pinsDir, "mines.dockitem"))).toThrow();
   expect(readFileSync(settingsPath, "utf8")).toBe(customSettings);
+  expect(readFileSync(terminalConfig, "utf8")).toBe(customTerminalConfig);
   expect(
     readFileSync(
       join(configDir, "applications", "google-chrome.desktop"),
@@ -89,7 +95,9 @@ test("initialization recovers partial pin creation", () => {
     configDir,
     chromiumPath: "/opt/chrome/chrome",
     chromiumProfileDir: join(workspace, "data", "desktop-profile"),
-    terminalPath: "/usr/bin/xterm",
+    terminalPath: "/usr/bin/wezterm",
+    fileManagerPath: "/usr/bin/thunar",
+    workspaceDir: workspace,
   });
   expect(readFileSync(join(pinsDir, "chrome.dockitem"), "utf8")).toBe(
     "existing pin",
@@ -111,7 +119,9 @@ test("a failed settings write leaves initialization retryable", () => {
     configDir,
     chromiumPath: "/opt/chrome/chrome",
     chromiumProfileDir: join(workspace, "data", "desktop-profile"),
-    terminalPath: "/usr/bin/xterm",
+    terminalPath: "/usr/bin/wezterm",
+    fileManagerPath: "/usr/bin/thunar",
+    workspaceDir: workspace,
   };
   const write = fs.writeFileSync;
   const interrupted = spyOn(fs, "writeFileSync").mockImplementation(

package/src/desktop/desktop-panel-config.ts

@@ -3,13 +3,21 @@ import {
   existsSync,
   linkSync,
   mkdirSync,
+  readFileSync,
+  renameSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 
-import { desktopChromeArguments } from "./desktop-browser-endpoint.js";
+import {
+  DESKTOP_CHROME_WINDOW_CLASS,
+  desktopChromeArguments,
+} from "./desktop-browser-endpoint.js";
+
+const TERMINAL_WINDOW_CLASS = "vellum-desktop-terminal";
+const TERMINAL_HEADER_CONFIG = "  window_decorations = 'TITLE|RESIZE',\n";
 
 // Absolute icon paths work without an installed icon theme.
 const TERMINAL_ICON_BASE64 = [
@@ -34,6 +42,8 @@ export interface DesktopPanelConfigRequest {
   /** Profile the launcher shares with that browser, so it reuses the window. */
   readonly chromiumProfileDir: string;
   readonly terminalPath: string;
+  readonly fileManagerPath: string;
+  readonly workspaceDir: string;
   readonly debugPort?: number;
 }
 
@@ -50,41 +60,69 @@ export function writeDesktopPanelConfig(
     "product_logo_64.png",
   );
   writeFileSync(terminalIcon, Buffer.from(TERMINAL_ICON_BASE64, "base64"));
+  const terminalConfig = join(configDir, "wezterm", "wezterm.lua");
+  mkdirSync(dirname(terminalConfig), { recursive: true });
+  const terminalConfigContents = `local wezterm = require 'wezterm'
+return {
+  front_end = 'Software',
+  enable_wayland = false,
+  check_for_updates = false,
+  hide_tab_bar_if_only_one_tab = false,
+${TERMINAL_HEADER_CONFIG}  font_size = 11,
+  color_scheme = 'Catppuccin Mocha',
+  initial_cols = 110,
+  initial_rows = 28,
+  keys = {
+    { key = 'd', mods = 'CTRL|SHIFT', action = wezterm.action.SplitHorizontal { domain = 'CurrentPaneDomain' } },
+    { key = 'e', mods = 'CTRL|SHIFT', action = wezterm.action.SplitVertical { domain = 'CurrentPaneDomain' } },
+  },
+}
+`;
+  seedFile(terminalConfig, terminalConfigContents, [
+    terminalConfigContents.replace(TERMINAL_HEADER_CONFIG, ""),
+    ...["", "  integrated_title_buttons = { 'Maximize', 'Close' },\n"].map(
+      (buttons) =>
+        terminalConfigContents.replace(
+          TERMINAL_HEADER_CONFIG,
+          `  window_decorations = 'INTEGRATED_BUTTONS|RESIZE',\n  integrated_title_button_style = 'Gnome',\n${buttons}`,
+        ),
+    ),
+  ]);
 
   const applicationsDir = join(configDir, "applications");
   mkdirSync(applicationsDir, { recursive: true });
   const chromiumEntry = join(applicationsDir, "google-chrome.desktop");
+  // Saved dock pins reference this stable launcher path.
   const terminalEntry = join(applicationsDir, "xterm.desktop");
+  const filesEntry = join(applicationsDir, "thunar.desktop");
   const minesEntry = join(applicationsDir, "org.gnome.Mines.desktop");
   writeFileSync(
     chromiumEntry,
     desktopEntry({
       name: "Google Chrome",
-      // Chrome includes its profile path in WM_CLASS.
-      windowClass: `google-chrome (${request.chromiumProfileDir})`,
+      windowClass: DESKTOP_CHROME_WINDOW_CLASS,
       icon: browserIcon,
-      exec: [
+      exec: desktopCommand([
         request.chromiumPath,
         ...desktopChromeArguments(
           request.chromiumProfileDir,
           request.debugPort,
         ),
-      ]
-        .map(
-          (arg) => `"${arg.replace(/[\\"`$]/g, "\\$&").replace(/%/g, "%%")}"`,
-        )
-        .join(" "),
+      ]),
     }),
   );
   writeFileSync(
     terminalEntry,
     desktopEntry({
       name: "Terminal",
-      windowClass: "XTerm",
+      windowClass: TERMINAL_WINDOW_CLASS,
       icon: terminalIcon,
-      // `-fa` picks a scalable font through fontconfig; xterm otherwise falls
-      // back to the `fixed` bitmap, which is unreadable at this geometry.
-      exec: `"${request.terminalPath}" -fa Monospace -fs 11 -bg '#1c1c22' -fg '#e6e6ea' -title Terminal`,
+      exec: desktopCommand([
+        request.terminalPath,
+        "start",
+        "--new-tab",
+        `--class=${TERMINAL_WINDOW_CLASS}`,
+      ]),
     }),
   );
 
@@ -98,6 +136,37 @@ export function writeDesktopPanelConfig(
     }),
   );
 
+  writeFileSync(
+    filesEntry,
+    desktopEntry({
+      name: "Files",
+      windowClass: "Thunar",
+      icon: "/usr/share/icons/Adwaita/scalable/places/folder.svg",
+      exec: desktopCommand([request.fileManagerPath, request.workspaceDir]),
+    }),
+  );
+
+  const gtkDir = join(configDir, "gtk-3.0");
+  const xfconfDir = join(configDir, "xfce4", "xfconf", "xfce-perchannel-xml");
+  mkdirSync(gtkDir, { recursive: true });
+  mkdirSync(xfconfDir, { recursive: true });
+  seedFile(
+    join(gtkDir, "settings.ini"),
+    "[Settings]\ngtk-theme-name=Adwaita\ngtk-icon-theme-name=Adwaita\ngtk-application-prefer-dark-theme=true\ngtk-font-name=Sans 11\n",
+  );
+  seedFile(
+    join(gtkDir, "bookmarks"),
+    `${pathToFileURL(request.workspaceDir).href} Workspace\n`,
+  );
+  seedFile(
+    join(xfconfDir, "thunar.xml"),
+    `<channel name="thunar" version="1.0">
+  <property name="last-window-width" type="int" value="1000"/>
+  <property name="last-window-height" type="int" value="680"/>
+  <property name="last-view" type="string" value="ThunarDetailsView"/>
+</channel>\n`,
+  );
+
   const launchersDir = join(configDir, "plank", "dock1", "launchers");
   const settingsDir = join(configDir, "glib-2.0", "settings");
   mkdirSync(launchersDir, { recursive: true });
@@ -107,13 +176,14 @@ export function writeDesktopPanelConfig(
     return;
   }
   seedFile(join(launchersDir, "chrome.dockitem"), dockItem(chromiumEntry));
+  seedFile(join(launchersDir, "files.dockitem"), dockItem(filesEntry));
   seedFile(join(launchersDir, "terminal.dockitem"), dockItem(terminalEntry));
   seedFile(join(launchersDir, "mines.dockitem"), dockItem(minesEntry));
   seedFile(
     join(settingsDir, "keyfile"),
     [
       "[net/launchpad/plank/docks/dock1]",
-      "dock-items=['chrome.dockitem', 'terminal.dockitem', 'mines.dockitem']",
+      "dock-items=['chrome.dockitem', 'files.dockitem', 'terminal.dockitem', 'mines.dockitem']",
       "icon-size=48",
       "hide-mode='none'",
       "theme='Matte'",
@@ -127,7 +197,25 @@ function dockItem(launcher: string): string {
   return `[PlankDockItemPreferences]\nLauncher=${pathToFileURL(launcher).href}\n`;
 }
 
-function seedFile(path: string, contents: string): void {
+function desktopCommand(args: string[]): string {
+  return args
+    .map((arg) => {
+      const quoted = `"${arg.replace(/[\\"`$]/g, "\\$&").replace(/%/g, "%%")}"`;
+      // Desktop values are unescaped before Exec arguments are parsed.
+      return quoted
+        .replace(/\\/g, "\\\\")
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t");
+    })
+    .join(" ");
+}
+
+function seedFile(
+  path: string,
+  contents: string,
+  previousContents: readonly string[] = [],
+): void {
   const temporaryPath = `${path}.${randomUUID()}.tmp`;
   try {
     writeFileSync(temporaryPath, contents, { flush: true });
@@ -137,6 +225,12 @@ function seedFile(path: string, contents: string): void {
     if ((err as NodeJS.ErrnoException).code !== "EEXIST") {
       throw err;
     }
+    if (
+      previousContents.length > 0 &&
+      previousContents.includes(readFileSync(path, "utf8"))
+    ) {
+      renameSync(temporaryPath, path);
+    }
   } finally {
     rmSync(temporaryPath, { force: true });
   }