@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/cli/commands/platform/__tests__/callback-routes-list.test.ts

@@ -1,73 +1,25 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, test } from "bun:test";
 
-import { Command } from "commander";
+import {
+  runPlatform,
+  runPlatformCaught,
+  setupPlatformIpcMock,
+} from "./helpers.js";
 
-// ---------------------------------------------------------------------------
-// Mock state
-// ---------------------------------------------------------------------------
-
-let mockCalls: Array<[string, Record<string, unknown>]> = [];
-let mockResponse: unknown = { ok: true, result: { routes: [] } };
-
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-
-mock.module("../../../../ipc/cli-client.js", () => ({
-  cliIpcCall: async (method: string, params: Record<string, unknown>) => {
-    mockCalls.push([method, params]);
-    return mockResponse;
-  },
-  exitFromIpcResult: (_r: unknown, _cmd: unknown) => {
-    throw new Error("exitFromIpcResult called");
-  },
-}));
-
-const { registerPlatformCommand } = await import("../index.js");
-
-function buildProgram(): Command {
-  const program = new Command();
-  program.exitOverride();
-  registerPlatformCommand(program);
-  return program;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
+const ipc = setupPlatformIpcMock();
 
 describe("assistant platform callback-routes list", () => {
   beforeEach(() => {
-    mockCalls = [];
-    mockResponse = { ok: true, result: { routes: [] } };
-    process.exitCode = 0;
+    ipc.calls = [];
+    ipc.response = { ok: true, result: { routes: [] } };
   });
 
   test("returns empty list when no routes registered", async () => {
-    const program = buildProgram();
-    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 program.parseAsync([
-        "node",
-        "assistant",
-        "platform",
-        "callback-routes",
-        "list",
-        "--json",
-      ]);
-    } finally {
-      process.stdout.write = origWrite;
-    }
-
-    expect(mockCalls[0][0]).toBe("platform_callback_routes_list");
-
-    const parsed = JSON.parse(stdoutChunks.join(""));
+    const out = await runPlatform(["callback-routes", "list", "--json"]);
+
+    expect(ipc.calls[0][0]).toBe("platform_callback_routes_list");
+
+    const parsed = JSON.parse(out.join(""));
     expect(parsed.ok).toBe(true);
     expect(parsed.routes).toEqual([]);
   });
@@ -91,30 +43,11 @@ describe("assistant platform callback-routes list", () => {
           "https://dev-platform.vellum.ai/v1/gateway/callbacks/019d6d4f-6dbd-779f-91d3-cb273b9429a5/webhooks/telegram/",
       },
     ];
-    mockResponse = { ok: true, result: { routes } };
-
-    const program = buildProgram();
-    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 program.parseAsync([
-        "node",
-        "assistant",
-        "platform",
-        "callback-routes",
-        "list",
-        "--json",
-      ]);
-    } finally {
-      process.stdout.write = origWrite;
-    }
-
-    const parsed = JSON.parse(stdoutChunks.join(""));
+    ipc.response = { ok: true, result: { routes } };
+
+    const out = await runPlatform(["callback-routes", "list", "--json"]);
+
+    const parsed = JSON.parse(out.join(""));
     expect(parsed.ok).toBe(true);
     expect(parsed.routes).toHaveLength(2);
     expect(parsed.routes[0].type).toBe("email");
@@ -122,27 +55,23 @@ describe("assistant platform callback-routes list", () => {
   });
 
   test("fails when platform credentials are missing", async () => {
-    mockResponse = {
+    ipc.response = {
       ok: false,
       error: "Platform credentials not available",
       statusCode: 422,
     };
 
-    const program = buildProgram();
-    await expect(
-      program.parseAsync([
-        "node",
-        "assistant",
-        "platform",
-        "callback-routes",
-        "list",
-        "--json",
-      ]),
-    ).rejects.toThrow("exitFromIpcResult called");
+    const { thrown } = await runPlatformCaught([
+      "callback-routes",
+      "list",
+      "--json",
+    ]);
+
+    expect((thrown as Error).message).toBe("exitFromIpcResult called");
   });
 
   test("callback-routes register calls platform_callback_routes_register", async () => {
-    mockResponse = {
+    ipc.response = {
       ok: true,
       result: {
         callbackUrl:
@@ -152,40 +81,25 @@ describe("assistant platform callback-routes list", () => {
       },
     };
 
-    const program = buildProgram();
-    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 program.parseAsync([
-        "node",
-        "assistant",
-        "platform",
-        "callback-routes",
-        "register",
-        "--path",
-        "webhooks/telegram",
-        "--type",
-        "telegram",
-        "--json",
-      ]);
-    } finally {
-      process.stdout.write = origWrite;
-    }
-
-    expect(mockCalls[0][0]).toBe("platform_callback_routes_register");
-    expect((mockCalls[0][1].body as Record<string, unknown>).path).toBe(
+    const out = await runPlatform([
+      "callback-routes",
+      "register",
+      "--path",
+      "webhooks/telegram",
+      "--type",
+      "telegram",
+      "--json",
+    ]);
+
+    expect(ipc.calls[0][0]).toBe("platform_callback_routes_register");
+    expect((ipc.calls[0][1].body as Record<string, unknown>).path).toBe(
       "webhooks/telegram",
     );
-    expect((mockCalls[0][1].body as Record<string, unknown>).type).toBe(
+    expect((ipc.calls[0][1].body as Record<string, unknown>).type).toBe(
       "telegram",
     );
 
-    const parsed = JSON.parse(stdoutChunks.join(""));
+    const parsed = JSON.parse(out.join(""));
     expect(parsed.ok).toBe(true);
     expect(parsed.callbackPath).toBe("webhooks/telegram");
   });

package/src/cli/commands/platform/__tests__/credits.test.ts

@@ -1,69 +1,13 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, test } from "bun:test";
 
-import { Command } from "commander";
+import { runPlatform, setupPlatformIpcMock } from "./helpers.js";
 
-// ---------------------------------------------------------------------------
-// Mock state
-// ---------------------------------------------------------------------------
-
-let mockCalls: Array<[string, Record<string, unknown>]> = [];
-let mockResponse: unknown = {
-  ok: true,
-  result: {
-    remaining: 42.17,
-    settled: 50,
-    pending: 7.83,
-    unit: "USD",
-    stale: false,
-    as_of: "2026-07-06T00:00:00.000Z",
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-
-mock.module("../../../../ipc/cli-client.js", () => ({
-  cliIpcCall: async (method: string, params: Record<string, unknown>) => {
-    mockCalls.push([method, params]);
-    return mockResponse;
-  },
-  exitFromIpcResult: (_r: unknown, _cmd: unknown) => {
-    throw new Error("exitFromIpcResult called");
-  },
-}));
-
-const { registerPlatformCommand } = await import("../index.js");
-
-function buildProgram(): Command {
-  const program = new Command();
-  program.exitOverride();
-  registerPlatformCommand(program);
-  return program;
-}
-
-function captureStdout(fn: () => Promise<void>): Promise<string[]> {
-  const chunks: string[] = [];
-  const origWrite = process.stdout.write.bind(process.stdout);
-  process.stdout.write = ((chunk: unknown) => {
-    chunks.push(typeof chunk === "string" ? chunk : String(chunk));
-    return true;
-  }) as typeof process.stdout.write;
-  return fn()
-    .then(() => chunks)
-    .finally(() => {
-      process.stdout.write = origWrite;
-    });
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
+const ipc = setupPlatformIpcMock();
 
 describe("assistant platform credits", () => {
   beforeEach(() => {
-    mockCalls = [];
-    mockResponse = {
+    ipc.calls = [];
+    ipc.response = {
       ok: true,
       result: {
         remaining: 42.17,
@@ -74,22 +18,12 @@ describe("assistant platform credits", () => {
         as_of: "2026-07-06T00:00:00.000Z",
       },
     };
-    process.exitCode = 0;
   });
 
   test("calls platform_credits and emits balance JSON with --json", async () => {
-    const out = await captureStdout(async () => {
-      const program = buildProgram();
-      await program.parseAsync([
-        "node",
-        "assistant",
-        "platform",
-        "credits",
-        "--json",
-      ]);
-    });
+    const out = await runPlatform(["credits", "--json"]);
 
-    expect(mockCalls[0][0]).toBe("platform_credits");
+    expect(ipc.calls[0][0]).toBe("platform_credits");
 
     const parsed = JSON.parse(out.join(""));
     expect(parsed.remaining).toBe(42.17);
@@ -100,12 +34,9 @@ describe("assistant platform credits", () => {
   });
 
   test("plain text mode does not emit JSON to stdout", async () => {
-    const out = await captureStdout(async () => {
-      const program = buildProgram();
-      await program.parseAsync(["node", "assistant", "platform", "credits"]);
-    });
+    const out = await runPlatform(["credits"]);
 
-    // Plain-text mode logs via log.info — verify writeOutput (JSON) was NOT called
+    // Plain-text mode logs via log.info; verify writeOutput (JSON) was NOT called
     expect(() => JSON.parse(out.join("").trim())).toThrow();
   });
 });

package/src/cli/commands/platform/__tests__/helpers.ts

@@ -0,0 +1,90 @@
+import { mock } from "bun:test";
+
+import { Command } from "commander";
+
+/** Mutable per-file mock state returned by {@link setupPlatformIpcMock}. */
+export interface PlatformIpcMockState {
+  /** Every (method, params) pair passed to the mocked cliIpcCall. */
+  calls: Array<[string, Record<string, unknown>]>;
+  /** The value the mocked cliIpcCall resolves with. */
+  response: unknown;
+}
+
+/**
+ * Install the shared IPC client mock for a platform command test file.
+ *
+ * bun's mock.module is global per test file, so each file must call this
+ * once at module top level (before importing ../index.js) and drive the
+ * mock through the returned state object. The mocked exitFromIpcResult
+ * throws so tests can assert the error path without exiting the process.
+ */
+export function setupPlatformIpcMock(): PlatformIpcMockState {
+  const state: PlatformIpcMockState = { calls: [], response: undefined };
+  mock.module("../../../../ipc/cli-client.js", () => ({
+    cliIpcCall: async (method: string, params: Record<string, unknown>) => {
+      state.calls.push([method, params]);
+      return state.response;
+    },
+    exitFromIpcResult: (_r: unknown, _cmd: unknown) => {
+      throw new Error("exitFromIpcResult called");
+    },
+  }));
+  return state;
+}
+
+/**
+ * Build a fresh commander program with the platform command registered.
+ * Imported lazily so the file-level mock installed by
+ * {@link setupPlatformIpcMock} is in place first.
+ */
+export async function buildPlatformProgram(): Promise<Command> {
+  const { registerPlatformCommand } = await import("../index.js");
+  const program = new Command();
+  program.exitOverride();
+  registerPlatformCommand(program);
+  return program;
+}
+
+/** Capture everything written to stdout while fn runs. */
+export function captureStdout(fn: () => Promise<void>): Promise<string[]> {
+  const chunks: string[] = [];
+  const origWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = ((chunk: unknown) => {
+    chunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
+  return fn()
+    .then(() => chunks)
+    .finally(() => {
+      process.stdout.write = origWrite;
+    });
+}
+
+/** Run 'assistant platform <args>' against a fresh program, capturing stdout. */
+export async function runPlatform(args: string[]): Promise<string[]> {
+  const { out, thrown } = await runPlatformCaught(args);
+  if (thrown !== undefined) {
+    throw thrown;
+  }
+  return out;
+}
+
+/**
+ * Like {@link runPlatform}, but capture whatever the parse throws instead of
+ * propagating it (the mocked exitFromIpcResult error, Commander's exitOverride
+ * on --help), so tests can assert on both the output and the thrown value.
+ */
+export async function runPlatformCaught(
+  args: string[],
+): Promise<{ out: string[]; thrown: unknown }> {
+  let thrown: unknown;
+  const out = await captureStdout(async () => {
+    const program = await buildPlatformProgram();
+    try {
+      await program.parseAsync(["node", "assistant", "platform", ...args]);
+    } catch (err) {
+      thrown = err;
+    }
+  });
+  return { out, thrown };
+}

package/src/cli/commands/platform/__tests__/invoices.test.ts

@@ -0,0 +1,238 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  runPlatform,
+  runPlatformCaught,
+  setupPlatformIpcMock,
+} from "./helpers.js";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const invoiceA = {
+  id: "in_a",
+  number: "INV-0001",
+  status: "paid",
+  currency: "usd",
+  amount_due: 1234,
+  amount_paid: 1234,
+  amount_remaining: 0,
+  created: 1750000000,
+  hosted_invoice_url: "https://pay.example.com/in_a",
+  invoice_pdf: "https://pay.example.com/in_a.pdf",
+};
+
+const invoiceB = {
+  id: "in_b",
+  number: null,
+  status: "open",
+  currency: "usd",
+  amount_due: 5600,
+  amount_paid: 0,
+  amount_remaining: 5600,
+  created: 1747000000,
+  hosted_invoice_url: null,
+  invoice_pdf: null,
+};
+
+const ipc = setupPlatformIpcMock();
+
+function runInvoices(args: string[]): Promise<string[]> {
+  return runPlatform(["invoices", ...args]);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("assistant platform invoices list", () => {
+  beforeEach(() => {
+    ipc.calls = [];
+    ipc.response = {
+      ok: true,
+      result: { invoices: [invoiceA, invoiceB], has_more: false },
+    };
+  });
+
+  test("calls platform_invoices_list and emits the page as JSON with --json", async () => {
+    const out = await runInvoices(["list", "--json"]);
+
+    expect(ipc.calls[0][0]).toBe("platform_invoices_list");
+    expect(ipc.calls[0][1]).toEqual({});
+
+    const parsed = JSON.parse(out.join(""));
+    expect(parsed.invoices).toHaveLength(2);
+    expect(parsed.invoices[0].id).toBe("in_a");
+    expect(parsed.has_more).toBe(false);
+  });
+
+  test("forwards --starting-after as the starting_after query param", async () => {
+    await runInvoices(["list", "--starting-after", "in_a", "--json"]);
+
+    expect(ipc.calls[0][0]).toBe("platform_invoices_list");
+    expect(ipc.calls[0][1]).toEqual({
+      queryParams: { starting_after: "in_a" },
+    });
+  });
+
+  test("plain text mode renders number, status, and amount lines", async () => {
+    const out = await runInvoices(["list"]);
+    const text = out.join("");
+
+    expect(text).toContain("INV-0001");
+    expect(text).toContain("Status:  paid");
+    expect(text).toContain("Amount:  USD 12.34");
+    expect(text).toContain("https://pay.example.com/in_a");
+    // Invoice with a null number falls back to its id.
+    expect(text).toContain("in_b");
+    expect(text).toContain("Amount:  USD 56.00");
+    // Not JSON output.
+    expect(() => JSON.parse(text.trim())).toThrow();
+  });
+
+  test("plain text mode reports an empty page", async () => {
+    ipc.response = { ok: true, result: { invoices: [], has_more: false } };
+
+    const out = await runInvoices(["list"]);
+
+    expect(out.join("").trim()).toBe("No invoices found.");
+  });
+
+  test("plain text mode ends with a paging hint when has_more is true", async () => {
+    ipc.response = {
+      ok: true,
+      result: { invoices: [invoiceA, invoiceB], has_more: true },
+    };
+
+    const out = await runInvoices(["list"]);
+
+    expect(out.join("").trim()).toEndWith(
+      "More invoices available. Run 'assistant platform invoices list --starting-after in_b' for the next page.",
+    );
+  });
+
+  test("plain text mode omits the paging hint when has_more is false", async () => {
+    const out = await runInvoices(["list"]);
+
+    expect(out.join("")).not.toContain("More invoices available");
+  });
+});
+
+describe("assistant platform invoices get", () => {
+  beforeEach(() => {
+    ipc.calls = [];
+    ipc.response = { ok: true, result: invoiceA };
+  });
+
+  test("calls platform_invoices_by_id_get with the id path param and emits JSON with --json", async () => {
+    const out = await runInvoices(["get", "in_123", "--json"]);
+
+    expect(ipc.calls[0][0]).toBe("platform_invoices_by_id_get");
+    expect(ipc.calls[0][1]).toEqual({ pathParams: { id: "in_123" } });
+
+    const parsed = JSON.parse(out.join(""));
+    expect(parsed.id).toBe("in_a");
+    expect(parsed.amount_due).toBe(1234);
+  });
+
+  test("plain text mode renders the invoice block including the PDF link", async () => {
+    const out = await runInvoices(["get", "in_a"]);
+    const text = out.join("");
+
+    expect(text).toContain("INV-0001");
+    expect(text).toContain("Status:  paid");
+    expect(text).toContain("Amount:  USD 12.34");
+    expect(text).toContain("PDF:     https://pay.example.com/in_a.pdf");
+  });
+
+  test("plain text mode scales zero-decimal currencies without dividing by 100", async () => {
+    ipc.response = {
+      ok: true,
+      result: { ...invoiceA, currency: "jpy", amount_due: 1200 },
+    };
+
+    const out = await runInvoices(["get", "in_a"]);
+
+    expect(out.join("")).toContain("Amount:  JPY 1,200");
+  });
+
+  test("plain text mode uses three decimals for three-decimal currencies", async () => {
+    ipc.response = {
+      ok: true,
+      result: { ...invoiceA, currency: "bhd", amount_due: 12345 },
+    };
+
+    const out = await runInvoices(["get", "in_a"]);
+
+    expect(out.join("")).toContain("Amount:  BHD 12.345");
+  });
+
+  test("plain text mode keeps Stripe's two-decimal scaling for ISK despite ISO zero-decimal metadata", async () => {
+    ipc.response = {
+      ok: true,
+      result: { ...invoiceA, currency: "isk", amount_due: 500 },
+    };
+
+    const out = await runInvoices(["get", "in_a"]);
+
+    expect(out.join("")).toContain("Amount:  ISK 5.00");
+  });
+
+  test("plain text mode falls back to raw minor units for invalid currency codes", async () => {
+    ipc.response = {
+      ok: true,
+      result: { ...invoiceA, currency: "zz", amount_due: 1234 },
+    };
+
+    const out = await runInvoices(["get", "in_a"]);
+
+    expect(out.join("")).toContain("Amount:  1234 ZZ (minor units)");
+  });
+});
+
+describe("assistant platform invoices error handling", () => {
+  beforeEach(() => {
+    ipc.calls = [];
+    ipc.response = {
+      ok: false,
+      error: "Platform credentials not available",
+      statusCode: 422,
+    };
+  });
+
+  test("list exits via exitFromIpcResult on IPC failure without writing output", async () => {
+    const { out, thrown } = await runPlatformCaught(["invoices", "list"]);
+
+    expect((thrown as Error).message).toBe("exitFromIpcResult called");
+    expect(out.join("")).toBe("");
+  });
+
+  test("get exits via exitFromIpcResult on IPC failure without writing output", async () => {
+    const { out, thrown } = await runPlatformCaught([
+      "invoices",
+      "get",
+      "in_missing",
+    ]);
+
+    expect((thrown as Error).message).toBe("exitFromIpcResult called");
+    expect(out.join("")).toBe("");
+  });
+});
+
+describe("assistant platform invoices --help", () => {
+  test("group help renders both subcommands", async () => {
+    const { out } = await runPlatformCaught(["invoices", "--help"]);
+    const text = out.join("");
+
+    expect(text).toContain("list");
+    expect(text).toContain("get");
+    expect(text).toContain("Stripe invoice history");
+  });
+
+  test("list help renders the --starting-after option", async () => {
+    const { out } = await runPlatformCaught(["invoices", "list", "--help"]);
+
+    expect(out.join("")).toContain("--starting-after <invoice-id>");
+  });
+});