@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/scripts/smoke-desktop-window-theme.ts

@@ -0,0 +1,186 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { writeDesktopWindowTheme } from "../src/desktop/desktop-window-theme.js";
+
+if (process.platform !== "linux") {
+  throw new Error(
+    "Run in a disposable Linux environment with Xvfb, Openbox, xterm, xdotool, xwininfo and xmllint installed",
+  );
+}
+
+const directory = await mkdtemp(join(tmpdir(), "window-theme-smoke-"));
+const env = { ...process.env, DISPLAY: ":97" };
+const children: ReturnType<typeof Bun.spawn>[] = [];
+const start = (cmd: string[]) => {
+  const child = Bun.spawn(cmd, {
+    env,
+    stdout: "ignore",
+    stderr: "inherit",
+    windowsHide: true,
+  });
+  children.push(child);
+  return child;
+};
+const run = (...cmd: string[]) => {
+  const result = Bun.spawnSync(cmd, {
+    env,
+
+    windowsHide: true,
+  });
+  assert.equal(result.exitCode, 0, result.stderr.toString());
+  return result.stdout.toString();
+};
+const waitFor = async (predicate: () => boolean) => {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    try {
+      if (predicate()) {
+        return;
+      }
+    } catch {}
+    await Bun.sleep(50);
+  }
+  throw new Error("Window theme smoke condition timed out");
+};
+const pointer = async (...args: string[]) => {
+  run("xdotool", ...args);
+  await Bun.sleep(200);
+};
+const geometry = () => {
+  const info = run("xwininfo", "-name", "Theme smoke");
+  return [
+    "Absolute upper-left X",
+    "Absolute upper-left Y",
+    "Width",
+    "Height",
+  ].map((label) =>
+    Number(new RegExp(`${label}:\\s+(-?\\d+)`).exec(info)?.[1]),
+  ) as [number, number, number, number];
+};
+const state = () => run("xprop", "-name", "Theme smoke", "_NET_WM_STATE");
+const button = async (offset: number) => {
+  const [x, y, width] = geometry();
+  await pointer(
+    "mousemove",
+    String(x + width - offset),
+    String(y - 16),
+    "click",
+    "1",
+  );
+};
+
+try {
+  const home = join(directory, "home");
+  const sourceDir = join(home, ".config", "openbox");
+  await mkdir(sourceDir, { recursive: true });
+  const original = await readFile("/etc/xdg/openbox/rc.xml", "utf8");
+  const mouse = original.match(/<mouse>[^]*?<\/mouse>/)![0];
+  const keyboard = original.match(/<keyboard>[^]*?<\/keyboard>/)![0];
+  const source = original
+    .replace(
+      mouse,
+      `<xi:include href="bindings.xml" xpointer="xpointer(/*/*)"/>`,
+    )
+    .replace(keyboard, "");
+  const sourcePath = join(sourceDir, "rc.xml");
+  await writeFile(sourcePath, source);
+  await writeFile(
+    join(sourceDir, "bindings.xml"),
+    `<bindings xmlns="http://openbox.org/3.4/rc">${mouse}${keyboard}</bindings>`,
+  );
+  const configDir = join(directory, "managed & theme");
+  const config = writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  const expanded = run("xmllint", "--xinclude", config);
+  assert(
+    expanded.includes("NextWindow") && expanded.includes("Move"),
+    "Relative includes must retain the actual keyboard and mouse bindings",
+  );
+  assert.equal(await readFile(sourcePath, "utf8"), source);
+  writeDesktopWindowTheme(configDir, home, "#bc7799");
+  writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  assert.equal(await readFile(sourcePath, "utf8"), source);
+  const blocked = join(directory, "blocked");
+  await writeFile(blocked, "not a directory");
+  assert.throws(() => writeDesktopWindowTheme(blocked, home));
+  assert.equal(await readFile(sourcePath, "utf8"), source);
+  const customBase = source.replace(
+    "<openbox_config",
+    '<openbox_config xml:base="./custom/"',
+  );
+  await writeFile(sourcePath, customBase);
+  assert.throws(() => writeDesktopWindowTheme(configDir, home));
+  assert.equal(await readFile(sourcePath, "utf8"), customBase);
+  await writeFile(sourcePath, source);
+
+  start(["Xvfb", ":97", "-screen", "0", "1100x700x24"]);
+  await waitFor(
+    () => run("xdotool", "getdisplaygeometry").trim() === "1100 700",
+  );
+  start(["openbox", "--config-file", config]);
+  await waitFor(() =>
+    run("xprop", "-root", "_OB_THEME").includes("window-theme"),
+  );
+  start([
+    "xterm",
+    "-title",
+    "Theme smoke",
+    "-geometry",
+    "48x12+450+250",
+    "-e",
+    "sleep",
+    "60",
+  ]);
+  await waitFor(
+    () => run("xdotool", "search", "--name", "^Theme smoke$").trim().length > 0,
+  );
+  await Bun.sleep(300);
+  const id = run("xdotool", "search", "--name", "^Theme smoke$").trim();
+  await button(39);
+  assert(
+    state().includes("MAXIMIZED_HORZ") && state().includes("MAXIMIZED_VERT"),
+  );
+  await button(39);
+  assert(!state().includes("MAXIMIZED"));
+  await button(62);
+  assert(state().includes("HIDDEN"));
+  await pointer("windowactivate", id);
+  assert(!state().includes("HIDDEN"));
+  let [x, y, width, height] = geometry();
+  await pointer("mousemove", String(x + 100), String(y - 16), "mousedown", "1");
+  await pointer("mousemove", String(x + 90), String(y - 26));
+  await pointer("mousemove", String(x + 45), String(y - 65));
+  await pointer("mouseup", "1");
+  const [movedX, movedY] = geometry();
+  assert(Math.abs(movedX - x) >= 30 && Math.abs(movedY - y) >= 30);
+  [x, y, width, height] = geometry();
+  await pointer(
+    "mousemove",
+    String(x + width - 2),
+    String(y + height + 2),
+    "mousedown",
+    "1",
+  );
+  await pointer("mousemove", String(x + width + 10), String(y + height + 10));
+  await pointer("mousemove", String(x + width + 60), String(y + height + 40));
+  await pointer("mouseup", "1");
+  const [, , resizedWidth, resizedHeight] = geometry();
+  assert(resizedWidth > width && resizedHeight > height);
+  await pointer("key", "alt+F4");
+  await waitFor(
+    () =>
+      !run("xprop", "-root", "_NET_CLIENT_LIST").includes(
+        `0x${Number(id).toString(16)}`,
+      ),
+  );
+  console.log(
+    "PASS: relative includes, preserved source, repeated theme updates, maximize/restore, minimize/activation, dragging, resizing, and keyboard close",
+  );
+} finally {
+  for (const child of children.reverse()) {
+    child.kill();
+  }
+  await Promise.all(children.map((child) => child.exited));
+  await rm(directory, { recursive: true, force: true });
+}

