@vellumai/assistant 0.12.1 → 0.12.2-dev.202609162214.308bda0

package/src/desktop/desktop-browser-operations.ts

@@ -0,0 +1,130 @@
+import { executeBrowserOperation } from "../browser/operations.js";
+import type { BrowserOperation } from "../browser/types.js";
+import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+import { desktopAutomationLease } from "./desktop-automation-lease.js";
+import { getDesktopSessionManager } from "./desktop-session-manager.js";
+
+export function executeDesktopBrowserOperation(
+  operation: BrowserOperation,
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  if (
+    input.target_client_id ||
+    (input.browser_mode &&
+      input.browser_mode !== "auto" &&
+      input.browser_mode !== "cdp-inspect")
+  ) {
+    throw new Error(
+      "--virtual-desktop targets the streamed Chrome directly. Omit other browser targets and modes.",
+    );
+  }
+  if (input.use_active_tab) {
+    throw new Error(
+      "Use assistant browser --virtual-desktop tabs list and tabs select to choose a streamed browser tab.",
+    );
+  }
+  if (operation === "wait_for_download") {
+    throw new Error(
+      "Download waiting is unavailable for the streamed desktop browser",
+    );
+  }
+  return desktopAutomationLease.runBrowser(
+    context,
+    async (signal) => {
+      const cdpClient = await getDesktopSessionManager().browser.client(
+        context.conversationId,
+        signal,
+      );
+      if (operation === "status") {
+        await cdpClient.listTabs();
+        return {
+          isError: false,
+          content: JSON.stringify({
+            requestedMode: "desktop",
+            recommendedMode: "desktop",
+            modes: [
+              {
+                mode: "desktop",
+                available: true,
+                summary:
+                  "Virtual desktop Chrome is ready. Use assistant browser --virtual-desktop commands.",
+                userActions: [],
+              },
+            ],
+          }),
+        };
+      }
+      const browser = getDesktopSessionManager().browser;
+      const generation = browser.generation;
+      const result = await executeBrowserOperation(operation, input, {
+        ...context,
+        signal,
+        cdpClient,
+      });
+      if (operation === "snapshot" && generation !== browser.generation) {
+        browser.invalidateSnapshot();
+        return {
+          isError: true,
+          content:
+            "The page changed during the snapshot. Take a fresh snapshot before acting.",
+        };
+      }
+      return result;
+    },
+    operation === "detach" || operation === "close",
+  );
+}
+
+export function executeDesktopBrowserTabs(
+  params: {
+    command: "list" | "select" | "new" | "close";
+    tabId?: number;
+    url?: string;
+  },
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return desktopAutomationLease.runBrowser(context, async (signal) => {
+    const cdpClient = await getDesktopSessionManager().browser.client(
+      context.conversationId,
+      signal,
+    );
+    let result: unknown;
+    if (params.command === "list") {
+      const tabs = await cdpClient.listTabs();
+      result = {
+        ok: true,
+        tabs: [
+          ...tabs.filter((tab) => tab.active),
+          ...tabs.filter((tab) => !tab.active),
+        ].slice(0, 100),
+      };
+    } else if (params.command === "new") {
+      const created = await cdpClient.send<{ tabId: number }>(
+        "Vellum.createTab",
+        {},
+        signal,
+      );
+      if (params.url) {
+        const navigated = await executeBrowserOperation(
+          "navigate",
+          { url: params.url },
+          { ...context, signal, cdpClient },
+        );
+        if (navigated.isError) {
+          return navigated;
+        }
+      }
+      result = { ok: true, ...created };
+    } else {
+      if (params.tabId === undefined) {
+        throw new Error("A tab ID is required");
+      }
+      result =
+        params.command === "select"
+          ? { ok: true, tab: await cdpClient.selectTab(params.tabId) }
+          : { ok: true, ...(await cdpClient.closeTab(params.tabId)) };
+    }
+    return { isError: false, content: JSON.stringify(result) };
+  });
+}

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

@@ -0,0 +1,79 @@
+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({
+      CommandLineFlagSecurityWarningsEnabled: false,
+      DownloadRestrictions: 1,
+    }),
+  );
+  const original = statSync(path);
+
+  writeDesktopChromePolicy(directory);
+  const content = readFileSync(path, "utf8");
+  expect(statSync(path).ino).not.toBe(original.ino);
+  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,47 @@
+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 &&
+    policy.PasswordManagerEnabled === false
+  ) {
+    return;
+  }
+
+  // This suppresses command-line warnings; Chrome's sandbox stays unchanged.
+  policy.CommandLineFlagSecurityWarningsEnabled = false;
+  // Suppress save prompts while keeping previously saved passwords usable.
+  policy.PasswordManagerEnabled = 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-chrome-session.test.ts

