@vellumai/assistant 0.11.4 → 0.11.5-staging.1

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,

package/src/cli/commands/__tests__/inference-providers.test.ts

@@ -120,6 +120,24 @@ describe("providers create — derived auth", () => {
     });
   });
 
+  test("forwards optional --base-url for ollama create", async () => {
+    await run([
+      "providers",
+      "create",
+      "ollama-home",
+      "--provider",
+      "ollama",
+      "--base-url",
+      "http://192.168.1.50:11434/v1",
+    ]);
+    expect(lastIpcCall()?.params?.body).toEqual({
+      name: "ollama-home",
+      provider: "ollama",
+      auth: { type: "none" },
+      base_url: "http://192.168.1.50:11434/v1",
+    });
+  });
+
   test("rejects a keyed provider without --credential before calling the daemon", async () => {
     const { exitCode } = await run([
       "providers",
@@ -332,6 +350,56 @@ describe("providers update", () => {
       base_url: "http://localhost:5678/v1",
     });
   });
+
+  test("ollama update forwards --base-url after GET", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        ...CONNECTION_RESULT,
+        name: "ollama",
+        provider: "ollama",
+        auth: { type: "none" },
+      },
+    };
+    await run([
+      "providers",
+      "update",
+      "ollama",
+      "--base-url",
+      "http://192.168.1.50:11434/v1",
+    ]);
+    expect(ipcCalls.map((c) => c.method)).toEqual([
+      "inference_provider_connections_get",
+      "inference_provider_connections_update",
+    ]);
+    expect(lastIpcCall()?.params).toEqual({
+      pathParams: { name: "ollama" },
+      body: {
+        auth: { type: "none" },
+        base_url: "http://192.168.1.50:11434/v1",
+      },
+    });
+  });
+});
+
+describe("providers get output", () => {
+  test("prints base_url when the connection stores one", async () => {
+    mockIpcResult = {
+      ok: true,
+      result: {
+        name: "ollama",
+        provider: "ollama",
+        auth: { type: "none" },
+        baseUrl: "http://192.168.1.50:11434/v1",
+        createdAt: 0,
+        updatedAt: 0,
+      },
+    };
+    const { stdout } = await run(["providers", "get", "ollama"]);
+    expect(stdout).toContain("name:     ollama");
+    expect(stdout).toContain("provider: ollama");
+    expect(stdout).toContain("base_url: http://192.168.1.50:11434/v1");
+  });
 });
 
 describe("providers list output", () => {

package/src/cli/commands/__tests__/keys.test.ts

@@ -1,5 +1,6 @@
 /**
- * Tests for the keys set CLI subcommand's agent-shell guard.
+ * Tests for the keys CLI subcommands: the set agent-shell guard and the
+ * delete force flag.
  *
  * Validates:
  *   - inline set from an agent shell (__CONVERSATION_ID) is refused with a
@@ -8,6 +9,8 @@
  *   - --generated bypasses the guard and stores via the daemon client
  *   - a plain user-terminal invocation (no markers) stores via the daemon
  *     client
+ *   - delete forwards the caller's force choice to the daemon client
+ *   - an in-use refusal points at the --force escape hatch
  */
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -18,7 +21,16 @@ import { Command } from "commander";
 // Mock state
 // ---------------------------------------------------------------------------
 
+interface DeleteResultStub {
+  result: "deleted" | "not-found" | "error";
+  error?: string;
+  code?: string;
+}
+
 let mockSetSecureKeyViaDaemon = mock(() => Promise.resolve({ ok: true }));
+let mockDeleteSecureKeyViaDaemon = mock(
+  (): Promise<DeleteResultStub> => Promise.resolve({ result: "deleted" }),
+);
 
 // ---------------------------------------------------------------------------
 // Mocks — must be declared before importing the module under test
@@ -26,11 +38,11 @@ let mockSetSecureKeyViaDaemon = mock(() => Promise.resolve({ ok: true }));
 
 mock.module("../../lib/daemon-credential-client.js", () => ({
   setSecureKeyViaDaemon: mockSetSecureKeyViaDaemon,
-  deleteSecureKeyViaDaemon: mock(() =>
-    Promise.resolve({ result: "deleted" as const }),
-  ),
+  deleteSecureKeyViaDaemon: mockDeleteSecureKeyViaDaemon,
 }));
 
+const loggedErrors: string[] = [];
+
 mock.module("../../../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -41,7 +53,9 @@ mock.module("../../../util/logger.js", () => ({
   getCliLogger: () => ({
     info: () => {},
     warn: () => {},
-    error: () => {},
+    error: (message: unknown) => {
+      loggedErrors.push(String(message));
+    },
     debug: () => {},
   }),
 }));
