@vellumai/assistant 0.12.0 → 0.12.1-dev.202609141913.5e16607

package/src/desktop/__tests__/fake-desktop.ts

@@ -0,0 +1,119 @@
+import { join } from "node:path";
+
+import { sleep } from "../../util/retry.js";
+import {
+  type DesktopChild,
+  type DesktopChildRole,
+  type DesktopLoss,
+  DesktopSessionManager,
+  type DesktopSpawnRequest,
+} from "../desktop-session-manager.js";
+
+/** A child the test exits by hand. */
+class FakeChild implements DesktopChild {
+  private static nextPid = 1000;
+  readonly pid = FakeChild.nextPid++;
+  readonly exited: Promise<number>;
+  private settle!: (code: number) => void;
+
+  constructor(
+    readonly role: DesktopChildRole,
+    readonly request: DesktopSpawnRequest,
+  ) {
+    this.exited = new Promise((resolve) => {
+      this.settle = resolve;
+    });
+  }
+
+  kill(): void {}
+
+  exit(code = 0): void {
+    this.settle(code);
+  }
+}
+
+export const LINGER_MS = 20;
+export const KILL_GRACE_MS = 20;
+
+export interface FakeDesktopOptions {
+  profileDir: string;
+  /** Defaults inside `profileDir`, for tests that ignore the dock's config. */
+  panelConfigDir?: string;
+  /** Roles whose spawn throws, to exercise a start that fails partway. */
+  failSpawn?: DesktopChildRole[];
+  /** Binaries `which` cannot find. */
+  missingBinaries?: string[];
+  /** Whether a SIGTERM makes the fake child exit on its own. */
+  exitOnTerm?: boolean;
+  /** Whether a SIGKILL does; without either the child survives both. */
+  exitOnKill?: boolean;
+  sourceEnv?: NodeJS.ProcessEnv;
+  renderWallpaper?: (width: number, height: number) => Promise<Buffer | null>;
+}
+
+export function newFakeDesktop(options: FakeDesktopOptions) {
+  const spawned: FakeChild[] = [];
+  const killed: { child: FakeChild; signal: string }[] = [];
+  let vncReady = true;
+  let chromiumPath: () => Promise<string> = async () => "/fake/chromium";
+  const manager = new DesktopSessionManager({
+    spawn: (role, request) => {
+      if (options.failSpawn?.includes(role)) {
+        throw new Error(`spawn ${role} failed`);
+      }
+      const child = new FakeChild(role, request);
+      spawned.push(child);
+      return child;
+    },
+    which: (binary) =>
+      options.missingBinaries?.includes(binary) ? null : `/usr/bin/${binary}`,
+    probeVncPort: async () => vncReady,
+    resolveChromePath: () => chromiumPath(),
+    renderWallpaper: options.renderWallpaper ?? (async () => null),
+    killProcessGroup: (child, signal) => {
+      killed.push({ child: child as FakeChild, signal });
+      const exits =
+        signal === "SIGTERM" ? options.exitOnTerm : options.exitOnKill;
+      if (exits) {
+        (child as FakeChild).exit(0);
+      }
+    },
+    lingerMs: LINGER_MS,
+    readyDeadlineMs: 30,
+    killGraceMs: KILL_GRACE_MS,
+    profileDir: options.profileDir,
+    panelConfigDir:
+      options.panelConfigDir ?? join(options.profileDir, "desktop-panel"),
+    sourceEnv: options.sourceEnv,
+  });
+  return {
+    manager,
+    spawned,
+    killed,
+    /** Children that got a SIGTERM, in order. */
+    terminated: () =>
+      killed.filter((k) => k.signal === "SIGTERM").map((k) => k.child),
+    setVncReady: (ready: boolean) => {
+      vncReady = ready;
+    },
+    setChromiumPath: (resolve: () => Promise<string>) => {
+      chromiumPath = resolve;
+    },
+    child: (role: DesktopChildRole) =>
+      spawned.filter((c) => c.role === role).at(-1)!,
+    roles: () => spawned.map((c) => c.role),
+    count: (role: DesktopChildRole) =>
+      spawned.filter((c) => c.role === role).length,
+  };
+}
+
+/** Let one awaited step (a path resolution, an exit callback) land. */
+export const settle = (): Promise<void> => sleep(0);
+
+export function newViewer() {
+  const lost: DesktopLoss[] = [];
+  return {
+    lost,
+    viewer: { onDesktopLost: (loss: DesktopLoss) => lost.push(loss) },
+  };
+}

package/src/desktop/desktop-chrome-policy.test.ts

