@vellumai/assistant 0.11.4 → 0.11.5-staging.2

package/src/channels/__tests__/message-audience.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+
+import { audienceForReader } from "../message-audience.js";
+
+describe("audienceForReader", () => {
+  test("restricts a reply in a Slack channel to the named reader", () => {
+    expect(audienceForReader("slack", "C0ROOM", "U0READER")).toEqual({
+      kind: "oneReader",
+      userId: "U0READER",
+    });
+  });
+
+  test("leaves a Slack DM unrestricted", () => {
+    // Nobody else can read a DM, so restricting buys no privacy and costs
+    // durability: an ephemeral message does not survive a reload.
+    expect(audienceForReader("slack", "D0DIRECT", "U0READER")).toBeUndefined();
+  });
+
+  test("restricts a private group, which several readers share", () => {
+    // A `G` id is a shared room like a `C` one. Testing for a DM rather than
+    // for a channel id is what keeps this from leaking into the group.
+    expect(audienceForReader("slack", "G0PRIVATE", "U0READER")).toEqual({
+      kind: "oneReader",
+      userId: "U0READER",
+    });
+  });
+
+  test("leaves every other channel unrestricted", () => {
+    for (const channel of ["telegram", "discord", "whatsapp", "email"]) {
+      expect(
+        audienceForReader(channel, "C0ROOM", "U0READER"),
+        `${channel} has no way to show one reader a message in a shared room`,
+      ).toBeUndefined();
+    }
+  });
+
+  test("stays unrestricted when there is no reader to name", () => {
+    expect(audienceForReader("slack", "C0ROOM", undefined)).toBeUndefined();
+    expect(audienceForReader("slack", "C0ROOM", null)).toBeUndefined();
+  });
+
+  test("tolerates an absent channel or room rather than throwing", () => {
+    // Several callers hold values that were never narrowed, so the answer for
+    // an unknown channel has to be the safe one rather than an exception.
+    expect(audienceForReader(undefined, "C0ROOM", "U0READER")).toBeUndefined();
+    expect(audienceForReader(null, "C0ROOM", "U0READER")).toBeUndefined();
+    expect(audienceForReader("slack", null, "U0READER")).toBeUndefined();
+  });
+});

package/src/channels/__tests__/types.test.ts

@@ -17,9 +17,10 @@ describe("INTERFACE_IDS", () => {
     ).toBe(true);
   });
 