@@ -0,0 +1,48 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, expect, test } from "bun:test";
+
+import { configureDesktopChromeFrame } from "./desktop-chrome-session.js";
+
+const directories: string[] = [];
+
+afterEach(() => {
+  for (const directory of directories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test.each(["{truncated", "[]", '{"browser":[]}'])(
+  "leaves unreadable or malformed preferences untouched: %s",
+  (contents) => {
+    const directory = mkdtempSync(join(tmpdir(), "desktop-frame-"));
+    directories.push(directory);
+    mkdirSync(join(directory, "Default"));
+    const path = join(directory, "Default", "Preferences");
+    writeFileSync(path, contents);
+
+    expect(() => configureDesktopChromeFrame(directory)).toThrow();
+    expect(readFileSync(path, "utf8")).toBe(contents);
+  },
+);
+
+test("does not rewrite an already configured profile", () => {
+  const directory = mkdtempSync(join(tmpdir(), "desktop-frame-"));
+  directories.push(directory);
+  mkdirSync(join(directory, "Default"));
+  const path = join(directory, "Default", "Preferences");
+  const contents =
+    '{ "browser": { "custom_chrome_frame": true }, "profile": { "exit_type": "Crashed" } }';
+  writeFileSync(path, contents);
+
+  configureDesktopChromeFrame(directory);
+
+  expect(readFileSync(path, "utf8")).toBe(contents);
+});

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

@@ -0,0 +1,87 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+import { isPlainObject } from "../util/object.js";
+
+export function shouldRestoreDesktopChromeSession(profileDir: string): boolean {
+  return (
+    readProfileMetadata(chromePreferencesPath(profileDir))?.exit_type ===
+    "Crashed"
+  );
+}
+
+/** Configure Chrome's own title bar before the browser or dock starts. */
+export function configureDesktopChromeFrame(profileDir: string): void {
+  const path = chromePreferencesPath(profileDir);
+  let preferences: Record<string, unknown> = {};
+  try {
+    const value: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (!isPlainObject(value)) {
+      throw new Error("Desktop Chrome preferences must be a JSON object");
+    }
+    preferences = value;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw err;
+    }
+  }
+  const browser = preferences.browser ?? {};
+  if (!isPlainObject(browser)) {
+    throw new Error("Desktop Chrome browser preferences must be a JSON object");
+  }
+  if (browser.custom_chrome_frame === true) {
+    return;
+  }
+  preferences.browser = { ...browser, custom_chrome_frame: true };
+  const directory = dirname(path);
+  mkdirSync(directory, { recursive: true });
+  const staging = mkdtempSync(join(directory, ".vellum-frame-"));
+  try {
+    const temporaryPath = join(staging, "Preferences");
+    writeFileSync(temporaryPath, JSON.stringify(preferences) + "\n", {
+      mode: 0o600,
+    });
+    renameSync(temporaryPath, path);
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+function chromePreferencesPath(profileDir: string): string {
+  const lastUsed = readProfileMetadata(
+    join(profileDir, "Local State"),
+  )?.last_used;
+  const profileName =
+    typeof lastUsed === "string" &&
+    lastUsed !== "" &&
+    lastUsed !== "." &&
+    lastUsed !== ".." &&
+    basename(lastUsed) === lastUsed
+      ? lastUsed
+      : "Default";
+  return join(profileDir, profileName, "Preferences");
+}
+
+function readProfileMetadata(
+  path: string,
+): { last_used?: unknown; exit_type?: unknown } | undefined {
+  try {
+    const value: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (isPlainObject(value)) {
+      const profile = value.profile;
+      if (isPlainObject(profile)) {
+        return profile;
+      }
+    }
+  } catch {
+    // Leave missing or unreadable session metadata to Chrome's normal startup.
+  }
+  return undefined;
+}

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

@@ -0,0 +1,131 @@
+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();
+  });
+});
+
+test("browser and viewer share installation while a cancelled waiter stops immediately", async () => {
+  const f = setup();
+  const abort = new AbortController();
+  const browser = f.installer
+    .ensureReady(abort.signal)
+    .catch((error: unknown) => error);
+  const viewer = f.installer.ensureReady();
+  await flush();
+  expect(f.install).toHaveBeenCalledTimes(1);
+  abort.abort();
+  expect(await browser).toBeInstanceOf(Error);
+  expect(f.installer.getStatus().state).toBe("installing");
+  f.finish();
+  await viewer;
+  expect(f.installer.getStatus().state).toBe("ready");
+});
+
+test("failed setup reports the stage without running an automatic retry", async () => {
+  const f = setup();
+  const result = f.installer.ensureReady().catch((error: Error) => error);
+  await flush();
+  f.progress();
+  f.fail();
+  const error = await result;
+  expect(error).toBeInstanceOf(Error);
+  expect((error as Error).message).toContain("failed during chrome");
+  expect(f.install).toHaveBeenCalledTimes(1);
+});