package/src/__tests__/always-loaded-tools-guard.test.ts

@@ -26,7 +26,7 @@ afterAll(() => {
 });
 
 describe("always-loaded tool count", () => {
-  test("should be exactly 11 with recall occupying the existing slot", async () => {
+  test("should be exactly 19 with recall occupying the existing slot", async () => {
     await initializeTools();
     const allDefs = getAllToolDefinitions();
 
@@ -44,23 +44,31 @@ describe("always-loaded tool count", () => {
     );
     const activeNames = activeTools.map((t) => t.name).sort();
 
-    // Host tools (host_bash, host_file_*) are excluded when no client is
-    // connected — without a human in the loop, the guardian auto-approve
-    // path would allow unchecked host command execution.
-    //
-    // `watch_retro_report` is here for the same reason the ui_surface tools are
-    // NOT: a watch retrospective runs clientless, so it can only report through
-    // a tool that survives this baseline. Its description and schema are kept
-    // deliberately terse because that is the cost of the slot.
+    // `watch_retro_report` survives this baseline because a watch
+    // retrospective runs clientless and can only report through a tool that
+    // stays on this baseline. The ui_* tools stay here because background
+    // surfaces persist and return instead of awaiting action, so a connected
+    // client is not required for the definitions to be present.
+    // Host tool definitions stay on the wire for background turns: schemas
+    // are cache-stable, and the shared execution gate rejects host tools on
+    // explicitly non-interactive turns before any proxy dispatch.
     const expectedNames = [
       "bash",
       "file_edit",
       "file_read",
       "file_write",
+      "host_bash",
+      "host_file_edit",
+      "host_file_read",
+      "host_file_transfer",
+      "host_file_write",
       "recall",
       "remember",
       "skill_execute",
       "skill_load",
+      "ui_dismiss",
+      "ui_show",
+      "ui_update",
       "watch_retro_report",
       "web_fetch",
       "web_search",
@@ -68,6 +76,6 @@ describe("always-loaded tool count", () => {
 
     expect(activeNames).toEqual(expectedNames);
     expect(activeNames.filter((name) => name === "recall")).toHaveLength(1);
-    expect(activeTools.length).toBe(11);
+    expect(activeTools.length).toBe(19);
   });
 });

package/src/__tests__/anthropic-provider.test.ts

@@ -3029,69 +3029,6 @@ describe("AnthropicProvider - internal attachment id", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Tests — Orphaned UTF-16 surrogate sanitization
-// ---------------------------------------------------------------------------
-
-describe("AnthropicProvider — surrogate sanitization", () => {
-  let provider: AnthropicProvider;
-
-  beforeEach(() => {
-    lastStreamParams = null;
-    provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
-  });
-
-  test("strips orphaned high surrogate from a tool result before sending", async () => {
-    // An orphaned high surrogate — the exact shape that triggers Anthropic's
-    // "no low surrogate in string" 400. The mock's JSON.parse(JSON.stringify)
-    // on line ~44 would throw if sanitization didn't happen.
-    const LONE_HIGH = "\uD83C";
-    const messages: Message[] = [
-      toolUseMsg("tu1", "bash"),
-      toolResultMsg("tu1", `shell output ${LONE_HIGH} more output`),
-      userMsg("what happened?"),
-    ];
-
-    await provider.sendMessage(messages);
-
-    const sent = lastStreamParams!.messages as Array<{
-      role: string;
-      content: Array<{ type: string; content?: string; text?: string }>;
-    }>;
-    // Find the tool_result block in the captured payload and assert no orphans.
-    const toolResult = sent
-      .flatMap((m) => m.content)
-      .find((b) => b.type === "tool_result");
-    expect(toolResult).toBeDefined();
-    expect(toolResult!.content).toBeDefined();
-    const content = toolResult!.content as string;
-    for (let i = 0; i < content.length; i++) {
-      const code = content.charCodeAt(i);
-      if (code >= 0xd800 && code <= 0xdbff) {
-        const next = i + 1 < content.length ? content.charCodeAt(i + 1) : 0;
-        expect(next >= 0xdc00 && next <= 0xdfff).toBe(true);
-        i++;
-      } else {
-        expect(code < 0xdc00 || code > 0xdfff).toBe(true);
-      }
-    }
-  });
-
-  test("clean payloads are not copied unnecessarily", async () => {
-    // When there are no orphans, the sanitizer should be a no-op. We can't
-    // easily assert reference equality through the mock boundary (the mock
-    // JSON-round-trips params for capture), but we can at least confirm the
-    // call succeeds without error on ordinary payloads containing valid
-    // surrogate pairs (emoji).
-    const EMOJI = "\uD83C\uDF89";
-    await provider.sendMessage([userMsg(`hello ${EMOJI} world`)]);
-    const sent = lastStreamParams!.messages as Array<{
-      content: Array<{ text?: string }>;
-    }>;
-    expect(sent[0].content[0].text).toContain(EMOJI);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Haiku model gating
 // ---------------------------------------------------------------------------

package/src/__tests__/app-compiler.test.ts

@@ -112,6 +112,12 @@ describe("compileApp", () => {
     const html = await readFile(join(appDir, "dist", "index.html"), "utf-8");
     expect(html).toContain('src="main.js"');
     expect(html).toContain('type="module"');
+
+    const fingerprint = JSON.parse(
+      await readFile(join(appDir, "dist", ".source-fingerprint.json"), "utf-8"),
+    ) as { algorithm: string; files: Record<string, string> };
+    expect(fingerprint.algorithm).toBe("sha256");
+    expect(fingerprint.files["src/main.tsx"]).toMatch(/^[0-9a-f]{64}$/);
   });
 
   test("compiles preact JSX correctly", async () => {

package/src/__tests__/app-control-tool-schemas.test.ts

@@ -591,8 +591,11 @@ describe("forwardAppControlProxyTool", () => {
       ctx,
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("no proxy resolver available");
-    expect(result.content).toContain("app_control_click");
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to control apps on your computer",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).not.toContain("app_control_click");
   });
 
   test("delegates to proxy resolver when available", async () => {

package/src/__tests__/app-dir-path-guard.test.ts

@@ -9,15 +9,13 @@ import { describe, expect, test } from "bun:test";
  * This prevents regressions where new code bypasses the dirName-based path
  * resolution and constructs UUID-based paths directly.
  *
- * Allowlist: only app-store.ts itself, app-source-watcher.ts (uses getAppsDir
- * for the fs.watch root, not for per-app paths), and workspace migrations
+ * Allowlist: only app-store.ts itself and workspace migrations
  * (self-contained, don't import from app-store).
  */
 
 /** Files that are permitted to import getAppsDir. */
 const ALLOWLIST = new Set([
   "assistant/src/apps/app-store.ts", // defines getAppsDir
-  "assistant/src/daemon/app-source-watcher.ts", // uses getAppsDir for recursive fs.watch root, not per-app paths
   "assistant/src/tools/filesystem/write.ts", // uses getAppsDir as an exemption root for the artifact-HTML guard, not per-app paths
 ]);
 

package/src/__tests__/assistant-event-hub-machine-name.test.ts

@@ -125,7 +125,10 @@ describe("AssistantEventHub — machineName", () => {
   });
 });
 
-describe("window capture negotiation", () => {
+describe.each([
+  ["x-vellum-cu-window-capture", "host_cu_window_capture"],
+  ["x-vellum-cu-sequence", "host_cu_sequence"],
+] as const)("%s negotiation", (header, capability) => {
   test.each([
     ["macos", undefined, false],
     ["macos", "0", false],
@@ -145,18 +148,14 @@ describe("window capture negotiation", () => {
             headers: {
               "x-vellum-client-id": "client-1",
               "x-vellum-interface-id": interfaceId,
-              ...(advertised
-                ? { "x-vellum-cu-window-capture": advertised }
-                : {}),
+              ...(advertised ? { [header]: advertised } : {}),
             },
             abortSignal: ac.signal,
           },
           { hub },
         );
         expect(
-          hub
-            .getClientById("client-1")
-            ?.capabilities.includes("host_cu_window_capture"),
+          hub.getClientById("client-1")?.capabilities.includes(capability),
         ).toBe(supported);
       } finally {
         ac.abort();

package/src/__tests__/assistant-event-hub.test.ts

@@ -690,3 +690,47 @@ test("window requests never reach an older overlapping connection with the same
     supported.dispose();
   }
 });
+
+test("batched action requests never reach an older overlapping connection with the same device ID", async () => {
+  const receivedLegacy: unknown[] = [];
+  const receivedSupported: unknown[] = [];
+  const legacy = assistantEventHub.subscribe({
+    type: "client",
+    clientId: "sequence-client",
+    interfaceId: "macos",
+    capabilities: ["host_cu"],
+    callback: (event) => {
+      receivedLegacy.push(event);
+    },
+  });
+  const supported = assistantEventHub.subscribe({
+    type: "client",
+    clientId: "sequence-client",
+    interfaceId: "macos",
+    capabilities: ["host_cu", "host_cu_sequence"],
+    callback: (event) => {
+      receivedSupported.push(event);
+    },
+  });
+  try {
+    broadcastMessage(
+      {
+        type: "host_cu_request",
+        requestId: "sequence-request",
+        conversationId: "sequence-session",
+        toolName: "computer_use_sequence",
+        input: { actions: [{ action: "key", key: "cmd+n" }] },
+        stepNumber: 1,
+        targetClientId: "sequence-client",
+      },
+      "sequence-session",
+      { targetClientId: "sequence-client" },
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(receivedLegacy).toHaveLength(0);
+    expect(receivedSupported).toHaveLength(1);
+  } finally {
+    legacy.dispose();
+    supported.dispose();
+  }
+});

package/src/__tests__/computer-use-skill-manifest-regression.test.ts

@@ -29,7 +29,7 @@ const manifestPath = resolve(
 const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
 
 describe("computer-use skill manifest regression", () => {
-  test("manifest has exactly 11 tools", () => {
+  test("manifest has exactly 12 tools", () => {
     expect(manifest.tools).toHaveLength(COMPUTER_USE_TOOL_COUNT);
   });
 

package/src/__tests__/computer-use-skill-proxy-bridge.test.ts

@@ -13,8 +13,11 @@ describe("forwardComputerUseProxyTool", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("no proxy resolver available");
-    expect(result.content).toContain("computer_use_click");
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).not.toContain("computer_use_click");
   });
 
   test("forwards to proxyToolResolver when present", async () => {

package/src/__tests__/computer-use-tools.test.ts

@@ -37,8 +37,8 @@ const ctx: ToolContext = {
 // ── Tool definitions ────────────────────────────────────────────────
 
 describe("computer-use tool definitions", () => {
-  test("allComputerUseTools contains 11 tools", () => {
-    expect(allComputerUseTools.length).toBe(11);
+  test("allComputerUseTools contains 12 tools", () => {
+    expect(allComputerUseTools.length).toBe(12);
   });
 
   test("all tools belong to computer-use category", () => {
@@ -104,7 +104,10 @@ describe("computer_use_click (unified)", () => {
   test("execute returns isError when no proxy resolver is configured", async () => {
     const result = await computerUseClickTool.execute({}, ctx);
     expect(result.isError).toBe(true);
-    expect(result.content).toMatch(/No proxy resolver/);
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
   });
 });
 
@@ -119,7 +122,10 @@ describe("computer_use_type_text", () => {
   test("execute returns isError when no proxy resolver is configured", async () => {
     const result = await computerUseTypeTextTool.execute({}, ctx);
     expect(result.isError).toBe(true);
-    expect(result.content).toMatch(/No proxy resolver/);
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
   });
 });
 
@@ -134,7 +140,10 @@ describe("computer_use_key", () => {
   test("execute returns isError when no proxy resolver is configured", async () => {
     const result = await computerUseKeyTool.execute({}, ctx);
     expect(result.isError).toBe(true);
-    expect(result.content).toMatch(/No proxy resolver/);
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
   });
 });
 
@@ -241,8 +250,11 @@ describe("forwardComputerUseProxyTool", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("no proxy resolver available");
-    expect(result.content).toContain("computer_use_click");
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).not.toContain("computer_use_click");
   });
 
   test("delegates to proxy resolver when available", async () => {

package/src/__tests__/config-schema-cmd.test.ts

@@ -130,7 +130,7 @@ describe("getSchemaAtPath", () => {
     expect(properties).toBeDefined();
     expect(properties.enabled).toBeDefined();
     expect(properties.voice).toBeDefined();
-    expect(properties.safety).toBeDefined();
+    expect(properties.disclosure).toBeDefined();
   });
 
   test("navigates through .transform() wrappers (ingress → object schema)", () => {
@@ -230,7 +230,7 @@ describe("z.toJSONSchema integration", () => {
     expect(properties).toBeDefined();
     expect(properties!.enabled).toBeDefined();
     expect(properties!.voice).toBeDefined();
-    expect(properties!.safety).toBeDefined();
+    expect(properties!.disclosure).toBeDefined();
   });
 
   test("sub-schema at a leaf like llm.profileSession.defaultTtlSeconds produces integer schema", () => {