@chanl-ai/cli 2.0.1

package/dist/__tests__/cli.test.js

@@ -0,0 +1,2313 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { createProgram } from "../cli";
+import { configStore } from "../utils/config-store";
+import { ChanlSDK } from "@chanl-ai/sdk";
+vi.mock("@chanl-ai/sdk", () => ({
+  ChanlSDK: vi.fn()
+}));
+vi.mock("../utils/config-store", () => ({
+  configStore: {
+    getApiKey: vi.fn(),
+    getBaseUrl: vi.fn(() => "https://api.chanl.ai"),
+    getWorkspaceId: vi.fn(() => "ws_123"),
+    getJwtToken: vi.fn(() => null),
+    getAuthMethod: vi.fn(() => null),
+    getAppUrl: vi.fn(() => "https://app.chanl.ai"),
+    setApiKey: vi.fn(),
+    setBaseUrl: vi.fn(),
+    setWorkspaceId: vi.fn(),
+    removeApiKey: vi.fn(),
+    clearAuth: vi.fn(),
+    delete: vi.fn(),
+    isAuthenticated: vi.fn(),
+    getPath: vi.fn(() => "/home/user/.chanl/config.json")
+  }
+}));
+function captureOutput() {
+  const logs = [];
+  const errors = [];
+  const originalLog = console.log;
+  const originalError = console.error;
+  console.log = (...args) => {
+    logs.push(args.map(String).join(" "));
+  };
+  console.error = (...args) => {
+    errors.push(args.map(String).join(" "));
+  };
+  return {
+    logs,
+    errors,
+    restore: () => {
+      console.log = originalLog;
+      console.error = originalError;
+    }
+  };
+}
+async function runCli(args) {
+  const output = captureOutput();
+  const program = createProgram();
+  process.exitCode = void 0;
+  try {
+    await program.parseAsync(["node", "chanl", ...args]);
+  } catch {
+  }
+  output.restore();
+  return {
+    exitCode: process.exitCode ?? 0,
+    logs: output.logs,
+    errors: output.errors
+  };
+}
+const mockTool = {
+  id: "tool_weather123",
+  workspaceId: "ws_123",
+  name: "get_weather",
+  description: "Get weather for a city",
+  type: "http",
+  inputSchema: {
+    type: "object",
+    properties: {
+      city: { type: "string", description: "City name" }
+    },
+    required: ["city"]
+  },
+  configuration: {
+    http: { method: "GET", url: "https://wttr.in/{{city}}" }
+  },
+  isEnabled: true,
+  tags: ["weather", "utility"],
+  createdBy: "user_123",
+  stats: {
+    totalCalls: 100,
+    successfulCalls: 95,
+    failedCalls: 5,
+    averageLatencyMs: 250,
+    lastCalledAt: "2025-01-15T10:30:00Z"
+  },
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-01-15T10:30:00Z"
+};
+const mockExecution = {
+  id: "exec_abc123",
+  toolId: "tool_weather123",
+  workspaceId: "ws_123",
+  source: "api",
+  status: "completed",
+  input: { city: "London" },
+  output: { temperature: "12\xB0C", condition: "Cloudy" },
+  executionTimeMs: 245,
+  createdAt: "2025-01-15T10:30:00Z",
+  updatedAt: "2025-01-15T10:30:00Z"
+};
+const mockMcpConfig = {
+  serverUrl: "https://my-workspace.chanl.app/mcp",
+  environment: "production",
+  status: "active",
+  toolCount: 15,
+  resourceCount: 8,
+  promptCount: 5,
+  agentConfigs: {
+    claude: {
+      mcpServers: {
+        chanl: {
+          url: "https://my-workspace.chanl.app/mcp",
+          headers: { "X-API-Key": "${CHANL_MCP_API_KEY}" },
+          transport: "streamable-http"
+        }
+      }
+    },
+    cursor: {
+      mcpServers: {
+        chanl: {
+          url: "https://my-workspace.chanl.app/mcp",
+          headers: { "X-API-Key": "${CHANL_MCP_API_KEY}" },
+          transport: "streamable-http"
+        }
+      }
+    },
+    generic: {
+      url: "https://my-workspace.chanl.app/mcp",
+      headers: { "X-API-Key": "${CHANL_MCP_API_KEY}" },
+      transport: "streamable-http"
+    }
+  }
+};
+const mockMcpStatusHealthy = {
+  healthy: true,
+  message: "MCP server is running",
+  responseTimeMs: 45
+};
+const mockMcpStatusUnhealthy = {
+  healthy: false,
+  message: "Failed to connect to MCP server",
+  error: "Connection refused"
+};
+const mockToolset = {
+  id: "toolset_abc123",
+  workspaceId: "ws_123",
+  name: "customer_support_tools",
+  description: "Tools for customer support agents",
+  tools: ["tool_weather123", "tool_lookup456"],
+  toolCount: 2,
+  enabled: true,
+  isPublic: false,
+  version: "1.0.0",
+  tags: ["support", "customer-facing"],
+  createdBy: "user_123",
+  createdAt: "2025-01-01T00:00:00Z",
+  updatedAt: "2025-01-15T10:30:00Z"
+};
+describe("CLI", () => {
+  let mockSdk;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSdk = {
+      tools: {
+        list: vi.fn(),
+        get: vi.fn(),
+        create: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn(),
+        execute: vi.fn(),
+        test: vi.fn(),
+        getExecutions: vi.fn(),
+        enable: vi.fn(),
+        disable: vi.fn(),
+        getCategories: vi.fn()
+      },
+      toolsets: {
+        list: vi.fn(),
+        get: vi.fn(),
+        create: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn(),
+        enable: vi.fn(),
+        disable: vi.fn(),
+        manageTools: vi.fn()
+      },
+      workspace: {
+        getAll: vi.fn(),
+        getById: vi.fn()
+      },
+      mcp: {
+        getConfig: vi.fn(),
+        getStatus: vi.fn(),
+        listTools: vi.fn(),
+        callTool: vi.fn(),
+        getTool: vi.fn()
+      },
+      chat: {
+        createSession: vi.fn(),
+        sendMessage: vi.fn(),
+        getMessages: vi.fn(),
+        endSession: vi.fn(),
+        deleteSession: vi.fn(),
+        session: vi.fn()
+      },
+      calls: {
+        list: vi.fn(),
+        get: vi.fn(),
+        getTranscript: vi.fn(),
+        getMetrics: vi.fn(),
+        getAnalysis: vi.fn(),
+        analyze: vi.fn(),
+        import: vi.fn(),
+        delete: vi.fn(),
+        bulkDelete: vi.fn()
+      },
+      scenarios: {
+        list: vi.fn(),
+        get: vi.fn(),
+        run: vi.fn(),
+        runAll: vi.fn(),
+        getExecution: vi.fn(),
+        getExecutions: vi.fn(),
+        getSimulations: vi.fn()
+      },
+      agents: {
+        list: vi.fn(),
+        get: vi.fn(),
+        create: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn(),
+        sync: vi.fn(),
+        syncAll: vi.fn(),
+        getStats: vi.fn(),
+        importFromPlatform: vi.fn(),
+        publish: vi.fn(),
+        pushMcp: vi.fn()
+      },
+      prompts: {
+        list: vi.fn(),
+        get: vi.fn(),
+        create: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn()
+      }
+    };
+    ChanlSDK.mockImplementation(() => mockSdk);
+    configStore.getApiKey.mockReturnValue("test-api-key");
+    configStore.getWorkspaceId.mockReturnValue("ws_123");
+    configStore.isAuthenticated.mockReturnValue(true);
+  });
+  afterEach(() => {
+    process.exitCode = void 0;
+  });
+  describe("--help", () => {
+    it("should have all expected commands in program", () => {
+      const program = createProgram();
+      const commandNames = program.commands.map((c) => c.name());
+      expect(commandNames).toContain("login");
+      expect(commandNames).toContain("logout");
+      expect(commandNames).toContain("auth");
+      expect(commandNames).toContain("config");
+      expect(commandNames).toContain("tools");
+    });
+  });
+  describe("--version", () => {
+    it("should have correct version in program", () => {
+      const program = createProgram();
+      expect(program.version()).toBe("1.0.0");
+    });
+  });
+  describe("tools list", () => {
+    it("should list tools with table output", async () => {
+      mockSdk.tools.list.mockResolvedValue({
+        success: true,
+        data: {
+          tools: [mockTool],
+          total: 1,
+          pagination: {
+            page: 1,
+            limit: 20,
+            totalPages: 1,
+            hasNext: false,
+            hasPrev: false
+          }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["tools", "list"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.tools.list).toHaveBeenCalledWith(expect.any(Object));
+      const output = logs.join("\n");
+      expect(output).toContain("get_weather");
+      expect(output).toContain("http");
+      expect(output).toContain("Total: 1 tools");
+    });
+    it("should list tools with JSON output", async () => {
+      mockSdk.tools.list.mockResolvedValue({
+        success: true,
+        data: {
+          tools: [mockTool],
+          total: 1,
+          pagination: {
+            page: 1,
+            limit: 20,
+            totalPages: 1,
+            hasNext: false,
+            hasPrev: false
+          }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "tools", "list"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.tools).toHaveLength(1);
+      expect(parsed.tools[0].name).toBe("get_weather");
+    });
+    it("should filter by type", async () => {
+      mockSdk.tools.list.mockResolvedValue({
+        success: true,
+        data: {
+          tools: [mockTool],
+          total: 1,
+          pagination: { page: 1, limit: 20, totalPages: 1, hasNext: false, hasPrev: false }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await runCli(["tools", "list", "--type", "http"]);
+      expect(mockSdk.tools.list).toHaveBeenCalledWith(
+        expect.objectContaining({ type: "http" })
+      );
+    });
+    it("should filter by enabled status", async () => {
+      mockSdk.tools.list.mockResolvedValue({
+        success: true,
+        data: {
+          tools: [mockTool],
+          total: 1,
+          pagination: { page: 1, limit: 20, totalPages: 1, hasNext: false, hasPrev: false }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await runCli(["tools", "list", "--enabled"]);
+      expect(mockSdk.tools.list).toHaveBeenCalledWith(
+        expect.objectContaining({ isEnabled: true })
+      );
+    });
+  });
+  describe("tools get", () => {
+    it("should get tool by ID", async () => {
+      mockSdk.tools.get.mockResolvedValue({
+        success: true,
+        data: { tool: mockTool },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["tools", "get", "tool_weather123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.tools.get).toHaveBeenCalledWith("tool_weather123");
+      const output = logs.join("\n");
+      expect(output).toContain("get_weather");
+      expect(output).toContain("http");
+    });
+    it("should output JSON when --json flag is used", async () => {
+      mockSdk.tools.get.mockResolvedValue({
+        success: true,
+        data: { tool: mockTool },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "tools", "get", "tool_weather123"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.name).toBe("get_weather");
+    });
+  });
+  describe("tools execute", () => {
+    it("should execute tool with input", async () => {
+      mockSdk.tools.execute.mockResolvedValue({
+        success: true,
+        data: {
+          success: true,
+          data: { temperature: "12\xB0C", condition: "Cloudy" },
+          latencyMs: 245,
+          traceId: "trace_abc123",
+          executionId: "exec_abc123"
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "tools",
+        "execute",
+        "tool_weather123",
+        "--input",
+        '{"city":"London"}'
+      ]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.tools.execute).toHaveBeenCalledWith("tool_weather123", { city: "London" });
+      const output = logs.join("\n");
+      expect(output).toContain("Success");
+      expect(output).toContain("245ms");
+    });
+    it("should handle invalid JSON input", async () => {
+      const { exitCode, errors } = await runCli([
+        "tools",
+        "execute",
+        "tool_weather123",
+        "--input",
+        "not-valid-json"
+      ]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Invalid JSON"))).toBe(true);
+    });
+  });
+  describe("tools delete", () => {
+    it("should delete tool with --yes flag", async () => {
+      mockSdk.tools.delete.mockResolvedValue({
+        success: true,
+        data: { deleted: true },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["tools", "delete", "tool_weather123", "--yes"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.tools.delete).toHaveBeenCalledWith("tool_weather123");
+      const output = logs.join("\n");
+      expect(output).toContain("Deleted");
+    });
+  });
+  describe("tools executions", () => {
+    it("should list executions for a tool", async () => {
+      mockSdk.tools.getExecutions.mockResolvedValue({
+        success: true,
+        data: {
+          data: [mockExecution],
+          total: 1,
+          page: 1,
+          limit: 10,
+          pagination: {
+            page: 1,
+            limit: 10,
+            totalPages: 1,
+            hasNext: false,
+            hasPrev: false
+          }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["tools", "executions", "tool_weather123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.tools.getExecutions).toHaveBeenCalledWith("tool_weather123", expect.any(Object));
+      const output = logs.join("\n");
+      expect(output).toContain("exec_abc123");
+      expect(output).toContain("completed");
+    });
+  });
+  describe("auth status", () => {
+    it("should show authenticated status", async () => {
+      configStore.getApiKey.mockReturnValue("chk_test1234567890");
+      configStore.getAuthMethod.mockReturnValue("api-key");
+      configStore.getWorkspaceId.mockReturnValue("ws_abc123");
+      const { logs, exitCode } = await runCli(["auth", "status"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("Authenticated");
+    });
+    it("should show not authenticated when no API key", async () => {
+      configStore.getApiKey.mockReturnValue(null);
+      configStore.getAuthMethod.mockReturnValue(null);
+      const { logs } = await runCli(["auth", "status"]);
+      const output = logs.join("\n");
+      expect(output).toContain("Not authenticated");
+    });
+    it("should output JSON when --json flag is used", async () => {
+      configStore.getApiKey.mockReturnValue("chk_test1234567890");
+      configStore.getAuthMethod.mockReturnValue("api-key");
+      configStore.getWorkspaceId.mockReturnValue("ws_abc123");
+      const { logs } = await runCli(["--json", "auth", "status"]);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.authenticated).toBe(true);
+    });
+  });
+  describe("logout", () => {
+    it("should logout successfully", async () => {
+      configStore.isAuthenticated.mockReturnValue(true);
+      const { logs, exitCode } = await runCli(["logout"]);
+      expect(exitCode).toBe(0);
+      expect(configStore.clearAuth).toHaveBeenCalled();
+      const output = logs.join("\n");
+      expect(output).toContain("Logged out");
+    });
+    it("should handle already logged out", async () => {
+      configStore.isAuthenticated.mockReturnValue(false);
+      const { logs } = await runCli(["logout"]);
+      const output = logs.join("\n");
+      expect(output).toContain("Already logged out");
+    });
+  });
+  describe("error handling", () => {
+    it("should show error when not authenticated for tools commands", async () => {
+      configStore.getApiKey.mockReturnValue(null);
+      const { exitCode, errors } = await runCli(["tools", "list"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Not authenticated"))).toBe(true);
+    });
+    it("should handle API errors gracefully", async () => {
+      mockSdk.tools.list.mockRejectedValue(new Error("Network error"));
+      const { exitCode, errors } = await runCli(["tools", "list"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Network error"))).toBe(true);
+    });
+    it("should handle unsuccessful API responses", async () => {
+      mockSdk.tools.list.mockResolvedValue({
+        success: false,
+        data: null,
+        message: "Unauthorized",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode, errors } = await runCli(["tools", "list"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Unauthorized") || e.includes("Failed"))).toBe(true);
+    });
+  });
+  describe("mcp info", () => {
+    it("should display MCP info with table output", async () => {
+      mockSdk.mcp.getConfig.mockResolvedValue({
+        success: true,
+        data: mockMcpConfig,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["mcp", "info"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.mcp.getConfig).toHaveBeenCalled();
+      const output = logs.join("\n");
+      expect(output).toContain("https://my-workspace.chanl.app/mcp");
+      expect(output).toContain("production");
+      expect(output).toContain("15");
+    });
+    it("should display MCP info with JSON output", async () => {
+      mockSdk.mcp.getConfig.mockResolvedValue({
+        success: true,
+        data: mockMcpConfig,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "mcp", "info"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.serverUrl).toBe("https://my-workspace.chanl.app/mcp");
+      expect(parsed.environment).toBe("production");
+      expect(parsed.toolCount).toBe(15);
+    });
+    it("should handle API errors", async () => {
+      mockSdk.mcp.getConfig.mockRejectedValue(new Error("Network error"));
+      const { exitCode, errors } = await runCli(["mcp", "info"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Network error"))).toBe(true);
+    });
+  });
+  describe("mcp status", () => {
+    it("should show healthy status", async () => {
+      mockSdk.mcp.getStatus.mockResolvedValue({
+        success: true,
+        data: mockMcpStatusHealthy,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["mcp", "status"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.mcp.getStatus).toHaveBeenCalled();
+      const output = logs.join("\n");
+      expect(output).toContain("healthy");
+      expect(output).toContain("MCP server is running");
+    });
+    it("should show unhealthy status with exit code 1", async () => {
+      mockSdk.mcp.getStatus.mockResolvedValue({
+        success: true,
+        data: mockMcpStatusUnhealthy,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { errors, exitCode } = await runCli(["mcp", "status"]);
+      expect(exitCode).toBe(1);
+      const output = errors.join("\n");
+      expect(output).toContain("unhealthy");
+    });
+    it("should output JSON when --json flag is used", async () => {
+      mockSdk.mcp.getStatus.mockResolvedValue({
+        success: true,
+        data: mockMcpStatusHealthy,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "mcp", "status"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.healthy).toBe(true);
+      expect(parsed.message).toBe("MCP server is running");
+    });
+  });
+  describe("mcp config", () => {
+    it("should output generic config by default", async () => {
+      mockSdk.mcp.getConfig.mockResolvedValue({
+        success: true,
+        data: mockMcpConfig,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "mcp", "config"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.url).toBe("https://my-workspace.chanl.app/mcp");
+      expect(parsed.transport).toBe("streamable-http");
+    });
+    it("should output claude config with --format claude", async () => {
+      mockSdk.mcp.getConfig.mockResolvedValue({
+        success: true,
+        data: mockMcpConfig,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "mcp", "config", "--format", "claude"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.mcpServers).toBeDefined();
+      expect(parsed.mcpServers.chanl.url).toBe("https://my-workspace.chanl.app/mcp");
+    });
+    it("should output cursor config with --format cursor", async () => {
+      mockSdk.mcp.getConfig.mockResolvedValue({
+        success: true,
+        data: mockMcpConfig,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "mcp", "config", "--format", "cursor"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.mcpServers).toBeDefined();
+      expect(parsed.mcpServers.chanl.url).toBe("https://my-workspace.chanl.app/mcp");
+    });
+    it("should handle API errors", async () => {
+      mockSdk.mcp.getConfig.mockRejectedValue(new Error("Network error"));
+      const { exitCode, errors } = await runCli(["mcp", "config"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Network error"))).toBe(true);
+    });
+  });
+  describe("mcp command registration", () => {
+    it("should have mcp command registered", () => {
+      const program = createProgram();
+      const commandNames = program.commands.map((c) => c.name());
+      expect(commandNames).toContain("mcp");
+    });
+  });
+  describe("mcp tools", () => {
+    const mockMcpTools = [
+      {
+        name: "get_weather",
+        description: "Get current weather for a location",
+        inputSchema: {
+          type: "object",
+          properties: {
+            city: { type: "string", description: "City name" }
+          },
+          required: ["city"]
+        }
+      },
+      {
+        name: "search_kb",
+        description: "Search the knowledge base",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query" }
+          },
+          required: ["query"]
+        }
+      }
+    ];
+    it("should list MCP tools for an agent with table output", async () => {
+      mockSdk.mcp.listTools.mockResolvedValue({
+        success: true,
+        data: { tools: mockMcpTools },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["mcp", "tools", "agent_123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.mcp.listTools).toHaveBeenCalledWith("agent_123");
+      const output = logs.join("\n");
+      expect(output).toContain("get_weather");
+      expect(output).toContain("search_kb");
+    });
+    it("should list MCP tools with JSON output", async () => {
+      mockSdk.mcp.listTools.mockResolvedValue({
+        success: true,
+        data: { tools: mockMcpTools },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "mcp", "tools", "agent_123"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.tools).toHaveLength(2);
+      expect(parsed.tools[0].name).toBe("get_weather");
+    });
+    it("should show message when agent has no tools", async () => {
+      mockSdk.mcp.listTools.mockResolvedValue({
+        success: true,
+        data: { tools: [] },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["mcp", "tools", "agent_123"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("No MCP tools");
+    });
+    it("should handle API errors", async () => {
+      mockSdk.mcp.listTools.mockRejectedValue(new Error("Agent not found"));
+      const { exitCode, errors } = await runCli(["mcp", "tools", "agent_123"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Agent not found"))).toBe(true);
+    });
+  });
+  describe("mcp call", () => {
+    it("should call a tool and display result", async () => {
+      mockSdk.mcp.callTool.mockResolvedValue({
+        success: true,
+        data: {
+          content: [{ type: "text", text: "Temperature in London: 15C" }],
+          isError: false
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "mcp",
+        "call",
+        "agent_123",
+        "get_weather",
+        '{"city":"London"}'
+      ]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.mcp.callTool).toHaveBeenCalledWith(
+        "agent_123",
+        "get_weather",
+        { city: "London" }
+      );
+      const output = logs.join("\n");
+      expect(output).toContain("Temperature in London: 15C");
+    });
+    it("should call a tool without arguments", async () => {
+      mockSdk.mcp.callTool.mockResolvedValue({
+        success: true,
+        data: {
+          content: [{ type: "text", text: "pong" }],
+          isError: false
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["mcp", "call", "agent_123", "ping"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.mcp.callTool).toHaveBeenCalledWith(
+        "agent_123",
+        "ping",
+        void 0
+      );
+      const output = logs.join("\n");
+      expect(output).toContain("pong");
+    });
+    it("should display error result from tool", async () => {
+      mockSdk.mcp.callTool.mockResolvedValue({
+        success: true,
+        data: {
+          content: [{ type: "text", text: "Error: city not found" }],
+          isError: true
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { errors, exitCode } = await runCli([
+        "mcp",
+        "call",
+        "agent_123",
+        "get_weather",
+        '{"city":"xyz"}'
+      ]);
+      expect(exitCode).toBe(1);
+      const output = errors.join("\n");
+      expect(output).toContain("Error");
+    });
+    it("should output JSON when --json flag is used", async () => {
+      mockSdk.mcp.callTool.mockResolvedValue({
+        success: true,
+        data: {
+          content: [{ type: "text", text: "result text" }],
+          isError: false
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "--json",
+        "mcp",
+        "call",
+        "agent_123",
+        "get_weather",
+        '{"city":"London"}'
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.content).toBeDefined();
+      expect(parsed.content[0].text).toBe("result text");
+    });
+    it("should handle invalid JSON arguments gracefully", async () => {
+      const { exitCode, errors } = await runCli([
+        "mcp",
+        "call",
+        "agent_123",
+        "get_weather",
+        "not-json"
+      ]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Invalid JSON"))).toBe(true);
+    });
+    it("should handle API errors", async () => {
+      mockSdk.mcp.callTool.mockRejectedValue(new Error("Tool not found"));
+      const { exitCode, errors } = await runCli([
+        "mcp",
+        "call",
+        "agent_123",
+        "nonexistent",
+        "{}"
+      ]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Tool not found"))).toBe(true);
+    });
+  });
+  describe("mcp inspect", () => {
+    const mockToolDetail = {
+      name: "get_weather",
+      description: "Get current weather for a location",
+      inputSchema: {
+        type: "object",
+        properties: {
+          city: { type: "string", description: "City name" },
+          units: { type: "string", enum: ["celsius", "fahrenheit"] }
+        },
+        required: ["city"]
+      }
+    };
+    it("should display tool details with table output", async () => {
+      mockSdk.mcp.getTool.mockResolvedValue({
+        success: true,
+        data: { tool: mockToolDetail },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["mcp", "inspect", "agent_123", "get_weather"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.mcp.getTool).toHaveBeenCalledWith("agent_123", "get_weather");
+      const output = logs.join("\n");
+      expect(output).toContain("get_weather");
+      expect(output).toContain("Get current weather");
+      expect(output).toContain("city");
+    });
+    it("should display tool details with JSON output", async () => {
+      mockSdk.mcp.getTool.mockResolvedValue({
+        success: true,
+        data: { tool: mockToolDetail },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "mcp", "inspect", "agent_123", "get_weather"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.name).toBe("get_weather");
+      expect(parsed.inputSchema).toBeDefined();
+    });
+    it("should handle tool not found", async () => {
+      mockSdk.mcp.getTool.mockRejectedValue(new Error("Tool not found"));
+      const { exitCode, errors } = await runCli(["mcp", "inspect", "agent_123", "nonexistent"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Tool not found"))).toBe(true);
+    });
+  });
+  describe("mcp install", () => {
+    it("should generate config snippet for default (generic) format", async () => {
+      const { logs, exitCode } = await runCli(["--json", "mcp", "install"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.mcpServers).toBeDefined();
+      expect(parsed.mcpServers.chanl).toBeDefined();
+      expect(parsed.mcpServers.chanl.transport).toBe("streamable-http");
+    });
+    it("should include API key from config", async () => {
+      const { logs, exitCode } = await runCli(["--json", "mcp", "install"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.mcpServers.chanl.headers["X-API-Key"]).toBe("test-api-key");
+    });
+    it("should generate config for claude format", async () => {
+      const { logs, exitCode } = await runCli(["--json", "mcp", "install", "--format", "claude"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.mcpServers).toBeDefined();
+      expect(parsed.mcpServers.chanl).toBeDefined();
+    });
+    it("should generate config for cursor format", async () => {
+      const { logs, exitCode } = await runCli(["--json", "mcp", "install", "--format", "cursor"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.mcpServers).toBeDefined();
+      expect(parsed.mcpServers.chanl).toBeDefined();
+    });
+    it("should generate config for vscode format", async () => {
+      const { logs, exitCode } = await runCli(["--json", "mcp", "install", "--format", "vscode"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.mcpServers).toBeDefined();
+      expect(parsed.mcpServers.chanl).toBeDefined();
+    });
+    it("should error when not authenticated", async () => {
+      configStore.getApiKey.mockReturnValue(null);
+      const { exitCode, errors } = await runCli(["mcp", "install"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Not authenticated") || e.includes("login"))).toBe(true);
+    });
+  });
+  describe("toolsets command registration", () => {
+    it("should have toolsets command registered", () => {
+      const program = createProgram();
+      const commandNames = program.commands.map((c) => c.name());
+      expect(commandNames).toContain("toolsets");
+    });
+  });
+  describe("toolsets list", () => {
+    it("should list toolsets with table output", async () => {
+      mockSdk.toolsets.list.mockResolvedValue({
+        success: true,
+        data: {
+          data: [mockToolset],
+          total: 1,
+          pagination: {
+            page: 1,
+            limit: 20,
+            totalPages: 1,
+            hasNext: false,
+            hasPrev: false
+          }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["toolsets", "list"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.toolsets.list).toHaveBeenCalledWith(expect.any(Object));
+      const output = logs.join("\n");
+      expect(output).toContain("customer_support_tools");
+      expect(output).toContain("1.0.0");
+      expect(output).toContain("Total: 1 toolsets");
+    });
+    it("should list toolsets with JSON output", async () => {
+      mockSdk.toolsets.list.mockResolvedValue({
+        success: true,
+        data: {
+          data: [mockToolset],
+          total: 1,
+          pagination: {
+            page: 1,
+            limit: 20,
+            totalPages: 1,
+            hasNext: false,
+            hasPrev: false
+          }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "toolsets", "list"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.toolsets).toHaveLength(1);
+      expect(parsed.toolsets[0].name).toBe("customer_support_tools");
+    });
+    it("should filter by enabled status", async () => {
+      mockSdk.toolsets.list.mockResolvedValue({
+        success: true,
+        data: {
+          data: [mockToolset],
+          total: 1,
+          pagination: { page: 1, limit: 20, totalPages: 1, hasNext: false, hasPrev: false }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await runCli(["toolsets", "list", "--enabled"]);
+      expect(mockSdk.toolsets.list).toHaveBeenCalledWith(
+        expect.objectContaining({ enabled: true })
+      );
+    });
+  });
+  describe("toolsets get", () => {
+    it("should get toolset by ID", async () => {
+      mockSdk.toolsets.get.mockResolvedValue({
+        success: true,
+        data: mockToolset,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["toolsets", "get", "toolset_abc123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.toolsets.get).toHaveBeenCalledWith("toolset_abc123");
+      const output = logs.join("\n");
+      expect(output).toContain("customer_support_tools");
+      expect(output).toContain("1.0.0");
+    });
+    it("should output JSON when --json flag is used", async () => {
+      mockSdk.toolsets.get.mockResolvedValue({
+        success: true,
+        data: mockToolset,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "toolsets", "get", "toolset_abc123"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.name).toBe("customer_support_tools");
+    });
+  });
+  describe("toolsets enable", () => {
+    it("should enable a toolset", async () => {
+      mockSdk.toolsets.enable.mockResolvedValue({
+        success: true,
+        data: { ...mockToolset, enabled: true },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["toolsets", "enable", "toolset_abc123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.toolsets.enable).toHaveBeenCalledWith("toolset_abc123");
+      const output = logs.join("\n");
+      expect(output).toContain("Enabled");
+      expect(output).toContain("customer_support_tools");
+    });
+  });
+  describe("toolsets disable", () => {
+    it("should disable a toolset", async () => {
+      mockSdk.toolsets.disable.mockResolvedValue({
+        success: true,
+        data: { ...mockToolset, enabled: false },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["toolsets", "disable", "toolset_abc123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.toolsets.disable).toHaveBeenCalledWith("toolset_abc123");
+      const output = logs.join("\n");
+      expect(output).toContain("Disabled");
+      expect(output).toContain("customer_support_tools");
+    });
+  });
+  describe("toolsets delete", () => {
+    it("should delete toolset with --yes flag", async () => {
+      mockSdk.toolsets.delete.mockResolvedValue({
+        success: true,
+        data: { deleted: true },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["toolsets", "delete", "toolset_abc123", "--yes"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.toolsets.delete).toHaveBeenCalledWith("toolset_abc123");
+      const output = logs.join("\n");
+      expect(output).toContain("Deleted");
+    });
+  });
+  describe("tools enable/disable", () => {
+    it("should enable a tool", async () => {
+      mockSdk.tools.enable.mockResolvedValue({
+        success: true,
+        data: { tool: { ...mockTool, isEnabled: true } },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["tools", "enable", "tool_weather123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.tools.enable).toHaveBeenCalledWith("tool_weather123");
+      const output = logs.join("\n");
+      expect(output).toContain("Enabled");
+      expect(output).toContain("get_weather");
+    });
+    it("should disable a tool", async () => {
+      mockSdk.tools.disable.mockResolvedValue({
+        success: true,
+        data: { tool: { ...mockTool, isEnabled: false } },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["tools", "disable", "tool_weather123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.tools.disable).toHaveBeenCalledWith("tool_weather123");
+      const output = logs.join("\n");
+      expect(output).toContain("Disabled");
+      expect(output).toContain("get_weather");
+    });
+  });
+  describe("chat command registration", () => {
+    it("should have chat command registered", () => {
+      const program = createProgram();
+      const commandNames = program.commands.map((c) => c.name());
+      expect(commandNames).toContain("chat");
+    });
+    it("should have the correct command name and description", () => {
+      const program = createProgram();
+      const chatCmd = program.commands.find((c) => c.name() === "chat");
+      expect(chatCmd).toBeDefined();
+      expect(chatCmd.description()).toContain("chat");
+    });
+  });
+  describe("chat single message", () => {
+    it("should send a single message and display response", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        message: "Hello! How can I help you?",
+        sessionId: "sess_123",
+        latencyMs: 120
+      });
+      const mockEnd = vi.fn().mockResolvedValue(void 0);
+      mockSdk.chat.session.mockResolvedValue({
+        sessionId: "sess_123",
+        agentName: "Test Agent",
+        send: mockSend,
+        end: mockEnd
+      });
+      const { logs, exitCode } = await runCli(["chat", "agent_abc", "--message", "Hello"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.chat.session).toHaveBeenCalledWith("agent_abc");
+      expect(mockSend).toHaveBeenCalledWith("Hello");
+      expect(mockEnd).toHaveBeenCalled();
+      const output = logs.join("\n");
+      expect(output).toContain("Hello");
+      expect(output).toContain("How can I help you?");
+    });
+    it("should output JSON when --json flag is used", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        message: "Hi there!",
+        sessionId: "sess_123",
+        latencyMs: 95
+      });
+      const mockEnd = vi.fn().mockResolvedValue(void 0);
+      mockSdk.chat.session.mockResolvedValue({
+        sessionId: "sess_123",
+        agentName: "Test Agent",
+        send: mockSend,
+        end: mockEnd
+      });
+      const { logs, exitCode } = await runCli(["--json", "chat", "agent_abc", "--message", "Hi"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.sessionId).toBe("sess_123");
+      expect(parsed.response).toBe("Hi there!");
+      expect(parsed.latencyMs).toBe(95);
+    });
+    it("should handle session creation failure", async () => {
+      mockSdk.chat.session.mockRejectedValue(new Error("Agent not found"));
+      const { exitCode, errors } = await runCli(["chat", "bad_agent", "--message", "Hello"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Agent not found") || e.includes("session"))).toBe(true);
+    });
+    it("should handle send message failure", async () => {
+      const mockSend = vi.fn().mockRejectedValue(new Error("No response from agent"));
+      const mockEnd = vi.fn().mockResolvedValue(void 0);
+      mockSdk.chat.session.mockResolvedValue({
+        sessionId: "sess_123",
+        agentName: "Test Agent",
+        send: mockSend,
+        end: mockEnd
+      });
+      const { exitCode, errors } = await runCli(["chat", "agent_abc", "--message", "Hello"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("No response") || e.includes("Failed"))).toBe(true);
+    });
+    it("should handle not authenticated", async () => {
+      configStore.getApiKey.mockReturnValue(null);
+      const { exitCode, errors } = await runCli(["chat", "agent_abc", "--message", "Hello"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Not authenticated"))).toBe(true);
+    });
+  });
+  describe("tools categories", () => {
+    it("should show tool categories", async () => {
+      mockSdk.tools.getCategories.mockResolvedValue({
+        success: true,
+        data: {
+          categories: [
+            { tag: "weather", count: 5, enabled: 4 },
+            { tag: "utility", count: 10, enabled: 8 }
+          ],
+          uncategorized: { count: 3, enabled: 2 }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["tools", "categories"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.tools.getCategories).toHaveBeenCalled();
+      const output = logs.join("\n");
+      expect(output).toContain("weather");
+      expect(output).toContain("utility");
+      expect(output).toContain("uncategorized");
+    });
+    it("should output JSON when --json flag is used", async () => {
+      mockSdk.tools.getCategories.mockResolvedValue({
+        success: true,
+        data: {
+          categories: [{ tag: "weather", count: 5, enabled: 4 }],
+          uncategorized: { count: 3, enabled: 2 }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "tools", "categories"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.categories).toHaveLength(1);
+      expect(parsed.categories[0].tag).toBe("weather");
+      expect(parsed.uncategorized.count).toBe(3);
+    });
+  });
+  describe("chat single message with tool calls", () => {
+    const mockToolCalls = [
+      {
+        id: "tc-001",
+        name: "get_weather",
+        parameters: { city: "London" },
+        result: { temperature: "12\xB0C" },
+        status: "success",
+        durationMs: 245,
+        startedAt: "2025-01-09T10:30:00.000Z",
+        completedAt: "2025-01-09T10:30:00.245Z"
+      },
+      {
+        id: "tc-002",
+        name: "send_email",
+        parameters: { to: "user@test.com" },
+        status: "error",
+        durationMs: 1200,
+        startedAt: "2025-01-09T10:30:01.000Z",
+        error: { message: "SMTP connection failed", code: "NETWORK_ERROR" }
+      }
+    ];
+    it("should display tool calls in chat response", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        message: "The weather in London is 12\xB0C.",
+        sessionId: "sess_tc1",
+        latencyMs: 350,
+        toolCalls: mockToolCalls
+      });
+      const mockEnd = vi.fn().mockResolvedValue(void 0);
+      mockSdk.chat.session.mockResolvedValue({
+        sessionId: "sess_tc1",
+        agentName: "Test Agent",
+        send: mockSend,
+        end: mockEnd
+      });
+      const { logs, exitCode } = await runCli(["chat", "agent_abc", "--message", "What is the weather in London?"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("get_weather");
+      expect(output).toContain("245ms");
+      expect(output).toContain("send_email");
+      expect(output).toContain("SMTP connection failed");
+      expect(output).toContain("The weather in London is 12\xB0C.");
+    });
+  });
+  describe("chat single message with tool calls JSON output", () => {
+    const mockToolCalls = [
+      {
+        id: "tc-001",
+        name: "get_weather",
+        parameters: { city: "London" },
+        result: { temperature: "12\xB0C" },
+        status: "success",
+        durationMs: 245,
+        startedAt: "2025-01-09T10:30:00.000Z",
+        completedAt: "2025-01-09T10:30:00.245Z"
+      },
+      {
+        id: "tc-002",
+        name: "send_email",
+        parameters: { to: "user@test.com" },
+        status: "error",
+        durationMs: 1200,
+        startedAt: "2025-01-09T10:30:01.000Z",
+        error: { message: "SMTP connection failed", code: "NETWORK_ERROR" }
+      }
+    ];
+    it("should include toolCalls in JSON output", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        message: "The weather in London is 12\xB0C.",
+        sessionId: "sess_tc2",
+        latencyMs: 350,
+        toolCalls: mockToolCalls
+      });
+      const mockEnd = vi.fn().mockResolvedValue(void 0);
+      mockSdk.chat.session.mockResolvedValue({
+        sessionId: "sess_tc2",
+        agentName: "Test Agent",
+        send: mockSend,
+        end: mockEnd
+      });
+      const { logs, exitCode } = await runCli(["--json", "chat", "agent_abc", "--message", "What is the weather?"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.toolCalls).toBeDefined();
+      expect(parsed.toolCalls).toHaveLength(2);
+      expect(parsed.toolCalls[0].name).toBe("get_weather");
+      expect(parsed.toolCalls[0].status).toBe("success");
+      expect(parsed.toolCalls[1].name).toBe("send_email");
+      expect(parsed.toolCalls[1].status).toBe("error");
+    });
+  });
+  describe("calls transcript with tool calls", () => {
+    const mockToolCalls = [
+      {
+        id: "tc-001",
+        name: "get_weather",
+        parameters: { city: "London" },
+        result: { temperature: "12\xB0C" },
+        status: "success",
+        durationMs: 245,
+        startedAt: "2025-01-09T10:30:00.000Z",
+        completedAt: "2025-01-09T10:30:00.245Z"
+      },
+      {
+        id: "tc-002",
+        name: "send_email",
+        parameters: { to: "user@test.com" },
+        status: "error",
+        durationMs: 1200,
+        startedAt: "2025-01-09T10:30:01.000Z",
+        error: { message: "SMTP connection failed", code: "NETWORK_ERROR" }
+      }
+    ];
+    it("should display tool calls in transcript output", async () => {
+      mockSdk.calls.getTranscript.mockResolvedValue({
+        success: true,
+        data: {
+          text: "Agent: Hello! Customer: What is the weather?",
+          wordCount: 8,
+          speakerCount: 2,
+          language: "en",
+          confidence: 0.95,
+          segments: [
+            { speaker: "speaker_0", text: "Hello!", start: 0, end: 1.5 },
+            { speaker: "speaker_1", text: "What is the weather?", start: 2, end: 4 }
+          ],
+          toolCalls: mockToolCalls
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["calls", "transcript", "call_abc123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.calls.getTranscript).toHaveBeenCalledWith("call_abc123");
+      const output = logs.join("\n");
+      expect(output).toContain("Tool Calls");
+      expect(output).toContain("get_weather");
+      expect(output).toContain("send_email");
+      expect(output).toContain("245ms");
+      expect(output).toContain("SMTP connection failed");
+    });
+    it("should include tool calls in JSON transcript output", async () => {
+      mockSdk.calls.getTranscript.mockResolvedValue({
+        success: true,
+        data: {
+          text: "Agent: Hello!",
+          wordCount: 2,
+          toolCalls: mockToolCalls
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "calls", "transcript", "call_abc123"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.toolCalls).toBeDefined();
+      expect(parsed.toolCalls).toHaveLength(2);
+      expect(parsed.toolCalls[0].name).toBe("get_weather");
+      expect(parsed.toolCalls[1].name).toBe("send_email");
+    });
+  });
+  describe("scenarios execution with tool calls", () => {
+    const mockToolCalls = [
+      {
+        id: "tc-001",
+        name: "get_weather",
+        parameters: { city: "London" },
+        result: { temperature: "12\xB0C" },
+        status: "success",
+        durationMs: 245,
+        startedAt: "2025-01-09T10:30:00.000Z",
+        completedAt: "2025-01-09T10:30:00.245Z"
+      },
+      {
+        id: "tc-002",
+        name: "send_email",
+        parameters: { to: "user@test.com" },
+        status: "error",
+        durationMs: 1200,
+        startedAt: "2025-01-09T10:30:01.000Z",
+        error: { message: "SMTP connection failed", code: "NETWORK_ERROR" }
+      }
+    ];
+    it("should display tool calls in execution details", async () => {
+      mockSdk.scenarios.getExecution.mockResolvedValue({
+        success: true,
+        data: {
+          execution: {
+            id: "exec_tc1",
+            executionId: "exec_tc1",
+            scenarioId: "scen_abc123",
+            status: "completed",
+            overallScore: 85,
+            duration: 12.5,
+            stepResults: [
+              {
+                stepId: "step_1",
+                status: "completed",
+                actualResponse: "The weather is 12\xB0C in London.",
+                toolCalls: mockToolCalls
+              }
+            ]
+          }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["scenarios", "execution", "exec_tc1"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.scenarios.getExecution).toHaveBeenCalledWith("exec_tc1");
+      const output = logs.join("\n");
+      expect(output).toContain("Tool Calls");
+      expect(output).toContain("get_weather");
+      expect(output).toContain("send_email");
+      expect(output).toContain("245ms");
+      expect(output).toContain("SMTP connection failed");
+    });
+    it("should include tool calls in JSON execution output", async () => {
+      mockSdk.scenarios.getExecution.mockResolvedValue({
+        success: true,
+        data: {
+          execution: {
+            id: "exec_tc2",
+            executionId: "exec_tc2",
+            scenarioId: "scen_abc123",
+            status: "completed",
+            overallScore: 85,
+            duration: 12.5,
+            stepResults: [
+              {
+                stepId: "step_1",
+                status: "completed",
+                actualResponse: "The weather is 12\xB0C in London.",
+                toolCalls: mockToolCalls
+              }
+            ]
+          }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "scenarios", "execution", "exec_tc2"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.execution).toBeDefined();
+      expect(parsed.execution.stepResults[0].toolCalls).toHaveLength(2);
+      expect(parsed.execution.stepResults[0].toolCalls[0].name).toBe("get_weather");
+      expect(parsed.execution.stepResults[0].toolCalls[1].name).toBe("send_email");
+    });
+  });
+  describe("agents import", () => {
+    const mockImportedAgent = {
+      id: "agent_imported_123",
+      name: "My VAPI Agent",
+      description: "Imported from VAPI",
+      platform: "vapi",
+      platformAgentId: "asst_abc",
+      status: "active",
+      deployments: [
+        {
+          orchestrator: "vapi",
+          externalId: "asst_abc",
+          status: "synced"
+        }
+      ],
+      createdAt: "2026-03-09T10:00:00.000Z",
+      updatedAt: "2026-03-09T10:00:00.000Z"
+    };
+    it("should import an agent from VAPI and display results", async () => {
+      mockSdk.agents.importFromPlatform.mockResolvedValue({
+        success: true,
+        data: { agent: mockImportedAgent },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "agents",
+        "import",
+        "--from",
+        "vapi",
+        "--agent-id",
+        "asst_abc"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("My VAPI Agent");
+      expect(output).toContain("agent_imported_123");
+      expect(output).toContain("vapi");
+      expect(mockSdk.agents.importFromPlatform).toHaveBeenCalledWith(
+        expect.objectContaining({
+          platform: "vapi",
+          externalAgentId: "asst_abc"
+        })
+      );
+    });
+    it("should display external ID and deployment info", async () => {
+      mockSdk.agents.importFromPlatform.mockResolvedValue({
+        success: true,
+        data: { agent: mockImportedAgent },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "agents",
+        "import",
+        "--from",
+        "vapi",
+        "--agent-id",
+        "asst_abc"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("asst_abc");
+    });
+    it("should output JSON with --json flag", async () => {
+      mockSdk.agents.importFromPlatform.mockResolvedValue({
+        success: true,
+        data: { agent: mockImportedAgent },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "--json",
+        "agents",
+        "import",
+        "--from",
+        "vapi",
+        "--agent-id",
+        "asst_abc"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.agent).toBeDefined();
+      expect(parsed.agent.id).toBe("agent_imported_123");
+      expect(parsed.agent.name).toBe("My VAPI Agent");
+      expect(parsed.agent.platform).toBe("vapi");
+      expect(parsed.agent.platformAgentId).toBe("asst_abc");
+      expect(parsed.agent.deployments).toHaveLength(1);
+      expect(parsed.agent.deployments[0].orchestrator).toBe("vapi");
+    });
+    it("should import from Retell platform", async () => {
+      const retellAgent = {
+        ...mockImportedAgent,
+        id: "agent_imported_456",
+        name: "My Retell Agent",
+        platform: "retell",
+        platformAgentId: "ret_xyz",
+        deployments: [
+          { orchestrator: "retell", externalId: "ret_xyz", status: "synced" }
+        ]
+      };
+      mockSdk.agents.importFromPlatform.mockResolvedValue({
+        success: true,
+        data: { agent: retellAgent },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "agents",
+        "import",
+        "--from",
+        "retell",
+        "--agent-id",
+        "ret_xyz"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("My Retell Agent");
+      expect(output).toContain("retell");
+      expect(mockSdk.agents.importFromPlatform).toHaveBeenCalledWith(
+        expect.objectContaining({
+          platform: "retell",
+          externalAgentId: "ret_xyz"
+        })
+      );
+    });
+    it("should handle import failure with error message", async () => {
+      mockSdk.agents.importFromPlatform.mockResolvedValue({
+        success: false,
+        data: null,
+        message: "Agent 'asst_nonexistent' not found on platform 'vapi'",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { errors, exitCode } = await runCli([
+        "agents",
+        "import",
+        "--from",
+        "vapi",
+        "--agent-id",
+        "asst_nonexistent"
+      ]);
+      expect(exitCode).toBe(1);
+      const errorOutput = errors.join("\n");
+      expect(errorOutput).toContain("not found");
+    });
+    it("should accept optional --name flag for name override", async () => {
+      mockSdk.agents.importFromPlatform.mockResolvedValue({
+        success: true,
+        data: {
+          agent: { ...mockImportedAgent, name: "Custom Agent Name" }
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "agents",
+        "import",
+        "--from",
+        "vapi",
+        "--agent-id",
+        "asst_abc",
+        "--name",
+        "Custom Agent Name"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("Custom Agent Name");
+      expect(mockSdk.agents.importFromPlatform).toHaveBeenCalledWith(
+        expect.objectContaining({
+          platform: "vapi",
+          externalAgentId: "asst_abc",
+          name: "Custom Agent Name"
+        })
+      );
+    });
+  });
+  describe("agents publish", () => {
+    const mockPublishResult = {
+      externalId: "ext_vapi_789",
+      platform: "vapi",
+      status: "active",
+      mcpUrl: "https://my-workspace.chanl.dev/mcp",
+      action: "created"
+    };
+    it("should publish an agent and display results", async () => {
+      mockSdk.agents.publish.mockResolvedValue({
+        success: true,
+        data: mockPublishResult,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "agents",
+        "publish",
+        "agent_123",
+        "--to",
+        "vapi"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("created");
+      expect(output).toContain("vapi");
+      expect(output).toContain("ext_vapi_789");
+      expect(mockSdk.agents.publish).toHaveBeenCalledWith(
+        "agent_123",
+        expect.objectContaining({
+          platform: "vapi"
+        })
+      );
+    });
+    it("should show MCP URL when included in result", async () => {
+      mockSdk.agents.publish.mockResolvedValue({
+        success: true,
+        data: mockPublishResult,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "agents",
+        "publish",
+        "agent_123",
+        "--to",
+        "vapi",
+        "--with-mcp"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("https://my-workspace.chanl.dev/mcp");
+      expect(mockSdk.agents.publish).toHaveBeenCalledWith(
+        "agent_123",
+        expect.objectContaining({
+          platform: "vapi",
+          includeMcp: true
+        })
+      );
+    });
+    it("should pass --target option as targetExternalId", async () => {
+      mockSdk.agents.publish.mockResolvedValue({
+        success: true,
+        data: { ...mockPublishResult, action: "updated" },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "agents",
+        "publish",
+        "agent_123",
+        "--to",
+        "vapi",
+        "--target",
+        "existing_ext_456"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("updated");
+      expect(mockSdk.agents.publish).toHaveBeenCalledWith(
+        "agent_123",
+        expect.objectContaining({
+          platform: "vapi",
+          targetExternalId: "existing_ext_456"
+        })
+      );
+    });
+    it("should output JSON with --json flag", async () => {
+      mockSdk.agents.publish.mockResolvedValue({
+        success: true,
+        data: mockPublishResult,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "--json",
+        "agents",
+        "publish",
+        "agent_123",
+        "--to",
+        "vapi"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.externalId).toBe("ext_vapi_789");
+      expect(parsed.platform).toBe("vapi");
+      expect(parsed.action).toBe("created");
+      expect(parsed.mcpUrl).toBe("https://my-workspace.chanl.dev/mcp");
+    });
+    it("should handle publish failure with error message", async () => {
+      mockSdk.agents.publish.mockResolvedValue({
+        success: false,
+        data: null,
+        message: "Agent 'agent_123' not found",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { errors, exitCode } = await runCli([
+        "agents",
+        "publish",
+        "agent_123",
+        "--to",
+        "vapi"
+      ]);
+      expect(exitCode).toBe(1);
+      const errorOutput = errors.join("\n");
+      expect(errorOutput).toContain("not found");
+    });
+  });
+  describe("agents push-mcp", () => {
+    const mockPushMcpResult = {
+      mcpUrl: "https://my-workspace.chanl.dev/mcp",
+      platform: "vapi",
+      externalId: "ext_vapi_789",
+      status: "configured"
+    };
+    it("should push MCP URL and display results", async () => {
+      mockSdk.agents.pushMcp.mockResolvedValue({
+        success: true,
+        data: mockPushMcpResult,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "agents",
+        "push-mcp",
+        "agent_123",
+        "--to",
+        "vapi"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("https://my-workspace.chanl.dev/mcp");
+      expect(output).toContain("vapi");
+      expect(output).toContain("ext_vapi_789");
+      expect(mockSdk.agents.pushMcp).toHaveBeenCalledWith(
+        "agent_123",
+        expect.objectContaining({
+          platform: "vapi"
+        })
+      );
+    });
+    it("should pass --target option as targetExternalId", async () => {
+      mockSdk.agents.pushMcp.mockResolvedValue({
+        success: true,
+        data: mockPushMcpResult,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode } = await runCli([
+        "agents",
+        "push-mcp",
+        "agent_123",
+        "--to",
+        "vapi",
+        "--target",
+        "existing_ext_456"
+      ]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.agents.pushMcp).toHaveBeenCalledWith(
+        "agent_123",
+        expect.objectContaining({
+          platform: "vapi",
+          targetExternalId: "existing_ext_456"
+        })
+      );
+    });
+    it("should output JSON with --json flag", async () => {
+      mockSdk.agents.pushMcp.mockResolvedValue({
+        success: true,
+        data: mockPushMcpResult,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli([
+        "--json",
+        "agents",
+        "push-mcp",
+        "agent_123",
+        "--to",
+        "vapi"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.mcpUrl).toBe("https://my-workspace.chanl.dev/mcp");
+      expect(parsed.platform).toBe("vapi");
+      expect(parsed.externalId).toBe("ext_vapi_789");
+      expect(parsed.status).toBe("configured");
+    });
+    it("should handle push-mcp failure with error message", async () => {
+      mockSdk.agents.pushMcp.mockResolvedValue({
+        success: false,
+        data: null,
+        message: "Agent 'agent_123' not found",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { errors, exitCode } = await runCli([
+        "agents",
+        "push-mcp",
+        "agent_123",
+        "--to",
+        "vapi"
+      ]);
+      expect(exitCode).toBe(1);
+      const errorOutput = errors.join("\n");
+      expect(errorOutput).toContain("not found");
+    });
+  });
+  describe("scenarios run-all", () => {
+    const mockBatchResult = {
+      agentId: "agent_abc",
+      totalScenarios: 3,
+      passed: 3,
+      failed: 0,
+      averageScore: 90,
+      allPassed: true,
+      minScore: 80,
+      results: [
+        {
+          scenarioId: "scen_001",
+          scenarioName: "Greeting Flow",
+          executionId: "exec_001",
+          status: "completed",
+          score: 90,
+          duration: 15.5,
+          toolCallCount: 2,
+          passed: true
+        },
+        {
+          scenarioId: "scen_002",
+          scenarioName: "Refund Flow",
+          executionId: "exec_002",
+          status: "completed",
+          score: 85,
+          duration: 22.3,
+          toolCallCount: 3,
+          passed: true
+        },
+        {
+          scenarioId: "scen_003",
+          scenarioName: "Escalation Flow",
+          executionId: "exec_003",
+          status: "completed",
+          score: 95,
+          duration: 10.1,
+          toolCallCount: 1,
+          passed: true
+        }
+      ]
+    };
+    it("should display results when all scenarios pass", async () => {
+      mockSdk.scenarios.runAll.mockResolvedValue(mockBatchResult);
+      const { logs, exitCode } = await runCli([
+        "scenarios",
+        "run-all",
+        "--agent",
+        "agent_abc",
+        "--min-score",
+        "80"
+      ]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.scenarios.runAll).toHaveBeenCalledWith(
+        expect.objectContaining({
+          agentId: "agent_abc",
+          minScore: 80
+        })
+      );
+      const output = logs.join("\n");
+      expect(output).toContain("Greeting Flow");
+      expect(output).toContain("Refund Flow");
+      expect(output).toContain("Escalation Flow");
+      expect(output).toMatch(/3.*passed/i);
+    });
+    it("should exit code 1 when any scenario fails", async () => {
+      const failedResult = {
+        ...mockBatchResult,
+        allPassed: false,
+        passed: 2,
+        failed: 1,
+        averageScore: 78,
+        results: [
+          { ...mockBatchResult.results[0] },
+          { ...mockBatchResult.results[1], score: 60, passed: false },
+          { ...mockBatchResult.results[2] }
+        ]
+      };
+      mockSdk.scenarios.runAll.mockResolvedValue(failedResult);
+      const { exitCode } = await runCli([
+        "scenarios",
+        "run-all",
+        "--agent",
+        "agent_abc",
+        "--min-score",
+        "80"
+      ]);
+      expect(exitCode).toBe(1);
+    });
+    it("should output JSON with --json flag", async () => {
+      mockSdk.scenarios.runAll.mockResolvedValue(mockBatchResult);
+      const { logs, exitCode } = await runCli([
+        "--json",
+        "scenarios",
+        "run-all",
+        "--agent",
+        "agent_abc"
+      ]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.allPassed).toBe(true);
+      expect(parsed.totalScenarios).toBe(3);
+      expect(parsed.results).toHaveLength(3);
+    });
+    it("should pass parallel option to SDK", async () => {
+      mockSdk.scenarios.runAll.mockResolvedValue(mockBatchResult);
+      await runCli([
+        "scenarios",
+        "run-all",
+        "--agent",
+        "agent_abc",
+        "--parallel",
+        "5"
+      ]);
+      expect(mockSdk.scenarios.runAll).toHaveBeenCalledWith(
+        expect.objectContaining({
+          agentId: "agent_abc",
+          parallel: 5
+        })
+      );
+    });
+    it("should display summary with average score", async () => {
+      mockSdk.scenarios.runAll.mockResolvedValue(mockBatchResult);
+      const { logs } = await runCli([
+        "scenarios",
+        "run-all",
+        "--agent",
+        "agent_abc"
+      ]);
+      const output = logs.join("\n");
+      expect(output).toContain("90");
+    });
+    it("should not call SDK when --agent option is missing", async () => {
+      await runCli(["scenarios", "run-all"]);
+      expect(mockSdk.scenarios.runAll).not.toHaveBeenCalled();
+    });
+  });
+  describe("prompts list", () => {
+    it("should list prompts with table output", async () => {
+      mockSdk.prompts.list.mockResolvedValue({
+        success: true,
+        data: [
+          {
+            id: "prompt_abc123",
+            name: "Support Greeting",
+            category: "support",
+            status: "active",
+            version: 3,
+            createdAt: "2025-01-01T00:00:00Z",
+            updatedAt: "2025-01-15T10:30:00Z"
+          },
+          {
+            id: "prompt_def456",
+            name: "Sales Pitch",
+            category: "sales",
+            status: "draft",
+            version: 1,
+            createdAt: "2025-02-01T00:00:00Z",
+            updatedAt: "2025-02-05T10:30:00Z"
+          }
+        ],
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["prompts", "list"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.prompts.list).toHaveBeenCalled();
+      const output = logs.join("\n");
+      expect(output).toContain("Support Greeting");
+      expect(output).toContain("Sales Pitch");
+    });
+    it("should list prompts with JSON output", async () => {
+      const mockPrompts = [
+        {
+          id: "prompt_abc123",
+          name: "Support Greeting",
+          category: "support",
+          status: "active"
+        }
+      ];
+      mockSdk.prompts.list.mockResolvedValue({
+        success: true,
+        data: mockPrompts,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "prompts", "list"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].name).toBe("Support Greeting");
+    });
+    it("should show message when no prompts found", async () => {
+      mockSdk.prompts.list.mockResolvedValue({
+        success: true,
+        data: [],
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["prompts", "list"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      expect(output).toContain("No prompts found");
+    });
+  });
+  describe("prompts get", () => {
+    it("should get prompt details by ID", async () => {
+      mockSdk.prompts.get.mockResolvedValue({
+        success: true,
+        data: {
+          id: "prompt_abc123",
+          name: "Support Greeting",
+          content: "Hello! How can I help you today?",
+          category: "support",
+          status: "active",
+          version: 3,
+          tags: ["greeting", "support"],
+          createdAt: "2025-01-01T00:00:00Z",
+          updatedAt: "2025-01-15T10:30:00Z"
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["prompts", "get", "prompt_abc123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.prompts.get).toHaveBeenCalledWith("prompt_abc123");
+      const output = logs.join("\n");
+      expect(output).toContain("Support Greeting");
+      expect(output).toContain("prompt_abc123");
+    });
+    it("should output JSON when --json flag is used", async () => {
+      mockSdk.prompts.get.mockResolvedValue({
+        success: true,
+        data: {
+          id: "prompt_abc123",
+          name: "Support Greeting",
+          content: "Hello! How can I help you today?",
+          category: "support",
+          status: "active"
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "prompts", "get", "prompt_abc123"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed.name).toBe("Support Greeting");
+      expect(parsed.content).toBe("Hello! How can I help you today?");
+    });
+    it("should handle not found error", async () => {
+      mockSdk.prompts.get.mockResolvedValue({
+        success: false,
+        data: null,
+        message: "Prompt not found",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode, errors } = await runCli(["prompts", "get", "nonexistent"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("Failed") || e.includes("not found"))).toBe(true);
+    });
+  });
+  describe("prompts delete", () => {
+    it("should delete a prompt", async () => {
+      mockSdk.prompts.delete.mockResolvedValue({
+        success: true,
+        data: null,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["prompts", "delete", "prompt_abc123", "--yes"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.prompts.delete).toHaveBeenCalledWith("prompt_abc123");
+      const output = logs.join("\n");
+      expect(output).toContain("deleted");
+    });
+  });
+  describe("workspaces list", () => {
+    it("should list workspaces with table output", async () => {
+      mockSdk.workspace.getAll.mockResolvedValue({
+        success: true,
+        data: [
+          {
+            id: "ws_abc123",
+            name: "My Workspace",
+            description: "Main workspace",
+            createdAt: "2025-01-01T00:00:00Z",
+            updatedAt: "2025-01-15T10:30:00Z"
+          },
+          {
+            id: "ws_def456",
+            name: "Test Workspace",
+            description: "Testing environment",
+            createdAt: "2025-02-01T00:00:00Z",
+            updatedAt: "2025-02-05T10:30:00Z"
+          }
+        ],
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["workspaces", "list"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.workspace.getAll).toHaveBeenCalled();
+      const output = logs.join("\n");
+      expect(output).toContain("My Workspace");
+      expect(output).toContain("Test Workspace");
+    });
+    it("should list workspaces with JSON output", async () => {
+      const mockWorkspaces = [
+        {
+          id: "ws_abc123",
+          name: "My Workspace",
+          description: "Main workspace",
+          createdAt: "2025-01-01T00:00:00Z",
+          updatedAt: "2025-01-15T10:30:00Z"
+        }
+      ];
+      mockSdk.workspace.getAll.mockResolvedValue({
+        success: true,
+        data: mockWorkspaces,
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["--json", "workspaces", "list"]);
+      expect(exitCode).toBe(0);
+      const output = logs.join("\n");
+      const parsed = JSON.parse(output);
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].name).toBe("My Workspace");
+    });
+  });
+  describe("workspaces get", () => {
+    it("should get workspace details by ID", async () => {
+      mockSdk.workspace.getById.mockResolvedValue({
+        success: true,
+        data: {
+          id: "ws_abc123",
+          name: "My Workspace",
+          description: "Main workspace",
+          settings: { timezone: "UTC" },
+          createdAt: "2025-01-01T00:00:00Z",
+          updatedAt: "2025-01-15T10:30:00Z"
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["workspaces", "get", "ws_abc123"]);
+      expect(exitCode).toBe(0);
+      expect(mockSdk.workspace.getById).toHaveBeenCalledWith("ws_abc123");
+      const output = logs.join("\n");
+      expect(output).toContain("My Workspace");
+      expect(output).toContain("ws_abc123");
+    });
+  });
+  describe("workspaces use", () => {
+    it("should set active workspace", async () => {
+      mockSdk.workspace.getById.mockResolvedValue({
+        success: true,
+        data: {
+          id: "ws_abc123",
+          name: "My Workspace",
+          description: "Main workspace",
+          settings: {},
+          createdAt: "2025-01-01T00:00:00Z",
+          updatedAt: "2025-01-15T10:30:00Z"
+        },
+        message: "Success",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { logs, exitCode } = await runCli(["workspaces", "use", "ws_abc123"]);
+      expect(exitCode).toBe(0);
+      expect(configStore.setWorkspaceId).toHaveBeenCalledWith("ws_abc123");
+      const output = logs.join("\n");
+      expect(output).toContain("ws_abc123");
+    });
+    it("should handle invalid workspace ID", async () => {
+      mockSdk.workspace.getById.mockResolvedValue({
+        success: false,
+        data: null,
+        message: "Workspace not found",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const { exitCode, errors } = await runCli(["workspaces", "use", "ws_invalid"]);
+      expect(exitCode).toBe(1);
+      expect(errors.some((e) => e.includes("not found") || e.includes("Failed"))).toBe(true);
+      expect(configStore.setWorkspaceId).not.toHaveBeenCalled();
+    });
+  });
+});
+//# sourceMappingURL=cli.test.js.map