@vellumai/assistant 0.8.0 → 0.8.1

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

@@ -1,110 +1,35 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { Command } from "commander";
 
 // ---------------------------------------------------------------------------
 // Mock state
 // ---------------------------------------------------------------------------
 
-let mockResolvePlatformCallbackRegistrationContext: () => Promise<
-  Record<string, unknown>
-> = async () => ({
-  isPlatform: false,
-  platformBaseUrl: "",
-  assistantId: "",
-  hasAssistantApiKey: false,
-  authHeader: null,
-  enabled: false,
-});
+let mockCalls: Array<[string, Record<string, unknown>]> = [];
+let mockResponse: unknown = { ok: true, result: { routes: [] } };
 
 // ---------------------------------------------------------------------------
 // Mocks
 // ---------------------------------------------------------------------------
 
-mock.module("../../../../inbound/platform-callback-registration.js", () => ({
-  resolvePlatformCallbackRegistrationContext: () =>
-    mockResolvePlatformCallbackRegistrationContext(),
-  registerCallbackRoute: async () => "",
-  resolveCallbackUrl: async () => "",
-}));
-
-mock.module("../../../lib/daemon-credential-client.js", () => ({
-  deleteSecureKeyViaDaemon: async () => "not-found" as const,
-  setSecureKeyViaDaemon: async () => false,
-}));
-
-const realLogger = await import("../../../../util/logger.js");
-mock.module("../../../../util/logger.js", () => ({
-  ...realLogger,
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-  getCliLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-  initLogger: () => {},
-  pruneOldLogFiles: () => 0,
+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 realConfigLoader = await import("../../../../config/loader.js");
-mock.module("../../../../config/loader.js", () => ({
-  ...realConfigLoader,
-  getConfig: () => ({
-    permissions: { mode: "workspace" },
-    skills: { load: { extraDirs: [] } },
-    sandbox: { enabled: true },
-  }),
-  loadConfig: () => ({}),
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-}));
-
-// ---------------------------------------------------------------------------
-// Import shared test utility (after mocks are registered)
-// ---------------------------------------------------------------------------
-
-const { runAssistantCommandFull } =
-  await import("../../../__tests__/run-assistant-command.js");
-
-// ---------------------------------------------------------------------------
-// Fetch mock
-// ---------------------------------------------------------------------------
-
-const originalFetch = globalThis.fetch;
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-});
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function connectedContext(
-  overrides: Record<string, unknown> = {},
-): Record<string, unknown> {
-  return {
-    isPlatform: false,
-    platformBaseUrl: "https://dev-platform.vellum.ai",
-    assistantId: "019d6d4f-6dbd-779f-91d3-cb273b9429a5",
-    hasAssistantApiKey: true,
-    authHeader: "Api-Key vak_test123",
-    enabled: false,
-    ...overrides,
-  };
-}
+const { registerPlatformCommand } = await import("../index.js");
 
-function mockFetchJson(body: unknown, status = 200): void {
-  globalThis.fetch = (async () =>
-    new Response(JSON.stringify(body), {
-      status,
-      headers: { "Content-Type": "application/json" },
-    })) as unknown as typeof globalThis.fetch;
+function buildProgram(): Command {
+  const program = new Command();
+  program.exitOverride();
+  registerPlatformCommand(program);
+  return program;
 }
 
 // ---------------------------------------------------------------------------
@@ -113,27 +38,36 @@ function mockFetchJson(body: unknown, status = 200): void {
 
 describe("assistant platform callback-routes list", () => {
   beforeEach(() => {
-    mockResolvePlatformCallbackRegistrationContext = async () =>
-      connectedContext();
-    process.exitCode = 0;
-  });
-
-  afterEach(() => {
+    mockCalls = [];
+    mockResponse = { ok: true, result: { routes: [] } };
     process.exitCode = 0;
   });
 
   test("returns empty list when no routes registered", async () => {
-    mockFetchJson([]);
-
-    const { stdout } = await runAssistantCommandFull(
-      "platform",
-      "callback-routes",
-      "list",
-      "--json",
-    );
-
-    expect(process.exitCode ?? 0).toBe(0);
-    const parsed = JSON.parse(stdout);
+    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(""));
     expect(parsed.ok).toBe(true);
     expect(parsed.routes).toEqual([]);
   });
@@ -152,22 +86,36 @@ describe("assistant platform callback-routes list", () => {
         id: "route-2",
         assistant_id: "019d6d4f-6dbd-779f-91d3-cb273b9429a5",
         type: "telegram",
-        callback_path: "019d6d4f-6dbd-779f-91d3-cb273b9429a5/webhooks/telegram",
+        callback_path:
+          "019d6d4f-6dbd-779f-91d3-cb273b9429a5/webhooks/telegram",
         callback_url:
           "https://dev-platform.vellum.ai/v1/gateway/callbacks/019d6d4f-6dbd-779f-91d3-cb273b9429a5/webhooks/telegram/",
       },
     ];
-    mockFetchJson(routes);
-
-    const { stdout } = await runAssistantCommandFull(
-      "platform",
-      "callback-routes",
-      "list",
-      "--json",
-    );
-
-    expect(process.exitCode ?? 0).toBe(0);
-    const parsed = JSON.parse(stdout);
+    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(""));
     expect(parsed.ok).toBe(true);
     expect(parsed.routes).toHaveLength(2);
     expect(parsed.routes[0].type).toBe("email");
@@ -175,69 +123,71 @@ describe("assistant platform callback-routes list", () => {
   });
 
   test("fails when platform credentials are missing", async () => {
-    mockResolvePlatformCallbackRegistrationContext = async () => ({
-      isPlatform: false,
-      platformBaseUrl: "",
-      assistantId: "",
-      hasAssistantApiKey: false,
-      authHeader: null,
-      enabled: false,
-    });
-
-    const { stdout } = await runAssistantCommandFull(
-      "platform",
-      "callback-routes",
-      "list",
-      "--json",
-    );
-
-    expect(process.exitCode).toBe(1);
-    const parsed = JSON.parse(stdout);
-    expect(parsed.ok).toBe(false);
-    expect(parsed.error).toContain("Platform credentials not available");
-  });
-
-  test("handles platform HTTP error", async () => {
-    mockFetchJson({ detail: "Unauthorized" }, 401);
-
-    const { stdout } = await runAssistantCommandFull(
-      "platform",
-      "callback-routes",
-      "list",
-      "--json",
-    );
-
-    expect(process.exitCode).toBe(1);
-    const parsed = JSON.parse(stdout);
-    expect(parsed.ok).toBe(false);
-    expect(parsed.error).toContain("HTTP 401");
+    mockResponse = {
+      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");
   });
 
-  test("works for self-hosted assistants with connected credentials", async () => {
-    mockResolvePlatformCallbackRegistrationContext = async () =>
-      connectedContext({ isPlatform: false, enabled: false });
-
-    mockFetchJson([
-      {
-        id: "route-1",
-        assistant_id: "019d6d4f-6dbd-779f-91d3-cb273b9429a5",
-        type: "email",
-        callback_path: "019d6d4f-6dbd-779f-91d3-cb273b9429a5/webhooks/email",
-        callback_url:
-          "https://dev-platform.vellum.ai/v1/gateway/callbacks/019d6d4f-6dbd-779f-91d3-cb273b9429a5/webhooks/email/",
+  test("callback-routes register calls platform_callback_routes_register", async () => {
+    mockResponse = {
+      ok: true,
+      result: {
+        callbackUrl:
+          "https://dev-platform.vellum.ai/v1/gateway/callbacks/asst/webhooks/telegram/",
+        callbackPath: "webhooks/telegram",
+        type: "telegram",
       },
-    ]);
-
-    const { stdout } = await runAssistantCommandFull(
-      "platform",
-      "callback-routes",
-      "list",
-      "--json",
-    );
-
-    expect(process.exitCode ?? 0).toBe(0);
-    const parsed = JSON.parse(stdout);
+    };
+
+    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("webhooks/telegram");
+    expect(
+      (mockCalls[0][1].body as Record<string, unknown>).type,
+    ).toBe("telegram");
+
+    const parsed = JSON.parse(stdoutChunks.join(""));
     expect(parsed.ok).toBe(true);
-    expect(parsed.routes).toHaveLength(1);
+    expect(parsed.callbackPath).toBe("webhooks/telegram");
   });
 });

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

@@ -1,153 +1,36 @@
-import { existsSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-const testDir = process.env.VELLUM_WORKSPACE_DIR!;
+import { Command } from "commander";
 
 // ---------------------------------------------------------------------------
 // Mock state
 // ---------------------------------------------------------------------------
 
-let mockGetSecureKeyAsync: (
-  account: string,
-) => Promise<string | undefined> = async () => undefined;
+let mockCalls: Array<[string, Record<string, unknown>]> = [];
+let mockResponse: unknown = { ok: true, result: { showPlatformLogin: true } };
 
 // ---------------------------------------------------------------------------
 // Mocks
 // ---------------------------------------------------------------------------
 
-mock.module("../../../../security/secure-keys.js", () => ({
-  getSecureKeyAsync: (account: string) => mockGetSecureKeyAsync(account),
-  getSecureKeyResultAsync: async () => ({
-    value: undefined,
-    unreachable: false,
-  }),
-  setSecureKeyAsync: async () => true,
-  deleteSecureKeyAsync: async () => "deleted" as const,
-  getProviderKeyAsync: async () => undefined,
-  getMaskedProviderKey: async () => undefined,
-  bulkSetSecureKeysAsync: async () => {},
-  listSecureKeysAsync: async () => ({ credentials: [] }),
-  setCesClient: () => {},
-  onCesClientChanged: () => ({ unsubscribe: () => {} }),
-  setCesReconnect: () => {},
-  getActiveBackendName: () => "file",
-  getActiveBackendInfoAsync: async () => ({
-    backend: "encrypted-store",
-    storePath: "/tmp/keys.enc",
-    storeKeyPath: "/tmp/store.key",
-    storeExists: false,
-    storeKeyExists: false,
-  }),
-  _resetBackend: () => {},
+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");
+  },
 }));
 
-mock.module("../../../lib/daemon-credential-client.js", () => ({
-  deleteSecureKeyViaDaemon: async () => "not-found" as const,
-  setSecureKeyViaDaemon: async () => true,
-}));
-
-mock.module("../../../../inbound/platform-callback-registration.js", () => ({
-  resolvePlatformCallbackRegistrationContext: async () => ({
-    isPlatform: false,
-    platformBaseUrl: "",
-    assistantId: "",
-    hasAssistantApiKey: false,
-    authHeader: null,
-    enabled: false,
-  }),
-  registerCallbackRoute: async () => "",
-  resolveCallbackUrl: async () => "",
-}));
-
-mock.module("../../../../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-  getCliLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-  initLogger: () => {},
-  truncateForLog: (value: string, maxLen = 500) =>
-    value.length > maxLen ? value.slice(0, maxLen) + "..." : value,
-  pruneOldLogFiles: () => 0,
-  LOG_FILE_PATTERN: /^assistant-(\d{4}-\d{2}-\d{2})\.log$/,
-}));
-
-mock.module("../../../../config/loader.js", () => ({
-  API_KEY_PROVIDERS: [] as const,
-  getConfig: () => ({
-    permissions: { mode: "workspace" },
-    skills: { load: { extraDirs: [] } },
-    sandbox: { enabled: true },
-  }),
-  getConfigReadOnly: () => ({
-    permissions: { mode: "workspace" },
-    skills: { load: { extraDirs: [] } },
-    sandbox: { enabled: true },
-  }),
-  loadConfig: () => ({}),
-  invalidateConfigCache: () => {},
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  applyNestedDefaults: (config: unknown) => config,
-  deepMergeOverwrite: () => {},
-  mergeDefaultWorkspaceConfig: () => {},
-}));
-
-// ---------------------------------------------------------------------------
-// Import module under test (after mocks are registered)
-// ---------------------------------------------------------------------------
-
-const { buildCliProgram } = await import("../../../program.js");
+const { registerPlatformConnectCommand } = await import("../connect.js");
 
-// ---------------------------------------------------------------------------
-// Test helper
-// ---------------------------------------------------------------------------
-
-async function runCommand(
-  args: string[],
-): Promise<{ stdout: string; exitCode: number }> {
-  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-  const originalStderrWrite = process.stderr.write.bind(process.stderr);
-  const stdoutChunks: string[] = [];
-
-  process.stdout.write = ((chunk: unknown) => {
-    stdoutChunks.push(typeof chunk === "string" ? chunk : String(chunk));
-    return true;
-  }) as typeof process.stdout.write;
-
-  process.stderr.write = (() => true) as typeof process.stderr.write;
-
-  process.exitCode = 0;
-
-  try {
-    const program = await buildCliProgram();
-    program.exitOverride();
-    program.configureOutput({
-      writeErr: () => {},
-      writeOut: (str: string) => stdoutChunks.push(str),
-    });
-    await program.parseAsync(["node", "assistant", ...args]);
-  } catch {
-    if (process.exitCode === 0) process.exitCode = 1;
-  } finally {
-    process.stdout.write = originalStdoutWrite;
-    process.stderr.write = originalStderrWrite;
-  }
-
-  const exitCode = process.exitCode ?? 0;
-  process.exitCode = 0;
-
-  return { exitCode, stdout: stdoutChunks.join("") };
+function buildProgram(): Command {
+  const program = new Command();
+  program.exitOverride();
+  program.option("--json", "JSON output");
+  registerPlatformConnectCommand(program);
+  return program;
 }
 
 // ---------------------------------------------------------------------------
@@ -156,70 +39,72 @@ async function runCommand(
 
 describe("assistant platform connect", () => {
   beforeEach(() => {
-    mockGetSecureKeyAsync = async () => undefined;
+    mockCalls = [];
+    mockResponse = { ok: true, result: { showPlatformLogin: true } };
     process.exitCode = 0;
-    // Remove any signal file left by previous tests
-    try {
-      rmSync(join(testDir, "signals"), { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
   });
 
-  test("writes emit-event signal file and reports success", async () => {
-    // GIVEN no existing platform credentials
-    mockGetSecureKeyAsync = async () => undefined;
+  test("calls platform_connect and reports login UI triggered", 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;
 
-    // WHEN the connect command is run with --json
-    const { exitCode, stdout } = await runCommand([
-      "platform",
-      "connect",
-      "--json",
-    ]);
+    try {
+      await program.parseAsync(["node", "assistant", "connect", "--json"]);
+    } finally {
+      process.stdout.write = origWrite;
+    }
 
-    // THEN the command succeeds
-    expect(exitCode).toBe(0);
+    expect(mockCalls.length).toBe(1);
+    expect(mockCalls[0][0]).toBe("platform_connect");
 
-    // AND the output confirms the login UI was triggered
-    const parsed = JSON.parse(stdout);
+    const parsed = JSON.parse(stdoutChunks.join(""));
     expect(parsed.ok).toBe(true);
     expect(parsed.showPlatformLogin).toBe(true);
-
-    // AND a show_platform_login emit-event signal file was written
-    const signalPath = join(testDir, "signals", "emit-event");
-    expect(existsSync(signalPath)).toBe(true);
-    const payload = JSON.parse(readFileSync(signalPath, "utf-8"));
-    expect(payload).toEqual({ type: "show_platform_login" });
   });
 
   test("already connected returns success with existing base URL", async () => {
-    // GIVEN stored platform credentials already exist
-    mockGetSecureKeyAsync = async (account: string) => {
-      if (account === "credential/vellum/platform_base_url")
-        return "https://platform.vellum.ai";
-      if (account === "credential/vellum/assistant_api_key")
-        return "sk-existing-key";
-      return undefined;
+    mockResponse = {
+      ok: true,
+      result: {
+        alreadyConnected: true,
+        baseUrl: "https://platform.vellum.ai",
+      },
     };
 
-    // WHEN the connect command is run with --json
-    const { exitCode, stdout } = await runCommand([
-      "platform",
-      "connect",
-      "--json",
-    ]);
+    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;
 
-    // THEN the command succeeds
-    expect(exitCode).toBe(0);
+    try {
+      await program.parseAsync(["node", "assistant", "connect", "--json"]);
+    } finally {
+      process.stdout.write = origWrite;
+    }
 
-    // AND the output indicates already connected with the base URL
-    const parsed = JSON.parse(stdout);
+    const parsed = JSON.parse(stdoutChunks.join(""));
     expect(parsed.ok).toBe(true);
     expect(parsed.alreadyConnected).toBe(true);
     expect(parsed.baseUrl).toBe("https://platform.vellum.ai");
+  });
 
-    // AND no emit-event signal file was written
-    const signalPath = join(testDir, "signals", "emit-event");
-    expect(existsSync(signalPath)).toBe(false);
+  test("calls exitFromIpcResult on error", async () => {
+    mockResponse = {
+      ok: false,
+      error: "Could not connect to the assistant",
+      statusCode: undefined,
+    };
+    const program = buildProgram();
+    await expect(
+      program.parseAsync(["node", "assistant", "connect", "--json"]),
+    ).rejects.toThrow("exitFromIpcResult called");
   });
 });