@@ -0,0 +1,71 @@
+import {
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, expect, test } from "bun:test";
+
+import { writeDesktopChromePolicy } from "./desktop-chrome-policy.js";
+
+const directories: string[] = [];
+function policyDirectory(): string {
+  const path = mkdtempSync(join(tmpdir(), "desktop-chrome-policy-"));
+  directories.push(path);
+  return path;
+}
+
+afterEach(() => {
+  for (const path of directories.splice(0)) {
+    rmSync(path, { recursive: true, force: true });
+  }
+});
+
+test("preserves unrelated policies and does not rewrite on repeated startup", () => {
+  const directory = policyDirectory();
+  const path = join(directory, "vellum-desktop.json");
+  const otherPath = join(directory, "organization.json");
+  const unrelated = '{ "HomepageLocation": "https://example.com" }\n';
+  writeFileSync(otherPath, unrelated);
+  writeFileSync(path, JSON.stringify({ DownloadRestrictions: 1 }));
+
+  writeDesktopChromePolicy(directory);
+  const content = readFileSync(path, "utf8");
+  expect(JSON.parse(content).DownloadRestrictions).toBe(1);
+  expect(readFileSync(otherPath, "utf8")).toBe(unrelated);
+  expect(readdirSync(directory).sort()).toEqual([
+    "organization.json",
+    "vellum-desktop.json",
+  ]);
+
+  const before = statSync(path);
+  writeDesktopChromePolicy(directory);
+  expect(readFileSync(path, "utf8")).toBe(content);
+  expect(statSync(path).ino).toBe(before.ino);
+  expect(statSync(path).mtimeMs).toBe(before.mtimeMs);
+});
+
+test("creates missing policy directories for a fresh desktop", () => {
+  const directory = join(policyDirectory(), "policies", "managed");
+  writeDesktopChromePolicy(directory);
+  expect(readdirSync(directory)).toEqual(["vellum-desktop.json"]);
+  expect(statSync(join(directory, "vellum-desktop.json")).mode & 0o777).toBe(
+    0o644,
+  );
+});
+
+test.each(["{broken", "[]", "null", "false"])(
+  "leaves invalid existing policy content untouched: %s",
+  (content) => {
+    const directory = policyDirectory();
+    const path = join(directory, "vellum-desktop.json");
+    writeFileSync(path, content);
+    expect(() => writeDesktopChromePolicy(directory)).toThrow();
+    expect(readFileSync(path, "utf8")).toBe(content);
+    expect(readdirSync(directory)).toEqual(["vellum-desktop.json"]);
+  },
+);

package/src/desktop/desktop-chrome-policy.ts

@@ -0,0 +1,42 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+export function writeDesktopChromePolicy(policyDir: string): void {
+  const path = join(policyDir, "vellum-desktop.json");
+  let policy: Record<string, unknown> = {};
+  try {
+    const value: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("Desktop Chrome policy must be a JSON object");
+    }
+    policy = value as Record<string, unknown>;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw err;
+    }
+  }
+  if (policy.CommandLineFlagSecurityWarningsEnabled === false) {
+    return;
+  }
+
+  // This suppresses command-line warnings; Chrome's sandbox stays unchanged.
+  policy.CommandLineFlagSecurityWarningsEnabled = false;
+  mkdirSync(policyDir, { recursive: true });
+  const staging = mkdtempSync(join(policyDir, ".vellum-desktop-"));
+  try {
+    const temporaryPath = join(staging, "policy.json");
+    writeFileSync(temporaryPath, JSON.stringify(policy, null, 2) + "\n", {
+      mode: 0o644,
+    });
+    renameSync(temporaryPath, path);
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}

package/src/desktop/desktop-dependencies.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import {
+  DesktopDependencyInstaller,
+  type DesktopSetupStatus,
+} from "./desktop-dependencies.js";
+
+const flush = async () => {
+  for (let i = 0; i < 10; i++) {
+    await Promise.resolve();
+  }
+};
+
+function setup() {
+  let ready = false;
+  let supported = true;
+  let finish!: () => void;
+  let fail!: (err: Error) => void;
+  let progress!: (stage: NonNullable<DesktopSetupStatus["stage"]>) => void;
+  const notify = mock(async () => {});
+  const install = mock((onStage: typeof progress) => {
+    progress = onStage;
+    return new Promise<void>((resolve, reject) => {
+      finish = () => {
+        ready = true;
+        resolve();
+      };
+      fail = reject;
+    });
+  });
+  const installer = new DesktopDependencyInstaller({
+    supported: () => supported,
+    ready: () => ready,
+    install,
+    notify,
+  });
+  return {
+    installer,
+    install,
+    notify,
+    finish: () => finish(),
+    fail: () => fail(new Error("download failed")),
+    progress: () => progress("chrome"),
+    restoreComponents: () => {
+      ready = true;
+    },
+    removeComponents: () => {
+      ready = false;
+    },
+    unsupported: () => {
+      supported = false;
+    },
+  };
+}
+
+describe("desktop dependency installation", () => {
+  test("status is read only and repeated starts share one install", async () => {
+    const f = setup();
+    expect(f.installer.getStatus().state).toBe("required");
+    expect(f.install).not.toHaveBeenCalled();
+    expect(f.installer.start().state).toBe("installing");
+    f.installer.start();
+    await flush();
+    expect(f.install).toHaveBeenCalledTimes(1);
+    f.progress();
+    expect(f.installer.getStatus()).toEqual({
+      state: "installing",
+      stage: "chrome",
+    });
+    f.finish();
+    await flush();
+    expect(f.installer.getStatus().state).toBe("ready");
+    f.installer.start();
+    expect(f.install).toHaveBeenCalledTimes(1);
+    expect(f.notify).toHaveBeenCalledTimes(3);
+    f.removeComponents();
+    expect(f.installer.getStatus().state).toBe("required");
+  });
+
+  test("a failed install releases the job and retries without starting a desktop", async () => {
+    const f = setup();
+    f.installer.start();
+    await flush();
+    f.restoreComponents();
+    f.fail();
+    await flush();
+    expect(f.installer.getStatus().state).toBe("failed");
+    f.installer.start();
+    await flush();
+    expect(f.install).toHaveBeenCalledTimes(2);
+    f.finish();
+    await flush();
+    expect(f.installer.getStatus().state).toBe("ready");
+  });
+
+  test("unsupported environments cannot trigger installation", () => {
+    const f = setup();
+    f.unsupported();
+    expect(f.installer.start().state).toBe("unsupported");
+    expect(f.install).not.toHaveBeenCalled();
+  });
+});

