@protoboxai/cli 1.0.0

package/README.md

@@ -0,0 +1,78 @@
+# @chanl/cli
+
+Command-line interface for the [Chanl AI](https://chanl.ai) platform.
+
+## Install
+
+```bash
+npm install -g @chanl/cli
+```
+
+Or run directly:
+
+```bash
+npx @chanl/cli
+```
+
+## Quick Start
+
+```bash
+# Authenticate
+chanl login
+
+# Check health
+chanl health
+
+# List agents
+chanl agents list
+
+# Chat with an agent
+chanl chat <agent-id>
+
+# Run test scenarios
+chanl scenarios list
+chanl scenarios run <id>
+
+# Manage tools
+chanl tools list
+chanl toolsets list
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `chanl login` | Authenticate with API key or browser |
+| `chanl health` | Check API health |
+| `chanl agents` | Manage AI agents |
+| `chanl tools` | Manage MCP tools |
+| `chanl toolsets` | Manage tool collections |
+| `chanl scenarios` | Run test scenarios |
+| `chanl calls` | Import and analyze calls |
+| `chanl call <phone>` | Make an outbound AI call |
+| `chanl chat <agent>` | Interactive chat session |
+| `chanl kb` | Manage knowledge base |
+| `chanl memory` | Manage agent memory |
+| `chanl scorecards` | Manage evaluation scorecards |
+| `chanl prompts` | Manage prompt templates |
+| `chanl config` | CLI configuration |
+| `chanl mcp` | MCP server status |
+
+## Configuration
+
+```bash
+chanl config show                    # Show current config
+chanl config set baseUrl <url>       # Custom API endpoint
+chanl config reset                   # Reset to production
+```
+
+Default API: `https://platform.chanl.ai`
+
+## Documentation
+
+- [Chanl Platform](https://chanl.ai)
+- [GitHub](https://github.com/chanl-ai/chanl-sdk)
+
+## License
+
+MIT

package/bin/protobox.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// Entry point for the Protobox CLI (local dev via workspace link)
+
+import('../dist/index.js').catch((err) => {
+  console.error('Failed to load CLI:', err.message);
+  process.exit(1);
+});

package/dist/cli.js

@@ -0,0 +1,60 @@
+import { Command } from "commander";
+import { createRequire } from "module";
+import { setOutputOptions } from "./utils/output.js";
+import {
+  createAuthCommand,
+  createLoginCommand,
+  createLogoutCommand,
+  createConfigCommand,
+  createToolsCommand,
+  createToolsetsCommand,
+  createHealthCommand,
+  createMcpCommand,
+  createKnowledgeCommand,
+  createChatCommand,
+  createPromptsCommand,
+  createWorkspacesCommand
+} from "./commands/index.js";
+const require2 = createRequire(import.meta.url);
+const { version: CLI_VERSION } = require2("../package.json");
+function createProgram() {
+  const program = new Command();
+  program.name("protobox").description("Command-line interface for Protobox \u2014 MCP servers, tools, and resources").version(CLI_VERSION, "-v, --version", "Show CLI version").option("--json", "Output results as JSON").option("--no-color", "Disable colored output").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    setOutputOptions({
+      json: opts["json"] === true,
+      noColor: opts["color"] === false
+    });
+  });
+  program.addCommand(createLoginCommand());
+  program.addCommand(createLogoutCommand());
+  program.addCommand(createAuthCommand());
+  program.addCommand(createConfigCommand());
+  program.addCommand(createToolsCommand());
+  program.addCommand(createToolsetsCommand());
+  program.addCommand(createHealthCommand());
+  program.addCommand(createMcpCommand());
+  program.addCommand(createKnowledgeCommand());
+  program.addCommand(createChatCommand());
+  program.addCommand(createPromptsCommand());
+  program.addCommand(createWorkspacesCommand());
+  program.showHelpAfterError(true);
+  program.showSuggestionAfterError(true);
+  return program;
+}
+async function run(argv = process.argv) {
+  const program = createProgram();
+  try {
+    await program.parseAsync(argv);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("Error:", error.message);
+    }
+    process.exitCode = 1;
+  }
+}
+export {
+  createProgram,
+  run
+};
+//# sourceMappingURL=cli.js.map

