@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -437,74 +437,218 @@ describe("notifications send — minimal-surface ergonomics", () => {
 // ---------------------------------------------------------------------------
 
 describe("notifications list", () => {
-  test("list returns empty array when no events", async () => {
-    ipcResponse = { ok: true, result: [] };
+  const emptyPayload = {
+    items: [],
+    total: 0,
+    returned: 0,
+    hasMore: false,
+    updatedAt: "2026-05-28T00:00:00.000Z",
+  };
+
+  function feedItem(
+    overrides: Record<string, unknown>,
+  ): Record<string, unknown> {
+    return {
+      id: "feed-1",
+      type: "notification",
+      priority: 50,
+      summary: "Background sync done",
+      timestamp: "2026-05-28T10:00:00.000Z",
+      status: "new",
+      createdAt: "2026-05-28T10:00:00.000Z",
+      ...overrides,
+    };
+  }
+
+  test("list calls list_home_feed and returns empty payload", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
 
     const { parsed, exitCode } = await runCommand(["list"]);
 
     expect(exitCode).toBe(0);
     expect(parsed.ok).toBe(true);
-    expect(parsed.events).toEqual([]);
+    expect(parsed.items).toEqual([]);
+    expect(parsed.total).toBe(0);
 
     expect(ipcCalls).toHaveLength(1);
-    expect(ipcCalls[0].method).toBe("list_notification_events");
+    expect(ipcCalls[0].method).toBe("list_home_feed");
   });
 
-  test("list returns events from IPC", async () => {
+  test("list returns items from IPC", async () => {
     ipcResponse = {
       ok: true,
-      result: [
-        {
-          id: "evt-1",
-          sourceEventName: "user.send_notification",
-          sourceChannel: "assistant_tool",
-          sourceContextId: "session-1",
-          urgency: "medium",
-          dedupeKey: null,
-          createdAt: "2026-01-01T00:00:00.000Z",
-        },
-      ],
+      result: {
+        ...emptyPayload,
+        items: [feedItem({ title: "Hello", urgency: "medium" })],
+        total: 1,
+        returned: 1,
+      },
     };
 
     const { parsed, exitCode } = await runCommand(["list"]);
 
     expect(exitCode).toBe(0);
     expect(parsed.ok).toBe(true);
-    const events = parsed.events as Array<Record<string, unknown>>;
-    expect(events).toHaveLength(1);
-    expect(events[0].sourceEventName).toBe("user.send_notification");
+    const items = parsed.items as Array<Record<string, unknown>>;
+    expect(items).toHaveLength(1);
+    expect(items[0].title).toBe("Hello");
   });
 
-  test("list passes --limit to IPC", async () => {
-    ipcResponse = { ok: true, result: [] };
+  test("list defaults to excluding dismissed (no includeDismissed flag in body)", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
 
-    const { parsed, exitCode } = await runCommand(["list", "--limit", "5"]);
+    await runCommand(["list"]);
 
-    expect(exitCode).toBe(0);
-    expect(parsed.ok).toBe(true);
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.includeDismissed).toBeUndefined();
+    expect(body.statuses).toBeUndefined();
+  });
 
-    expect(ipcCalls).toHaveLength(1);
-    expect((ipcCalls[0].params?.body as Record<string, unknown>)?.limit).toBe(
-      5,
-    );
+  test("--all sets includeDismissed=true", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand(["list", "--all"]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.includeDismissed).toBe(true);
   });
 
-  test("list passes --source-event-name to IPC", async () => {
-    ipcResponse = { ok: true, result: [] };
+  test("--status is repeatable and passed as statuses array", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
 
+    await runCommand(["list", "--status", "new", "--status", "acted_on"]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.statuses).toEqual(["new", "acted_on"]);
+  });
+
+  test("--status rejects invalid value before IPC call", async () => {
     const { parsed, exitCode } = await runCommand([
       "list",
-      "--source-event-name",
-      "schedule.notify",
+      "--status",
+      "bogus",
     ]);
 
-    expect(exitCode).toBe(0);
-    expect(parsed.ok).toBe(true);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("status");
+    expect(ipcCalls).toHaveLength(0);
+  });
 
-    expect(ipcCalls).toHaveLength(1);
-    expect(
-      (ipcCalls[0].params?.body as Record<string, unknown>)?.sourceEventName,
-    ).toBe("schedule.notify");
+  test("--before and --after are forwarded as ISO strings", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand([
+      "list",
+      "--after",
+      "2026-05-28T00:00:00Z",
+      "--before",
+      "2026-05-29T00:00:00Z",
+    ]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.after).toBe("2026-05-28T00:00:00Z");
+    expect(body.before).toBe("2026-05-29T00:00:00Z");
+  });
+
+  test("--urgency is repeatable and passed as urgencies array", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand(["list", "--urgency", "high", "--urgency", "critical"]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.urgencies).toEqual(["high", "critical"]);
+  });
+
+  test("--urgency rejects invalid value", async () => {
+    const { exitCode, parsed } = await runCommand([
+      "list",
+      "--urgency",
+      "extreme",
+    ]);
+
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("urgency");
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("--category is repeatable and passed as categories array", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand([
+      "list",
+      "--category",
+      "email",
+      "--category",
+      "scheduling",
+    ]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.categories).toEqual(["email", "scheduling"]);
+  });
+
+  test("--conversation-id, --from-assistant, --noteworthy forwarded", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand([
+      "list",
+      "--conversation-id",
+      "conv-abc",
+      "--from-assistant",
+      "--noteworthy",
+    ]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.conversationId).toBe("conv-abc");
+    expect(body.fromAssistant).toBe(true);
+    expect(body.noteworthy).toBe(true);
+  });
+
+  test("--limit and --offset are forwarded as integers", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand(["list", "--limit", "5", "--offset", "10"]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.limit).toBe(5);
+    expect(body.offset).toBe(10);
+  });
+
+  test("--limit rejects non-positive integers", async () => {
+    const { exitCode, parsed } = await runCommand(["list", "--limit", "0"]);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("limit");
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("--limit rejects values above 200", async () => {
+    const { exitCode, parsed } = await runCommand(["list", "--limit", "500"]);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("200");
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("--offset rejects negative values", async () => {
+    const { exitCode, parsed } = await runCommand(["list", "--offset", "-1"]);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("offset");
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("empty --conversation-id is rejected", async () => {
+    const { exitCode, parsed } = await runCommand([
+      "list",
+      "--conversation-id",
+      "   ",
+    ]);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("Conversation ID");
+    expect(ipcCalls).toHaveLength(0);
   });
 
   test("list surfaces IPC error response", async () => {
@@ -524,7 +668,7 @@ describe("notifications list", () => {
   test("list maps daemon 4xx to exit 2", async () => {
     ipcResponse = {
       ok: false,
-      error: "Invalid limit",
+      error: "Invalid filter",
       statusCode: 400,
     };
 
@@ -532,7 +676,7 @@ describe("notifications list", () => {
 
     expect(exitCode).toBe(2);
     expect(parsed.ok).toBe(false);
-    expect(parsed.error).toBe("Invalid limit");
+    expect(parsed.error).toBe("Invalid filter");
   });
 
   test("list maps daemon 5xx to exit 3", async () => {

package/src/cli/commands/browser.ts

@@ -412,6 +412,253 @@ Examples:
   for (const meta of BROWSER_OPERATION_META) {
     buildSubcommand(browser, meta);
   }
+
+  // -- tabs subcommand group
+  const tabs = browser
+    .command("tabs")
+    .description("Manage browser tabs");
+
+  tabs
+    .command("list")
+    .description("List all open browser tabs")
+    .option("--pretty", "Human-readable table output instead of JSON")
+    .action(async (opts: { pretty?: boolean }) => {
+      const parentOpts = browser.opts() as {
+        session?: string;
+        json?: boolean;
+        targetClientId?: string;
+      };
+      const sessionId = parentOpts.session ?? "default";
+      const jsonMode = parentOpts.json ?? false;
+      const conversationId = resolveContextConversationId();
+      const targetClientId = parentOpts.targetClientId;
+
+      const ipcResult = await cliIpcCall<{
+        ok: boolean;
+        tabs?: Array<{
+          tabId?: number;
+          windowId?: number;
+          url?: string;
+          title?: string;
+          active: boolean;
+          pinned: boolean;
+        }>;
+      }>(
+        "browser_tabs",
+        {
+          body: {
+            command: "list",
+            sessionId,
+            ...(conversationId ? { conversationId } : {}),
+            ...(targetClientId ? { targetClientId } : {}),
+          },
+        },
+        { timeoutMs: 30_000 },
+      );
+
+      if (!ipcResult.ok) {
+        if (jsonMode) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: ipcResult.error }) + "\n",
+          );
+        } else {
+          log.error(`Error: ${ipcResult.error}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      const tabList = ipcResult.result?.tabs ?? [];
+
+      if (jsonMode || !opts.pretty) {
+        process.stdout.write(JSON.stringify(tabList) + "\n");
+      } else {
+        if (tabList.length === 0) {
+          log.info("No tabs found.");
+          return;
+        }
+        log.info(
+          `${"ID".padEnd(8)} ${"WIN".padEnd(5)} ${"ACT".padEnd(4)} ${"PIN".padEnd(4)} URL/Title`,
+        );
+        log.info("-".repeat(80));
+        for (const tab of tabList) {
+          const id = String(tab.tabId ?? "?").padEnd(8);
+          const win = String(tab.windowId ?? "?").padEnd(5);
+          const act = (tab.active ? "yes" : "no").padEnd(4);
+          const pin = (tab.pinned ? "yes" : "no").padEnd(4);
+          const label = tab.url ?? tab.title ?? "(untitled)";
+          log.info(`${id} ${win} ${act} ${pin} ${label}`);
+        }
+      }
+    });
+
+  tabs
+    .command("select")
+    .description("Select (activate) a browser tab by ID")
+    .requiredOption("--tab-id <id>", "Tab ID to select", Number)
+    .action(async (opts: { tabId: number }) => {
+      const parentOpts = browser.opts() as {
+        session?: string;
+        json?: boolean;
+        targetClientId?: string;
+      };
+      const sessionId = parentOpts.session ?? "default";
+      const jsonMode = parentOpts.json ?? false;
+      const conversationId = resolveContextConversationId();
+      const targetClientId = parentOpts.targetClientId;
+
+      const ipcResult = await cliIpcCall<{ ok: boolean; tab?: unknown }>(
+        "browser_tabs",
+        {
+          body: {
+            command: "select",
+            sessionId,
+            tabId: opts.tabId,
+            ...(conversationId ? { conversationId } : {}),
+            ...(targetClientId ? { targetClientId } : {}),
+          },
+        },
+        { timeoutMs: 30_000 },
+      );
+
+      if (!ipcResult.ok) {
+        if (jsonMode) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: ipcResult.error }) + "\n",
+          );
+        } else {
+          log.error(`Error: ${ipcResult.error}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      if (jsonMode) {
+        process.stdout.write(
+          JSON.stringify({ ok: true, tab: ipcResult.result?.tab }) + "\n",
+        );
+      } else {
+        log.info(`Selected tab ${opts.tabId}`);
+      }
+    });
+
+  tabs
+    .command("new")
+    .description("Open a new browser tab")
+    .option("--url <url>", "URL to navigate the new tab to")
+    .action(async (opts: { url?: string }) => {
+      const parentOpts = browser.opts() as {
+        session?: string;
+        json?: boolean;
+        targetClientId?: string;
+      };
+      const sessionId = parentOpts.session ?? "default";
+      const jsonMode = parentOpts.json ?? false;
+      const conversationId = resolveContextConversationId();
+      const targetClientId = parentOpts.targetClientId;
+
+      const ipcResult = await cliIpcCall<{
+        ok: boolean;
+        tabId?: string;
+        clientId?: string;
+      }>(
+        "browser_tabs",
+        {
+          body: {
+            command: "new",
+            sessionId,
+            ...(opts.url ? { url: opts.url } : {}),
+            ...(conversationId ? { conversationId } : {}),
+            ...(targetClientId ? { targetClientId } : {}),
+          },
+        },
+        { timeoutMs: 30_000 },
+      );
+
+      if (!ipcResult.ok) {
+        if (jsonMode) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: ipcResult.error }) + "\n",
+          );
+        } else {
+          log.error(`Error: ${ipcResult.error}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      if (jsonMode) {
+        process.stdout.write(
+          JSON.stringify({
+            ok: true,
+            tabId: ipcResult.result?.tabId,
+            clientId: ipcResult.result?.clientId,
+          }) + "\n",
+        );
+      } else {
+        log.info(
+          `Opened new tab${ipcResult.result?.tabId ? ` (ID: ${ipcResult.result.tabId})` : ""}`,
+        );
+      }
+    });
+
+  tabs
+    .command("close")
+    .description("Close a browser tab by ID")
+    .requiredOption("--tab-id <id>", "Tab ID to close", Number)
+    .action(async (opts: { tabId: number }) => {
+      const parentOpts = browser.opts() as {
+        session?: string;
+        json?: boolean;
+        targetClientId?: string;
+      };
+      const sessionId = parentOpts.session ?? "default";
+      const jsonMode = parentOpts.json ?? false;
+      const conversationId = resolveContextConversationId();
+      const targetClientId = parentOpts.targetClientId;
+
+      const ipcResult = await cliIpcCall<{
+        ok: boolean;
+        closed?: boolean;
+        tabId?: number;
+      }>(
+        "browser_tabs",
+        {
+          body: {
+            command: "close",
+            sessionId,
+            tabId: opts.tabId,
+            ...(conversationId ? { conversationId } : {}),
+            ...(targetClientId ? { targetClientId } : {}),
+          },
+        },
+        { timeoutMs: 30_000 },
+      );
+
+      if (!ipcResult.ok) {
+        if (jsonMode) {
+          process.stdout.write(
+            JSON.stringify({ ok: false, error: ipcResult.error }) + "\n",
+          );
+        } else {
+          log.error(`Error: ${ipcResult.error}`);
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      if (jsonMode) {
+        process.stdout.write(
+          JSON.stringify({
+            ok: true,
+            closed: ipcResult.result?.closed,
+            tabId: opts.tabId,
+          }) + "\n",
+        );
+      } else {
+        log.info(`Closed tab ${opts.tabId}`);
+      }
+    });
     },
   });
 }

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

@@ -0,0 +1,143 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
+
+// ---------------------------------------------------------------------------
+// Mock state
+// ---------------------------------------------------------------------------
+
+let mockCalls: Array<[string, Record<string, unknown> | undefined]> = [];
+let mockResponses: unknown[] = [];
+
+mock.module("../../../../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    mockCalls.push([method, params]);
+    return mockResponses.shift() ?? { ok: true, result: { success: true } };
+  },
+  exitFromIpcResult: (_r: unknown, _cmd: unknown) => {
+    throw new Error("exitFromIpcResult called");
+  },
+}));
+
+const { registerChannelsCommand } = await import("../index.js");
+
+function buildProgram(): Command {
+  const program = new Command();
+  program.exitOverride();
+  registerChannelsCommand(program);
+  return program;
+}
+
+async function runCli(...argv: string[]): Promise<string> {
+  const stdoutChunks: string[] = [];
+  const origWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = ((chunk: unknown) => {
+    stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+  try {
+    await buildProgram().parseAsync(["node", "assistant", ...argv]);
+  } finally {
+    process.stdout.write = origWrite;
+  }
+  return stdoutChunks.join("");
+}
+
+function emptySnapshot(channel: string, overrides: Record<string, unknown> = {}) {
+  return {
+    channel,
+    ready: false,
+    setupStatus: "not_configured",
+    checkedAt: 0,
+    stale: false,
+    reasons: [],
+    localChecks: [],
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("assistant channels", () => {
+  beforeEach(() => {
+    mockCalls = [];
+    mockResponses = [];
+    process.exitCode = 0;
+  });
+
+  describe("list", () => {
+    test("calls channels_readiness_get with includeRemote=false by default", async () => {
+      mockResponses = [
+        { ok: true, result: { success: true, snapshots: [] } },
+      ];
+      await runCli("channels", "list", "--json");
+      expect(mockCalls).toHaveLength(1);
+      expect(mockCalls[0][0]).toBe("channels_readiness_get");
+      expect(mockCalls[0][1]).toEqual({
+        queryParams: { includeRemote: "false" },
+      });
+    });
+
+    test("--remote flips includeRemote to true (still GET, still cached)", async () => {
+      mockResponses = [
+        { ok: true, result: { success: true, snapshots: [] } },
+      ];
+      await runCli("channels", "list", "--remote", "--json");
+      expect(mockCalls[0][0]).toBe("channels_readiness_get");
+      expect(mockCalls[0][1]).toEqual({
+        queryParams: { includeRemote: "true" },
+      });
+    });
+  });
+
+  describe("get", () => {
+    test("always re-probes via the refresh route (live, never cached)", async () => {
+      mockResponses = [
+        {
+          ok: true,
+          result: {
+            success: true,
+            snapshots: [emptySnapshot("slack")],
+          },
+        },
+      ];
+      await runCli("channels", "get", "slack", "--json");
+      expect(mockCalls[0][0]).toBe("channels_readiness_refresh_post");
+      expect(mockCalls[0][1]).toEqual({
+        body: { channel: "slack", includeRemote: true },
+      });
+    });
+
+    test("requires a channel argument", async () => {
+      // commander throws via exitOverride when arg is missing
+      await expect(runCli("channels", "get")).rejects.toThrow();
+      expect(mockCalls).toHaveLength(0);
+    });
+
+    test("exits non-zero when channel has no registered probe", async () => {
+      mockResponses = [
+        { ok: true, result: { success: true, snapshots: [] } },
+      ];
+      await runCli("channels", "get", "nope", "--json");
+      expect(process.exitCode).toBe(1);
+    });
+
+    test("does NOT accept --refresh flag (every get is live)", async () => {
+      // commander rejects unknown options via exitOverride
+      await expect(
+        runCli("channels", "get", "slack", "--refresh"),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("refresh", () => {
+    test("is not registered (mutating verb deferred to its own PR)", async () => {
+      // commander throws via exitOverride for unknown subcommands
+      await expect(
+        runCli("channels", "refresh", "slack"),
+      ).rejects.toThrow();
+    });
+  });
+});