@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

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

@@ -1,42 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,306 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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)
-  );
-}

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

@@ -1,135 +0,0 @@
-import * as fs from "node:fs";
-import {
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, expect, spyOn, test } from "bun:test";
-
-import { writeDesktopPanelConfig } from "./desktop-panel-config.js";
-
-const workspaces: string[] = [];
-
-afterEach(() => {
-  for (const dir of workspaces.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("initializes the dock and preserves user changes across restarts", () => {
-  const workspace = mkdtempSync(join(tmpdir(), "desktop-dock-"));
-  workspaces.push(workspace);
-  const configDir = join(workspace, "data", "desktop-panel");
-  const profileDir = join(workspace, "data", "desktop-profile");
-  mkdirSync(configDir, { recursive: true });
-  mkdirSync(profileDir, { recursive: true });
-  writeFileSync(join(profileDir, "Preferences"), "browser preferences");
-  writeFileSync(join(configDir, "wallpaper.png"), "keep");
-  const request = {
-    configDir,
-    chromiumPath: "/opt/chrome-v1/chrome",
-    chromiumProfileDir: profileDir,
-    terminalPath: "/usr/bin/xterm",
-  };
-  writeDesktopPanelConfig(request);
-  const settingsPath = join(configDir, "glib-2.0", "settings", "keyfile");
-  const pinsDir = join(configDir, "plank", "dock1", "launchers");
-  const settings = readFileSync(settingsPath, "utf8");
-  expect(settings.length).toBeGreaterThan(0);
-  expect(
-    readFileSync(join(pinsDir, "chrome.dockitem"), "utf8"),
-  ).not.toBeEmpty();
-
-  expect(readFileSync(join(pinsDir, "mines.dockitem"), "utf8")).toContain(
-    "applications/org.gnome.Mines.desktop",
-  );
-  expect(
-    readFileSync(
-      join(configDir, "applications", "org.gnome.Mines.desktop"),
-      "utf8",
-    ),
-  ).toContain("Exec=/usr/games/gnome-mines");
-
-  // Removed pins stay removed across restarts.
-  rmSync(join(pinsDir, "chrome.dockitem"));
-  rmSync(join(pinsDir, "mines.dockitem"));
-  const customSettings = settings.replace("icon-size=48", "icon-size=64");
-  writeFileSync(settingsPath, customSettings);
-  writeDesktopPanelConfig({
-    ...request,
-    chromiumPath: "/opt/chrome-v2/chrome",
-  });
-  expect(() => readFileSync(join(pinsDir, "chrome.dockitem"))).toThrow();
-  expect(() => readFileSync(join(pinsDir, "mines.dockitem"))).toThrow();
-  expect(readFileSync(settingsPath, "utf8")).toBe(customSettings);
-  expect(
-    readFileSync(
-      join(configDir, "applications", "google-chrome.desktop"),
-      "utf8",
-    ),
-  ).toContain("/opt/chrome-v2/chrome");
-  expect(readFileSync(join(profileDir, "Preferences"), "utf8")).toBe(
-    "browser preferences",
-  );
-  expect(readFileSync(join(configDir, "wallpaper.png"), "utf8")).toBe("keep");
-});
-
-test("initialization recovers partial pin creation", () => {
-  const workspace = mkdtempSync(join(tmpdir(), "desktop-dock-"));
-  workspaces.push(workspace);
-  const configDir = join(workspace, "data", "desktop-panel");
-  const pinsDir = join(configDir, "plank", "dock1", "launchers");
-  mkdirSync(pinsDir, { recursive: true });
-  writeFileSync(join(pinsDir, "chrome.dockitem"), "existing pin");
-  writeDesktopPanelConfig({
-    configDir,
-    chromiumPath: "/opt/chrome/chrome",
-    chromiumProfileDir: join(workspace, "data", "desktop-profile"),
-    terminalPath: "/usr/bin/xterm",
-  });
-  expect(readFileSync(join(pinsDir, "chrome.dockitem"), "utf8")).toBe(
-    "existing pin",
-  );
-  expect(
-    readFileSync(join(pinsDir, "terminal.dockitem"), "utf8"),
-  ).not.toBeEmpty();
-  expect(
-    readFileSync(join(configDir, "glib-2.0", "settings", "keyfile"), "utf8"),
-  ).not.toBeEmpty();
-});
-
-test("a failed settings write leaves initialization retryable", () => {
-  const workspace = mkdtempSync(join(tmpdir(), "desktop-dock-"));
-  workspaces.push(workspace);
-  const configDir = join(workspace, "data", "desktop-panel");
-  const settingsPath = join(configDir, "glib-2.0", "settings", "keyfile");
-  const request = {
-    configDir,
-    chromiumPath: "/opt/chrome/chrome",
-    chromiumProfileDir: join(workspace, "data", "desktop-profile"),
-    terminalPath: "/usr/bin/xterm",
-  };
-  const write = fs.writeFileSync;
-  const interrupted = spyOn(fs, "writeFileSync").mockImplementation(
-    (...args) => {
-      if (String(args[0]).startsWith(`${settingsPath}.`)) {
-        write(args[0], "partial settings");
-        throw new Error("interrupted write");
-      }
-      write(...args);
-    },
-  );
-  try {
-    expect(() => writeDesktopPanelConfig(request)).toThrow("interrupted write");
-  } finally {
-    interrupted.mockRestore();
-  }
-  expect(fs.existsSync(settingsPath)).toBe(false);
-  writeDesktopPanelConfig(request);
-  expect(readFileSync(settingsPath, "utf8")).not.toContain("partial settings");
-  expect(readFileSync(settingsPath, "utf8")).not.toBeEmpty();
-});