package/dist/commands/auth.js

@@ -0,0 +1,294 @@
+import { Command } from "commander";
+import { select } from "@inquirer/prompts";
+import ora from "ora";
+import chalk from "chalk";
+import http from "node:http";
+import { ChanlSDK } from "@protoboxai/sdk";
+import { configStore } from "../utils/config-store.js";
+import {
+  printSuccess,
+  printError,
+  printInfo,
+  printLabel,
+  printBlank,
+  isJsonOutput,
+  printJson,
+  maskString
+} from "../utils/output.js";
+function createAuthCommand() {
+  const auth = new Command("auth").description("Authentication commands");
+  auth.command("status").description("Show current authentication status").action(handleAuthStatus);
+  return auth;
+}
+function createLoginCommand() {
+  return new Command("login").description("Authenticate with Chanl API").option("-k, --api-key <key>", "API key to use for authentication").option("--browser", "Force browser-based login (email/password or Google/Microsoft)").option("--base-url <url>", "Override the API base URL").addHelpText(
+    "after",
+    `
+Login Methods:
+  Default           Opens browser for sign-in (Google, Microsoft, or email)
+  --api-key <key>   Use an API key directly (skips browser)
+
+Examples:
+  $ chanl login                          # Browser login (recommended)
+  $ chanl login --api-key ak_xxx         # API key login
+  $ chanl login --base-url http://localhost:3100   # Custom API URL`
+  ).action(handleLogin);
+}
+function createLogoutCommand() {
+  return new Command("logout").description("Remove stored credentials").action(handleLogout);
+}
+async function handleLogin(options) {
+  if (options.baseUrl) {
+    configStore.setBaseUrl(options.baseUrl);
+  }
+  if (options.apiKey) {
+    await handleApiKeyLogin(options.apiKey);
+  } else {
+    await handleBrowserLogin();
+  }
+}
+async function handleApiKeyLogin(apiKey) {
+  const baseUrl = configStore.getBaseUrl();
+  const spinner = ora("Validating API key...").start();
+  try {
+    const sdk = new ChanlSDK({ apiKey, baseUrl });
+    const healthResponse = await sdk.health.getHealth();
+    if (!healthResponse.success) {
+      spinner.fail("Cannot connect to API");
+      printError("API is not reachable", `Check that the server is running at ${baseUrl}`);
+      process.exitCode = 1;
+      return;
+    }
+    const authTestResponse = await sdk.tools.list();
+    if (!authTestResponse.success) {
+      spinner.fail("Authentication failed");
+      printError("Invalid API key or unauthorized access");
+      process.exitCode = 1;
+      return;
+    }
+    configStore.setApiKey(apiKey);
+    spinner.succeed("Authentication successful");
+    if (isJsonOutput()) {
+      printJson({ success: true, method: "api-key", apiKey: maskString(apiKey), baseUrl });
+    } else {
+      printSuccess(`API key saved to ${configStore.getPath()}`);
+      printInfo("Workspace context is determined by your API key");
+    }
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Failed to validate API key", message);
+    process.exitCode = 1;
+  }
+}
+async function handleBrowserLogin() {
+  const baseUrl = configStore.getBaseUrl();
+  const appUrl = configStore.getAppUrl();
+  printBlank();
+  printInfo("Opening browser for authentication...");
+  try {
+    const { firebaseToken, port } = await startCallbackServer();
+    const authUrl = `${appUrl}/cli-auth?port=${port}`;
+    const open = (await import("open")).default;
+    await open(authUrl);
+    printInfo(`If the browser didn't open, visit:`);
+    console.log(chalk.cyan(`  ${authUrl}`));
+    printBlank();
+    const spinner = ora("Waiting for authentication...").start();
+    const token = await firebaseToken;
+    spinner.text = "Exchanging token...";
+    const sdk = new ChanlSDK({ baseUrl });
+    const response = await sdk.auth.exchangeFirebaseToken(token);
+    if (!response.success || !response.data) {
+      spinner.fail("Token exchange failed");
+      printError("Failed to exchange token", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const { accessToken, refreshToken, user, defaultWorkspaceId, workspaces } = response.data;
+    configStore.setJwtAuth(accessToken, refreshToken);
+    let selectedWorkspaceId = defaultWorkspaceId;
+    if (workspaces && workspaces.length > 1 && !isJsonOutput()) {
+      spinner.stop();
+      printBlank();
+      selectedWorkspaceId = await select({
+        message: "Select a workspace:",
+        choices: workspaces.map((ws) => ({
+          name: ws.name || ws.workspaceId,
+          value: ws.workspaceId,
+          description: ws.role
+        })),
+        default: defaultWorkspaceId
+      });
+    } else if (workspaces && workspaces.length === 1) {
+      selectedWorkspaceId = workspaces[0].workspaceId;
+    }
+    if (selectedWorkspaceId) {
+      configStore.setWorkspaceId(selectedWorkspaceId);
+    }
+    spinner.succeed("Authentication successful");
+    if (isJsonOutput()) {
+      printJson({
+        success: true,
+        method: "browser",
+        user: { email: user.email, displayName: user.displayName },
+        workspaceId: selectedWorkspaceId
+      });
+    } else {
+      printBlank();
+      printLabel("User", user.email);
+      if (user.displayName) printLabel("Name", user.displayName);
+      if (selectedWorkspaceId) printLabel("Workspace", selectedWorkspaceId);
+      printBlank();
+      printSuccess(`Credentials saved to ${configStore.getPath()}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    if (message === "LOGIN_TIMEOUT") {
+      printError("Login timed out", "No response from browser within 2 minutes");
+    } else if (message === "LOGIN_CANCELLED") {
+      printInfo("Login cancelled");
+    } else {
+      printError("Browser login failed", message);
+    }
+    process.exitCode = 1;
+  }
+}
+function startCallbackServer() {
+  return new Promise((resolveSetup) => {
+    let resolveToken;
+    let rejectToken;
+    const firebaseToken = new Promise((resolve, reject) => {
+      resolveToken = resolve;
+      rejectToken = reject;
+    });
+    const server = http.createServer((req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (req.method === "POST" && req.url === "/callback") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const data = JSON.parse(body);
+            if (data.error) {
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ success: false }));
+              rejectToken(new Error(data.error));
+              return;
+            }
+            if (!data.token) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Missing token" }));
+              return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ success: true }));
+            resolveToken(data.token);
+          } catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Invalid JSON" }));
+          }
+        });
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      const timeout = setTimeout(() => {
+        server.close();
+        rejectToken(new Error("LOGIN_TIMEOUT"));
+      }, 12e4);
+      firebaseToken.then(() => {
+        clearTimeout(timeout);
+        setTimeout(() => server.close(), 500);
+      }).catch(() => {
+        clearTimeout(timeout);
+        server.close();
+      });
+      resolveSetup({ firebaseToken, port, server });
+    });
+  });
+}
+async function handleLogout() {
+  if (!configStore.isAuthenticated()) {
+    if (isJsonOutput()) {
+      printJson({ success: true, message: "Already logged out" });
+    } else {
+      printInfo("Already logged out");
+    }
+    return;
+  }
+  configStore.clearAuth();
+  configStore.delete("workspaceId");
+  if (isJsonOutput()) {
+    printJson({ success: true, message: "Logged out successfully" });
+  } else {
+    printSuccess("Logged out successfully");
+  }
+}
+async function handleAuthStatus() {
+  const authMethod = configStore.getAuthMethod();
+  const baseUrl = configStore.getBaseUrl();
+  const workspaceId = configStore.getWorkspaceId();
+  if (isJsonOutput()) {
+    printJson({
+      authenticated: authMethod !== null,
+      method: authMethod,
+      apiKey: authMethod === "api-key" ? maskString(configStore.getApiKey()) : null,
+      jwtToken: authMethod === "jwt" ? "(set)" : null,
+      workspaceId: workspaceId ?? null,
+      baseUrl
+    });
+    return;
+  }
+  printBlank();
+  if (!authMethod) {
+    printLabel("Status", chalk.yellow("Not authenticated"));
+    printBlank();
+    printInfo("Run 'chanl login' to authenticate via browser");
+    printInfo("Run 'chanl login --api-key <key>' to use an API key");
+    return;
+  }
+  printLabel("Status", chalk.green("Authenticated"));
+  printLabel("Method", authMethod === "jwt" ? "Browser (JWT)" : "API Key");
+  if (authMethod === "api-key") {
+    printLabel("API Key", maskString(configStore.getApiKey()));
+  }
+  printLabel("Base URL", baseUrl);
+  if (workspaceId) {
+    printLabel("Workspace ID", workspaceId);
+    try {
+      const sdkConfig = { baseUrl };
+      if (authMethod === "api-key") {
+        sdkConfig.apiKey = configStore.getApiKey();
+      } else {
+        sdkConfig.jwtToken = configStore.getJwtToken();
+      }
+      const sdk = new ChanlSDK(sdkConfig);
+      const response = await sdk.workspace.getById(workspaceId);
+      if (response.success && response.data?.name) {
+        printLabel("Workspace Name", response.data.name);
+      }
+    } catch {
+    }
+  }
+  printBlank();
+}
+export {
+  createAuthCommand,
+  createLoginCommand,
+  createLogoutCommand
+};
+//# sourceMappingURL=auth.js.map

package/dist/commands/chat.js

@@ -0,0 +1,203 @@
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import { createInterface } from "node:readline";
+import { createSdk } from "../utils/sdk-factory.js";
+import {
+  printError,
+  printSuccess,
+  printInfo,
+  printBlank,
+  isJsonOutput,
+  printJson
+} from "../utils/output.js";
+function createChatCommand() {
+  const chat = new Command("chat").description("Start an interactive chat session with an agent").argument("<agent-id>", "ID of the agent to chat with").option("-m, --message <text>", "Send a single message and exit").option("-s, --stream", "Enable streaming responses (real-time text)").option("-w, --workspace <id>", "Workspace ID override").addHelpText(
+    "after",
+    `
+What is Chat?
+  Chat lets you test an AI agent via text in your terminal. It creates a session
+  on the Chanl platform, which manages the full lifecycle including
+  transcription, billing, and post-chat evaluation.
+
+Modes:
+  Interactive (default):  Opens a prompt loop \u2014 type messages, see agent responses.
+                          Type 'exit', 'quit', or press Ctrl+C to end.
+
+  Single message:         Send one message with --message, print response, exit.
+
+Streaming:
+  Use --stream for real-time text output. Text appears as the agent generates it.
+  Note: streaming responses do not include tool call metadata.
+
+Examples:
+  $ chanl chat abc123                          # Interactive chat
+  $ chanl chat abc123 --stream                 # Interactive with streaming
+  $ chanl chat abc123 --message "Hello"        # Single message mode
+  $ chanl chat abc123 --message "Hi" --stream  # Single message, streamed
+  $ chanl chat abc123 --message "Hi" --json    # Single message, JSON output
+  $ chanl chat abc123 --workspace ws_456       # Override workspace`
+  ).action(handleChat);
+  return chat;
+}
+async function handleChat(agentId, options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  if (options.message) {
+    await handleSingleMessage(sdk, agentId, options.message, options.stream);
+  } else {
+    await handleInteractiveChat(sdk, agentId, options.stream);
+  }
+}
+async function handleSingleMessage(sdk, agentId, message, stream) {
+  const spinner = ora("Connecting to agent...").start();
+  try {
+    const chat = await sdk.chat.session(agentId);
+    spinner.text = "Sending message...";
+    try {
+      if (stream && !isJsonOutput()) {
+        spinner.stop();
+        printBlank();
+        console.log(chalk.dim("You >"), message);
+        process.stdout.write(chalk.cyan("Agent > "));
+        const reply = await chat.send(message, {
+          stream: true,
+          onChunk: (delta) => process.stdout.write(delta)
+        });
+        console.log();
+        if (reply.latencyMs) {
+          printBlank();
+          printInfo(`Response time: ${reply.latencyMs}ms`);
+        }
+        printBlank();
+      } else {
+        const reply = await chat.send(message);
+        spinner.stop();
+        if (isJsonOutput()) {
+          printJson({
+            sessionId: chat.sessionId,
+            agentId,
+            message,
+            response: reply.message,
+            toolCalls: reply.toolCalls,
+            latencyMs: reply.latencyMs
+          });
+        } else {
+          printBlank();
+          console.log(chalk.dim("You >"), message);
+          if (reply.toolCalls?.length) {
+            console.log(chalk.dim("  Tools:"));
+            printToolCalls(reply.toolCalls);
+          }
+          console.log(chalk.cyan("Agent >"), reply.message);
+          if (reply.latencyMs) {
+            printBlank();
+            printInfo(`Response time: ${reply.latencyMs}ms`);
+          }
+          printBlank();
+        }
+      }
+    } finally {
+      await chat.end();
+    }
+  } catch (error) {
+    spinner.fail("Chat failed");
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", errorMessage);
+    process.exitCode = 1;
+  }
+}
+async function handleInteractiveChat(sdk, agentId, stream) {
+  const spinner = ora("Connecting to agent...").start();
+  try {
+    const chat = await sdk.chat.session(agentId);
+    const agentName = chat.agentName || "Agent";
+    spinner.succeed(`Connected to ${agentName}${stream ? " (streaming)" : ""}`);
+    printInfo("Type 'exit' or 'quit' to end the session. Ctrl+C also works.");
+    printBlank();
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const prompt = () => {
+      rl.question(chalk.bold("You > "), async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+          prompt();
+          return;
+        }
+        if (trimmed.toLowerCase() === "exit" || trimmed.toLowerCase() === "quit") {
+          await endSessionCleanly(chat);
+          rl.close();
+          return;
+        }
+        try {
+          if (stream) {
+            process.stdout.write(chalk.cyan("Agent > "));
+            const reply = await chat.send(trimmed, {
+              stream: true,
+              onChunk: (delta) => process.stdout.write(delta)
+            });
+            console.log();
+            if (reply.latencyMs) {
+              printInfo(`${reply.latencyMs}ms`);
+            }
+          } else {
+            const reply = await chat.send(trimmed);
+            if (reply.toolCalls?.length) {
+              console.log(chalk.dim("  Tools:"));
+              printToolCalls(reply.toolCalls);
+            }
+            console.log(chalk.cyan("Agent >"), reply.message);
+          }
+          printBlank();
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          printError("Send failed", errorMessage);
+          printBlank();
+        }
+        prompt();
+      });
+    };
+    const handleSigint = async () => {
+      printBlank();
+      await endSessionCleanly(chat);
+      rl.close();
+      process.exit(0);
+    };
+    rl.on("SIGINT", () => {
+      void handleSigint();
+    });
+    rl.on("close", () => {
+    });
+    prompt();
+  } catch (error) {
+    spinner.fail("Failed to connect");
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", errorMessage);
+    process.exitCode = 1;
+  }
+}
+function printToolCalls(toolCalls) {
+  for (const tc of toolCalls) {
+    const statusIcon = tc.status === "success" ? chalk.green("\u2713") : tc.status === "error" ? chalk.red("\u2717") : tc.status === "timeout" ? chalk.yellow("\u23F1") : chalk.dim("\u2026");
+    const duration = tc.durationMs ? chalk.dim(` (${tc.durationMs}ms)`) : "";
+    const params = Object.keys(tc.parameters).length ? chalk.dim(` ${JSON.stringify(tc.parameters)}`) : "";
+    console.log(`  ${statusIcon} ${chalk.yellow(tc.name)}${params}${duration}`);
+    if (tc.status === "error" && tc.error) {
+      console.log(`    ${chalk.red(tc.error.message)}`);
+    }
+  }
+}
+async function endSessionCleanly(chat) {
+  try {
+    await chat.end();
+    printSuccess("Session ended");
+  } catch {
+    printInfo("Session closed");
+  }
+}
+export {
+  createChatCommand
+};
+//# sourceMappingURL=chat.js.map