-  test("still includes macos and other existing interfaces", () => {
+  test("includes desktop and existing interfaces", () => {
     for (const id of [
       "macos",
+      "windows",
       "ios",
       "cli",
       "telegram",
@@ -41,8 +42,9 @@ describe("INTERACTIVE_INTERFACES", () => {
     expect(INTERACTIVE_INTERFACES.has("chrome-extension" as never)).toBe(false);
   });
 
-  test("still includes macos", () => {
+  test("includes desktop clients", () => {
     expect(INTERACTIVE_INTERFACES.has("macos")).toBe(true);
+    expect(INTERACTIVE_INTERFACES.has("windows")).toBe(true);
   });
 });
 
@@ -51,8 +53,9 @@ describe("isInterfaceId", () => {
     expect(isInterfaceId("chrome-extension")).toBe(true);
   });
 
-  test("returns true for macos", () => {
+  test("returns true for desktop interfaces", () => {
     expect(isInterfaceId("macos")).toBe(true);
+    expect(isInterfaceId("windows")).toBe(true);
   });
 
   test("returns false for unknown interface", () => {
@@ -68,6 +71,7 @@ describe("parseInterfaceId", () => {
   test("returns canonical ID for valid interface", () => {
     expect(parseInterfaceId("web")).toBe("web");
     expect(parseInterfaceId("macos")).toBe("macos");
+    expect(parseInterfaceId("windows")).toBe("windows");
   });
 
   test("normalizes legacy 'vellum' alias to 'web'", () => {
@@ -103,6 +107,16 @@ describe("supportsHostProxy", () => {
     expect(supportsHostProxy("macos", "host_browser")).toBe(true);
   });
 
+  test("windows exposes its implemented host capabilities", () => {
+    expect(supportsHostProxy("windows")).toBe(true);
+    expect(supportsHostProxy("windows", "host_bash")).toBe(true);
+    expect(supportsHostProxy("windows", "host_file")).toBe(true);
+    expect(supportsHostProxy("windows", "host_cu")).toBe(true);
+    expect(supportsHostProxy("windows", "host_browser")).toBe(true);
+    expect(supportsHostProxy("windows", "host_ui_snapshot")).toBe(true);
+    expect(supportsHostProxy("windows", "host_app_control")).toBe(false);
+  });
+
   // ── chrome-extension: only host_browser. ──
   test("chrome-extension returns false (no capability)", () => {
     // Chrome extension does not support "any host proxy at all" — it only

package/src/channels/message-audience.ts

@@ -0,0 +1,40 @@
+/**
+ * Who a reply should be visible to, decided once for every producer.
+ */
+
+import type { MessageAudience } from "@vellumai/gateway-client";
+
+import { isSlackDmConversation } from "../messaging/providers/slack/message-metadata.js";
+
+/**
+ * The audience a reply addressed at `userId` should carry, or `undefined` when
+ * the whole room may see it.
+ *
+ * Restricting a message only means something where someone else could read it.
+ * A room with one reader gets no restriction: a Slack DM is already private,
+ * and marking it restricted there costs durability, because an ephemeral
+ * message does not survive a reload.
+ *
+ * Slack is the only channel that can show one reader a message in a room it
+ * shares with others. The test is for a DM rather than for a channel id, so
+ * every other room shape counts as shared: a private group holds several
+ * readers even though its id begins with `G` rather than `C`.
+ *
+ * `sourceChannel` and `chatId` are loosely typed because the only questions
+ * asked of them are whether the channel is Slack and whether the room is a
+ * DM, and several callers hold values that were never narrowed. An unknown
+ * channel answers with no restriction rather than throwing.
+ */
+export function audienceForReader(
+  sourceChannel: string | null | undefined,
+  chatId: string | null | undefined,
+  userId: string | null | undefined,
+): MessageAudience | undefined {
+  if (sourceChannel !== "slack" || !userId || !chatId) {
+    return undefined;
+  }
+  if (isSlackDmConversation(chatId)) {
+    return undefined;
+  }
+  return { kind: "oneReader", userId };
+}

package/src/channels/types.ts

@@ -166,6 +166,7 @@ export const CHANNEL_METADATA: Partial<Record<ChannelId, ChannelInfo>> = {
 
 export const INTERFACE_IDS = [
   "macos",
+  "windows",
   "ios",
   "cli",
   "telegram",
@@ -264,6 +265,7 @@ export function parseClientOs(value: unknown): ClientOs | null {
  */
 export const INTERACTIVE_INTERFACES: ReadonlySet<InterfaceId> = new Set([
   "macos",
+  "windows",
   "ios",
   "cli",
   "web",
@@ -274,9 +276,9 @@ export function isInteractiveInterface(id: InterfaceId): boolean {
 }
 
 /**
- * Host proxy capabilities that an interface can support. The macOS client
- * supports all of them; the chrome-extension interface only supports
- * host_browser (via the Chrome DevTools Protocol proxy).
+ * Host proxy capabilities that an interface can support. macOS supports all
+ * of them, Windows withholds app control, and chrome-extension supports only
+ * host_browser through the Chrome DevTools Protocol proxy.
  */
 export const HOST_PROXY_CAPABILITIES = [
   "host_bash",
@@ -290,29 +292,28 @@ export const HOST_PROXY_CAPABILITIES = [
 export type HostProxyCapability = (typeof HOST_PROXY_CAPABILITIES)[number];
 
 /**
- * Interfaces that support the full desktop host-proxy set (every
- * `HostProxyCapability` value). This is the capability-level identity used
- * by the discriminated transport metadata union and by the
+ * Interfaces that support desktop host-proxy tools. This identity is used by
+ * the discriminated transport metadata union and by the
  * `supportsHostProxy(id)` type predicate.
  *
  * Extend this literal type AND the `supportsHostProxy` implementation
- * below in lock-step when adding a new host-capable client (e.g. a native
- * Linux or Windows desktop).
+ * below in lock-step when adding a new host-capable client such as native
+ * Linux.
  */
-export type HostProxyInterfaceId = "macos";
+export type HostProxyInterfaceId = "macos" | "windows";
 
 /**
  * Whether the interface supports a host proxy capability.
  *
  * The no-arg form `supportsHostProxy(id)` asks "is this interface a desktop
- * host-proxy client?" — it returns `true` only for macOS and is the type
+ * host-proxy client?" It returns `true` for native desktop clients and is the
  * predicate that narrows `InterfaceId` to `HostProxyInterfaceId`. It returns
  * `false` for chrome-extension because chrome-extension only supports
  * `host_browser`, and the no-arg form is the gate that legacy desktop-only
  * call sites use (e.g. preactivating computer-use, restoring host proxies
- * in the drain queue). Callers that want to check a single capability —
+ * in the drain queue). Callers that want to check a single capability,
  * for example, to decide whether to keep `hostBrowserProxy` available for
- * chrome-extension — should pass the capability explicitly:
+ * chrome-extension, should pass the capability explicitly:
  * `supportsHostProxy(id, "host_browser")`.
  */
 export function supportsHostProxy(id: InterfaceId): id is HostProxyInterfaceId;
@@ -331,6 +332,9 @@ export function supportsHostProxy(
   if (id === "macos") {
     return true;
   }
+  if (id === "windows") {
+    return capability == null || capability !== "host_app_control";
+  }
   if (id === "chrome-extension" && capability === "host_browser") {
     return true;
   }

package/src/cli/__tests__/catalog-search-help.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Memory injection indexes CLI help via {@link buildCliCommandHelpContent}.
+ * Setup prompts like "Setup <app> for me" should retrieve `plugins search` /
+ * `skills search` before the model falls back to web search.
+ *
+ * These assertions lock the retrieval phrases in the indexed blob so a later
+ * wording change cannot silently drop them.
+ */
+import { describe, expect, test } from "bun:test";
+
+import { buildCliCommandHelpContent } from "../../plugins/defaults/memory/substrate/cli-command-content.js";
+import { pluginsHelp } from "../commands/plugins.help.js";
+import { skillsHelp } from "../commands/skills.help.js";
+
+function searchHelp(
+  help: { subcommands?: Array<{ name: string; helpText?: string }> },
+): { name: string; helpText?: string } {
+  const search = help.subcommands?.find((sub) => sub.name === "search");
+  if (!search) {
+    throw new Error("expected a search subcommand");
+  }
+  return search;
+}
+
+describe("catalog search help for setup-intent retrieval", () => {
+  test("plugins help indexes setup, superpowers, and web-search fallback", () => {
+    const indexed = buildCliCommandHelpContent(pluginsHelp);
+    const search = searchHelp(pluginsHelp);
+
+    expect(search.helpText).toBeDefined();
+    expect(indexed.toLowerCase()).toContain("superpowers");
+    expect(indexed).toContain("Setup <app> for me");
+    expect(indexed.toLowerCase()).toContain("before searching the web");
+    expect(indexed).toContain("assistant plugins search");
+    expect(indexed).toContain("assistant skills search");
+    expect(indexed.toLowerCase()).not.toContain("empty query");
+  });
+
+  test("skills help indexes setup as the second stop before web search", () => {
+    const indexed = buildCliCommandHelpContent(skillsHelp);
+    const search = searchHelp(skillsHelp);
+
+    expect(search.helpText).toBeDefined();
+    expect(indexed).toContain("Second stop after plugin search");
+    expect(indexed).toContain("Setup <app> for me");
+    expect(indexed.toLowerCase()).toContain("before searching the web");
+    expect(indexed).toContain("assistant skills search");
+    expect(indexed).toContain("try web search");
+  });
+});

package/src/cli/commands/__tests__/channel-verification-sessions.test.ts

@@ -13,10 +13,12 @@
  *   - `revoke` with no flags (channel: undefined)
  *   - `revoke --channel phone` sends channel param
  *   - `create --channel fax` → invalid channel, exits with code 1, IPC not called
+ *   - the accepted `--channel` set is the canonical CHANNEL_IDS vocabulary
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { CHANNEL_IDS } from "@vellumai/service-contracts/channels";
 import { Command } from "commander";
 
 // ---------------------------------------------------------------------------
@@ -242,6 +244,35 @@ describe("channel-verification-sessions create", () => {
     expect(lastIpcCall).toBeNull();
   });
 
+  test("--channel discord reaches IPC (canonical vocabulary, not a local copy)", async () => {
+    const { exitCode } = await runCommand([
+      "channel-verification-sessions",
+      "create",
+      "--channel",
+      "discord",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(lastIpcCall!.method).toBe("channel_verification_sessions_create");
+    expect(lastIpcCall!.params).toMatchObject({
+      body: { channel: "discord", purpose: "guardian" },
+    });
+  });
+
+  test("every canonical channel id is accepted", async () => {
+    for (const channel of CHANNEL_IDS) {
+      const { exitCode } = await runCommand([
+        "channel-verification-sessions",
+        "create",
+        "--channel",
+        channel,
+      ]);
+
+      expect(exitCode).toBe(0);
+      expect(lastIpcCall!.params).toMatchObject({ body: { channel } });
+    }
+  });
+
   test("IPC error results in exit code 1", async () => {
     mockIpcResult = { ok: false, error: "Could not connect" };
 

package/src/cli/commands/__tests__/conversations-search.test.ts

@@ -0,0 +1,289 @@
+/**
+ * Tests for `assistant conversations search`.
+ *
+ * Validates IPC plumbing onto `conversations_search`, human vs `--json`
+ * output, empty-result copy, and validation of the search term / --limit.
+ */
+
+import * as nodeFs from "node:fs";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+let lastIpcCall: { method: string; params?: Record<string, unknown> } | null =
+  null;
+
+let mockIpcResult: {
+  ok: boolean;
+  result?: unknown;
+  error?: string;
+  statusCode?: number;
+} = { ok: true, result: { query: "flux", results: [] } };
+
+mock.module("../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    lastIpcCall = { method, params };
+    return mockIpcResult;
+  },
+  exitCodeFromIpcResult: (r: { statusCode?: number }) =>
+    r.statusCode === undefined
+      ? 10
+      : r.statusCode >= 500
+        ? 3
+        : r.statusCode >= 400
+          ? 2
+          : 1,
+  exitFromIpcResult: () => {
+    process.exitCode = 1;
+  },
+}));
+
+const fakeLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+};
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => fakeLogger,
+  getCliLogger: () => fakeLogger,
+  initLogger: () => {},
+  truncateForLog: (v: string) => v,
+  pruneOldLogFiles: () => 0,
+  LOG_FILE_PATTERN: /^assistant-(\d{4}-\d{2}-\d{2})\.log$/,
+  getCurrentLogFilePath: () => "/tmp/test-assistant.log",
+}));
+
+const realFs = { ...nodeFs };
+mock.module("node:fs", () => ({ ...realFs }));
+
+const { registerConversationsCommand } = await import("../conversations.js");
+
+const THREE_HOURS_AGO = Date.now() - 3 * 60 * 60 * 1000;
+
+const matchingResult = {
+  conversationId: "conv-xyz",
+  conversationTitle: "Quarterly metrics",
+  conversationUpdatedAt: THREE_HOURS_AGO,
+  matchingMessages: [
+    {
+      messageId: "msg-1",
+      role: "user",
+      excerpt: "let's review the flux capacitor numbers",
+      createdAt: THREE_HOURS_AGO,
+    },
+    {
+      messageId: "msg-2",
+      role: "assistant",
+      excerpt: "the Q3 flux capacitor spend is on track",
+      createdAt: THREE_HOURS_AGO,
+    },
+  ],
+};
+
+async function runSearch(
+  args: string[],
+): Promise<{ code: number; stdout: string; stderr: string }> {
+  const stdoutChunks: string[] = [];
+  const stderrChunks: string[] = [];
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = ((chunk: unknown) => {
+    stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+  process.stderr.write = ((chunk: unknown) => {
+    stderrChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stderr.write;
+
+  const program = new Command();
+  program.exitOverride();
+  program.configureOutput({
+    writeErr: (s) => {
+      stderrChunks.push(s);
+    },
+    writeOut: (s) => {
+      stdoutChunks.push(s);
+    },
+  });
+  registerConversationsCommand(program);
+  try {
+    await program.parseAsync(["node", "assistant", "conversations", ...args]);
+  } catch (err) {
+    const isHelp =
+      typeof err === "object" &&
+      err !== null &&
+      "code" in err &&
+      (err as { code?: string }).code === "commander.helpDisplayed";
+    if (!isHelp && (process.exitCode === 0 || process.exitCode === undefined)) {
+      process.exitCode = 1;
+    }
+    if (
+      !isHelp &&
+      err instanceof Error &&
+      !stderrChunks.some((s) => s.includes(err.message))
+    ) {
+      stderrChunks.push(err.message);
+    }
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  }
+  const code = Number(process.exitCode ?? 0);
+  process.exitCode = 0;
+  return {
+    code,
+    stdout: stdoutChunks.join(""),
+    stderr: stderrChunks.join(""),
+  };
+}
+
+beforeEach(() => {
+  lastIpcCall = null;
+  process.exitCode = 0;
+  mockIpcResult = { ok: true, result: { query: "flux", results: [] } };
+});
+
+afterEach(() => {
+  process.exitCode = 0;
+});
+
+describe("conversations search", () => {
+  test("forwards the term to conversations_search as queryParams.q", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { query: "flux capacitor", results: [matchingResult] },
+    };
+    const { code } = await runSearch(["search", "flux capacitor"]);
+    expect(code).toBe(0);
+    expect(lastIpcCall?.method).toBe("conversations_search");
+    expect(lastIpcCall?.params).toEqual({
+      queryParams: { q: "flux capacitor" },
+    });
+  });
+
+  test("passes --limit as a query param string", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { query: "flux", results: [] },
+    };
+    const { code } = await runSearch(["search", "flux", "--limit", "5"]);
+    expect(code).toBe(0);
+    expect(lastIpcCall?.params).toEqual({
+      queryParams: { q: "flux", limit: "5" },
+    });
+  });
+
+  test("prints conversation rows and excerpts in human mode", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { query: "flux", results: [matchingResult] },
+    };
+    const { code, stdout } = await runSearch(["search", "flux"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("conv-xyz");
+    expect(stdout).toContain("Quarterly metrics");
+    expect(stdout).toContain("3h ago");
+    expect(stdout).toContain("user  let's review the flux capacitor numbers");
+    expect(stdout).toContain(
+      "assistant  the Q3 flux capacitor spend is on track",
+    );
+  });
+
+  test("prints Untitled when the conversation title is null", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        query: "flux",
+        results: [
+          {
+            ...matchingResult,
+            conversationTitle: null,
+            matchingMessages: [],
+          },
+        ],
+      },
+    };
+    const { code, stdout } = await runSearch(["search", "flux"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain("Untitled");
+  });
+
+  test("prints a no-match line when the daemon returns no results", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { query: "no-such-term", results: [] },
+    };
+    const { code, stdout } = await runSearch(["search", "no-such-term"]);
+    expect(code).toBe(0);
+    expect(lastIpcCall?.method).toBe("conversations_search");
+    expect(stdout).toBe('No conversations matched "no-such-term"\n');
+  });
+
+  test("--json emits the daemon payload", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: { query: "flux", results: [matchingResult] },
+    };
+    const { code, stdout } = await runSearch(["search", "flux", "--json"]);
+    expect(code).toBe(0);
+    expect(JSON.parse(stdout)).toEqual({
+      query: "flux",
+      results: [matchingResult],
+    });
+  });
+
+  test("--json reports IPC failure as { ok: false } and exits non-zero", async () => {
+    mockIpcResult = { ok: false, error: "assistant not running" };
+    const { code, stdout } = await runSearch(["search", "flux", "--json"]);
+    expect(code).toBe(10);
+    expect(JSON.parse(stdout)).toEqual({
+      ok: false,
+      error: "assistant not running",
+    });
+  });
+
+  test("rejects a whitespace-only term before IPC", async () => {
+    const { code, stderr } = await runSearch(["search", "   "]);
+    expect(code).toBe(1);
+    expect(lastIpcCall).toBeNull();
+    expect(stderr).toContain("Search term must be a non-empty string");
+  });
+
+  test("--json rejects a whitespace-only term as { ok: false }", async () => {
+    const { code, stdout } = await runSearch(["search", "   ", "--json"]);
+    expect(code).toBe(1);
+    expect(lastIpcCall).toBeNull();
+    expect(JSON.parse(stdout)).toMatchObject({
+      ok: false,
+      error: expect.stringContaining("Search term must be a non-empty string"),
+    });
+  });
+
+  test("rejects a non-numeric --limit before IPC", async () => {
+    const { code, stderr } = await runSearch([
+      "search",
+      "flux",
+      "--limit",
+      "all",
+    ]);
+    expect(code).toBe(1);
+    expect(lastIpcCall).toBeNull();
+    expect(stderr).toContain("Invalid --limit value");
+  });
+
+  test("search --help documents the term, --limit, and examples", async () => {
+    const { code, stdout } = await runSearch(["search", "--help"]);
+    expect(code).toBe(0);
+    expect(stdout).toContain(
+      "Search conversations by title and message content",
+    );
+    expect(stdout).toContain("--limit");
+    expect(stdout).toContain(
+      'assistant conversations search "project planning"',
+    );
+    expect(stdout).toContain("--json");
+  });
+});

package/src/cli/commands/__tests__/conversations-slack.test.ts

@@ -98,6 +98,7 @@ mock.module("../../../ipc/gateway-client.js", () => ({
 }));
 
 mock.module("../../../messaging/providers/slack/send.js", () => ({
+  updateSlackMessage: async () => ({ ok: true, ts: "ts" }),
   sendSlackReply: async (
     chatId: string,
     text: string,