@@ -55,6 +69,10 @@ let savedSkillContextJson: string | undefined;
 
 beforeEach(() => {
   mockSetSecureKeyViaDaemon = mock(() => Promise.resolve({ ok: true }));
+  mockDeleteSecureKeyViaDaemon = mock(
+    (): Promise<DeleteResultStub> => Promise.resolve({ result: "deleted" }),
+  );
+  loggedErrors.length = 0;
   savedConversationId = process.env.__CONVERSATION_ID;
   savedSkillContextJson = process.env.__SKILL_CONTEXT_JSON;
   delete process.env.__CONVERSATION_ID;
@@ -83,9 +101,7 @@ afterEach(() => {
 async function runKeysCommand(...args: string[]) {
   mock.module("../../lib/daemon-credential-client.js", () => ({
     setSecureKeyViaDaemon: mockSetSecureKeyViaDaemon,
-    deleteSecureKeyViaDaemon: mock(() =>
-      Promise.resolve({ result: "deleted" as const }),
-    ),
+    deleteSecureKeyViaDaemon: mockDeleteSecureKeyViaDaemon,
   }));
 
   const { registerKeysCommand } = await import("../keys.js");
@@ -187,3 +203,68 @@ describe("assistant keys set (agent-shell guard)", () => {
     expect(process.exitCode).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// delete — in-use guard and --force
+// ---------------------------------------------------------------------------
+
+describe("assistant keys delete (in-use guard)", () => {
+  test("deletes without force by default", async () => {
+    // GIVEN a stored key no connection depends on
+    // WHEN the key is deleted without --force
+    await runKeysCommand("keys", "delete", "acme");
+
+    // THEN the daemon is asked for a non-forced delete
+    expect(mockDeleteSecureKeyViaDaemon).toHaveBeenCalledTimes(1);
+    const [type, provider, force] = mockDeleteSecureKeyViaDaemon.mock
+      .calls[0] as unknown as [string, string, boolean];
+    expect(type).toBe("api_key");
+    expect(provider).toBe("acme");
+    expect(force).toBe(false);
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("--force carries explicit intent to the daemon", async () => {
+    // GIVEN a caller who accepts breaking dependent connections
+    // WHEN --force is passed
+    await runKeysCommand("keys", "delete", "acme", "--force");
+
+    // THEN the daemon receives the force flag
+    const [, , force] = mockDeleteSecureKeyViaDaemon.mock
+      .calls[0] as unknown as [string, string, boolean];
+    expect(force).toBe(true);
+  });
+
+  test("names dependent connections and points at --force when refused", async () => {
+    // GIVEN a key an LLM provider connection resolves its auth through
+    mockDeleteSecureKeyViaDaemon = mock(
+      (): Promise<DeleteResultStub> =>
+        Promise.resolve({
+          result: "error",
+          code: "CREDENTIAL_IN_USE",
+          error:
+            'Credential credential/acme/api_key is in use by connection "acme-router".',
+        }),
+    );
+    const exitCalls: number[] = [];
+    const origExit = process.exit;
+    process.exit = ((code?: number) => {
+      exitCalls.push(code ?? 0);
+      throw new Error("__exit__");
+    }) as typeof process.exit;
+
+    // WHEN the delete is attempted without --force
+    try {
+      await runKeysCommand("keys", "delete", "acme");
+    } catch (err) {
+      expect((err as Error).message).toBe("__exit__");
+    } finally {
+      process.exit = origExit;
+    }
+
+    // THEN the refusal names the connection and suggests the escape hatch
+    expect(exitCalls).toEqual([1]);
+    expect(loggedErrors.join("\n")).toContain('connection "acme-router"');
+    expect(loggedErrors.join("\n")).toContain("keys delete acme --force");
+  });
+});