package/src/desktop/desktop-dependencies.ts

@@ -0,0 +1,306 @@
+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;
+
+const DESKTOP_BINARIES = {
+  xServer: ["Xtigervnc"],
+  windowManager: ["openbox"],
+  compositor: ["xcompmgr"],
+  panel: ["plank"],
+  panelSession: ["dbus-run-session"],
+  clipboard: ["tigervncconfig", "vncconfig"],
+  terminal: ["xterm"],
+  wallpaper: ["feh"],
+} as const;
+
+const DESKTOP_PACKAGES = [
+  "dbus-x11",
+  "feh",
+  "gnome-mines",
+  "openbox",
+  "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",
+  );
+}
+
+export function resolveDesktopBinaries(
+  which: (name: string) => string | null = Bun.which,
+) {
+  const resolved = {} as Record<keyof typeof DESKTOP_BINARIES, string>;
+  for (const [role, names] of Object.entries(DESKTOP_BINARIES)) {
+    const path = names.map((name) => which(name)).find(Boolean);
+    if (!path) {
+      throw new Error(`Desktop component is missing: ${names[0]}`);
+    }
+    resolved[role as keyof typeof DESKTOP_BINARIES] = path;
+  }
+  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" };
+  }
+
+  start(): DesktopSetupStatus {
+    const status = this.getStatus();
+    if (
+      status.state === "ready" ||
+      status.state === "installing" ||
+      status.state === "unsupported"
+    ) {
+      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" };
+      })
+      .finally(() => {
+        this.installing = null;
+        this.update(this.status!);
+      });
+    this.update(this.status);
+    return this.status;
+  }
+
+  async ensureReady(): Promise<void> {
+    this.start();
+    await this.installing;
+    if (this.getStatus().state !== "ready") {
+      throw new Error("Desktop setup did not complete");
+    }
+  }
+
+  private update(status: DesktopSetupStatus): void {
+    this.status = status;
+    void this.dependencies.notify().catch((err: unknown) => {
+      log.warn({ err }, "Desktop setup notification 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);
+    }
+  };
+  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 }),
+      ]);
+    }
+  }
+  onStage("checking");
+  await run([desktopChromePath(), "--version"]);
+  await writeFile(desktopChromePath() + ".ready", "");
+}
+
+export const desktopDependencyInstaller = new DesktopDependencyInstaller();

package/src/desktop/desktop-feature.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "bun:test";
+
+import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
+import type { AssistantConfig } from "../config/schema.js";
+import { isAssistantDesktopEnabled } from "./desktop-feature.js";
+
+describe("isAssistantDesktopEnabled", () => {
+  const config = {} as AssistantConfig;
+
+  test("needs both the flag and a containerized runtime", () => {
+    setOverridesForTesting({ "assistant-desktop": true });
+    expect(isAssistantDesktopEnabled(config, true)).toBe(true);
+    expect(isAssistantDesktopEnabled(config, false)).toBe(false);
+
+    setOverridesForTesting({ "assistant-desktop": false });
+    expect(isAssistantDesktopEnabled(config, true)).toBe(false);
+  });
+});

package/src/desktop/desktop-feature.ts

@@ -0,0 +1,19 @@
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { getIsContainerized } from "../config/env-registry.js";
+import type { AssistantConfig } from "../config/schema.js";
+
+const ASSISTANT_DESKTOP_FLAG = "assistant-desktop" as const;
+
+/**
+ * Whether this daemon serves `/v1/desktop/stream`: the `assistant-desktop` flag
+ * plus a containerized runtime where desktop components can be installed.
+ */
+export function isAssistantDesktopEnabled(
+  config: AssistantConfig,
+  containerized: boolean = getIsContainerized(),
+): boolean {
+  return (
+    containerized &&
+    isAssistantFeatureFlagEnabled(ASSISTANT_DESKTOP_FLAG, config)
+  );
+}