@protoboxai/cli 1.0.0

package/dist/commands/mcp.js

@@ -0,0 +1,589 @@
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { configStore } from "../utils/config-store.js";
+import { createSdk } from "../utils/sdk-factory.js";
+import {
+  printSuccess,
+  printError,
+  printInfo,
+  printLabel,
+  printBlank,
+  printSimpleTable,
+  isJsonOutput,
+  printJson
+} from "../utils/output.js";
+function createMcpCommand() {
+  const mcp = new Command("mcp").description("MCP server configuration and status").addHelpText(
+    "after",
+    `
+What is MCP?
+  Model Context Protocol (MCP) lets AI agents (Claude, Cursor, etc.) use your
+  Chanl tools, knowledge base, and prompts. The MCP server bridges your workspace
+  with AI clients.
+
+Quick Start:
+  $ chanl mcp                # Check server status
+  $ chanl mcp test           # Run protocol test
+  $ chanl mcp config         # Get config for your AI client
+
+Connecting AI Clients:
+  1. Run 'chanl mcp config --format claude' to get Claude Desktop config
+  2. Add the JSON to Claude Desktop's settings
+  3. Your Chanl tools will appear in Claude!`
+  ).action(handleMcpDefault);
+  mcp.command("info").description("Show MCP server URL, status, and resource counts").addHelpText(
+    "after",
+    `
+Example:
+  $ chanl mcp info             # Show server details
+  $ chanl mcp info --json      # Output as JSON`
+  ).action(handleMcpInfo);
+  mcp.command("status").description("Health check the MCP server").addHelpText(
+    "after",
+    `
+Example:
+  $ chanl mcp status           # Quick health check`
+  ).action(handleMcpStatus);
+  mcp.command("test").description("Run MCP protocol test with real MCP client").addHelpText(
+    "after",
+    `
+Tests the full MCP protocol handshake:
+  1. Connect to MCP server
+  2. List available tools
+  3. List resources (knowledge base)
+  4. List prompts
+
+Example:
+  $ chanl mcp test             # Run all protocol tests
+  $ chanl mcp test --json      # Output results as JSON`
+  ).action(handleMcpTest);
+  mcp.command("config").description("Output MCP configuration for AI clients").option("-f, --format <format>", "Format: claude, cursor, generic", "generic").addHelpText(
+    "after",
+    `
+Generates configuration JSON for connecting AI clients to your MCP server.
+
+Supported formats:
+  claude    - Claude Desktop (claude_desktop_config.json)
+  cursor    - Cursor IDE settings
+  generic   - Generic MCP client format
+
+Examples:
+  $ chanl mcp config                          # Generic format
+  $ chanl mcp config --format claude          # Claude Desktop format
+  $ chanl mcp config --format cursor          # Cursor IDE format
+  $ chanl mcp config --format claude > config.json  # Save to file
+
+Setup Claude Desktop:
+  1. Run: chanl mcp config --format claude
+  2. Copy the JSON output
+  3. Paste into ~/Library/Application Support/Claude/claude_desktop_config.json`
+  ).action(handleMcpConfig);
+  mcp.command("tools <agent-id>").description("List MCP tools available for an agent").addHelpText(
+    "after",
+    `
+Example:
+  $ chanl mcp tools agent_123            # List tools for agent
+  $ chanl mcp tools agent_123 --json     # Output as JSON`
+  ).action(handleMcpTools);
+  mcp.command("call <agent-id> <tool-name> [args]").description("Call an MCP tool by name").addHelpText(
+    "after",
+    `
+Example:
+  $ chanl mcp call agent_123 get_weather '{"city":"London"}'
+  $ chanl mcp call agent_123 ping
+  $ chanl mcp call agent_123 get_weather '{"city":"London"}' --json`
+  ).action(handleMcpCall);
+  mcp.command("inspect <agent-id> <tool-name>").description("Show schema and details for a specific MCP tool").addHelpText(
+    "after",
+    `
+Example:
+  $ chanl mcp inspect agent_123 get_weather
+  $ chanl mcp inspect agent_123 get_weather --json`
+  ).action(handleMcpInspect);
+  mcp.command("install").description("Generate MCP config snippet for editors (Cursor, VSCode, Claude)").option("-f, --format <format>", "Format: claude, cursor, vscode, generic", "generic").addHelpText(
+    "after",
+    `
+Generates a ready-to-use MCP configuration using your stored API key and workspace.
+No server call needed \u2014 works offline.
+
+Supported formats:
+  claude    - Claude Desktop / Claude Code
+  cursor    - Cursor IDE
+  vscode    - Visual Studio Code
+  generic   - Generic MCP client (default)
+
+Examples:
+  $ chanl mcp install                          # Generic format
+  $ chanl mcp install --format claude          # Claude Desktop format
+  $ chanl mcp install --format cursor          # Cursor IDE format
+  $ chanl mcp install --format vscode          # VSCode format
+  $ chanl mcp install --format claude > mcp.json  # Save to file`
+  ).action(handleMcpInstall);
+  return mcp;
+}
+async function handleMcpInfo() {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching MCP configuration...").start();
+  try {
+    const response = await sdk.mcp.getConfig();
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch MCP configuration", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const config = response.data;
+    if (isJsonOutput()) {
+      printJson(config);
+      return;
+    }
+    printBlank();
+    printSimpleTable(
+      ["Property", "Value"],
+      [
+        ["Server URL", config.serverUrl],
+        ["Environment", config.environment],
+        ["Status", config.status === "active" ? chalk.green("active") : chalk.red("disabled")],
+        ["Tools", config.toolCount.toString()],
+        ["Resources", config.resourceCount.toString()],
+        ["Prompts", config.promptCount.toString()],
+        ...config.toolsetName ? [["Toolset", config.toolsetName]] : []
+      ]
+    );
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to fetch MCP configuration");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleMcpStatus() {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Checking MCP server health...").start();
+  try {
+    const response = await sdk.mcp.getStatus();
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to check MCP status", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const status = response.data;
+    if (isJsonOutput()) {
+      printJson(status);
+      return;
+    }
+    printBlank();
+    if (status.healthy) {
+      printSuccess("MCP server is healthy");
+      printLabel("Message", status.message);
+      if (status.responseTimeMs) {
+        printLabel("Response Time", status.responseTimeMs + "ms");
+      }
+    } else {
+      printError("MCP server is unhealthy", status.message);
+      if (status.error) {
+        printLabel("Error", status.error);
+      }
+      process.exitCode = 1;
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to check MCP status");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleMcpConfig(options) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching MCP configuration...").start();
+  try {
+    const response = await sdk.mcp.getConfig();
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch MCP configuration", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const config = response.data;
+    const format = options.format.toLowerCase();
+    let output;
+    switch (format) {
+      case "claude":
+        output = config.agentConfigs.claude;
+        break;
+      case "cursor":
+        output = config.agentConfigs.cursor;
+        break;
+      case "generic":
+      default:
+        output = config.agentConfigs.generic;
+        break;
+    }
+    printJson(output);
+    if (!isJsonOutput()) {
+      printBlank();
+      printInfo(`Configuration for ${format} format. Copy and paste into your ${format === "claude" ? "Claude Desktop" : format === "cursor" ? "Cursor IDE" : "MCP client"} configuration.`);
+      printInfo(`Replace \${CHANL_MCP_API_KEY} with your actual MCP API key.`);
+    }
+  } catch (error) {
+    spinner.fail("Failed to fetch MCP configuration");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleMcpDefault() {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Checking MCP server...").start();
+  try {
+    const [configResponse, statusResponse] = await Promise.all([
+      sdk.mcp.getConfig(),
+      sdk.mcp.getStatus()
+    ]);
+    spinner.stop();
+    if (!configResponse.success || !configResponse.data) {
+      printError("Failed to fetch MCP configuration", configResponse.message);
+      process.exitCode = 1;
+      return;
+    }
+    const config = configResponse.data;
+    const status = statusResponse.data;
+    if (isJsonOutput()) {
+      printJson({ config, status });
+      return;
+    }
+    const statusIcon = status?.healthy ? chalk.green("\u2713") : chalk.red("\u2717");
+    const statusText = status?.healthy ? "Connected" : "Unhealthy";
+    const latency = status?.responseTimeMs ? ` (${status.responseTimeMs}ms)` : "";
+    printBlank();
+    console.log(chalk.bold("MCP Server"));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    printLabel("Server URL", config.serverUrl ?? "Not configured");
+    printLabel("Status", `${statusIcon} ${statusText}${latency}`);
+    printLabel("Tools", `${config.toolCount ?? 0} enabled`);
+    printLabel("Resources", (config.resourceCount ?? 0).toString());
+    printLabel("Prompts", (config.promptCount ?? 0).toString());
+    console.log(chalk.dim("\u2500".repeat(40)));
+    printBlank();
+    if (!status?.healthy) {
+      printInfo("Run 'chanl mcp test' for detailed diagnostics");
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    spinner.fail("Failed to check MCP server");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleMcpTools(agentId) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching MCP tools...").start();
+  try {
+    const response = await sdk.mcp.listTools(agentId);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch MCP tools", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const tools = response.data.tools;
+    if (isJsonOutput()) {
+      printJson({ tools });
+      return;
+    }
+    if (tools.length === 0) {
+      printBlank();
+      printInfo("No MCP tools available for this agent");
+      printBlank();
+      return;
+    }
+    printBlank();
+    printSimpleTable(
+      ["Name", "Description"],
+      tools.map((t) => [
+        t.name,
+        t.description || chalk.dim("No description")
+      ])
+    );
+    printBlank();
+    printInfo(`Total: ${tools.length} tool${tools.length === 1 ? "" : "s"}`);
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to fetch MCP tools");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleMcpCall(agentId, toolName, argsJson) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  let args;
+  if (argsJson) {
+    try {
+      args = JSON.parse(argsJson);
+    } catch {
+      printError("Invalid JSON arguments", `Could not parse: ${argsJson}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const spinner = ora(`Calling tool '${toolName}'...`).start();
+  try {
+    const response = await sdk.mcp.callTool(agentId, toolName, args);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to call tool", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const result = response.data;
+    if (isJsonOutput()) {
+      printJson(result);
+      return;
+    }
+    if (result.isError) {
+      for (const item of result.content) {
+        if (item.text) {
+          printError("Tool returned an error", item.text);
+        }
+      }
+      process.exitCode = 1;
+      return;
+    }
+    printBlank();
+    for (const item of result.content) {
+      if (item.text) {
+        console.log(item.text);
+      } else {
+        printJson(item);
+      }
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to call tool");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleMcpInspect(agentId, toolName) {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora(`Fetching tool '${toolName}'...`).start();
+  try {
+    const response = await sdk.mcp.getTool(agentId, toolName);
+    spinner.stop();
+    if (!response.success || !response.data) {
+      printError("Failed to fetch tool details", response.message);
+      process.exitCode = 1;
+      return;
+    }
+    const tool = response.data;
+    if (isJsonOutput()) {
+      printJson(tool);
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold(tool.name));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    if (tool.description) {
+      printLabel("Description", tool.description);
+    }
+    printBlank();
+    console.log(chalk.bold("Input Schema"));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    const schema = tool.inputSchema;
+    const properties = schema["properties"];
+    const required = schema["required"] || [];
+    if (properties) {
+      const rows = [];
+      for (const [name, prop] of Object.entries(properties)) {
+        const isRequired = required.includes(name);
+        const typeStr = String(prop["type"] || "any");
+        const desc = String(prop["description"] || "");
+        const reqStr = isRequired ? chalk.red("*") : " ";
+        rows.push([`${reqStr} ${name}`, typeStr, desc]);
+      }
+      printSimpleTable(["Parameter", "Type", "Description"], rows);
+    } else {
+      printInfo("No parameters defined");
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("Failed to fetch tool details");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+  }
+}
+async function handleMcpInstall(options) {
+  const apiKey = configStore.getApiKey();
+  if (!apiKey) {
+    printError("Not authenticated", "Run 'chanl login' to authenticate first");
+    process.exitCode = 1;
+    return;
+  }
+  const baseUrl = configStore.getBaseUrl() || "https://api.chanl.ai";
+  const mcpUrl = baseUrl.replace(/\/$/, "") + "/mcp";
+  const format = options.format.toLowerCase();
+  const serverConfig = {
+    url: mcpUrl,
+    headers: { "X-API-Key": apiKey },
+    transport: "streamable-http"
+  };
+  let output;
+  switch (format) {
+    case "claude":
+      output = {
+        mcpServers: {
+          chanl: serverConfig
+        }
+      };
+      break;
+    case "cursor":
+      output = {
+        mcpServers: {
+          chanl: serverConfig
+        }
+      };
+      break;
+    case "vscode":
+      output = {
+        mcpServers: {
+          chanl: serverConfig
+        }
+      };
+      break;
+    case "generic":
+    default:
+      output = {
+        mcpServers: {
+          chanl: serverConfig
+        }
+      };
+      break;
+  }
+  printJson(output);
+  if (!isJsonOutput()) {
+    printBlank();
+    const targetName = format === "claude" ? "Claude Desktop / Claude Code" : format === "cursor" ? "Cursor IDE" : format === "vscode" ? "Visual Studio Code" : "your MCP client";
+    printInfo(`Copy the JSON above into your ${targetName} configuration.`);
+    printBlank();
+  }
+}
+async function handleMcpTest() {
+  const sdk = createSdk();
+  if (!sdk) return;
+  const spinner = ora("Fetching MCP configuration...").start();
+  let config;
+  try {
+    const configResponse = await sdk.mcp.getConfig();
+    if (!configResponse.success || !configResponse.data) {
+      spinner.fail("Failed to fetch MCP configuration");
+      printError("Error", configResponse.message || "Unknown error");
+      process.exitCode = 1;
+      return;
+    }
+    config = configResponse.data;
+  } catch (error) {
+    spinner.fail("Failed to fetch MCP configuration");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Error", message);
+    process.exitCode = 1;
+    return;
+  }
+  spinner.text = "Running MCP protocol test...";
+  const apiKey = process.env.MCP_API_KEY || configStore.getApiKey();
+  if (!apiKey) {
+    spinner.fail("No API key available");
+    printError("Error", "API key required for MCP test. Set MCP_API_KEY env var for local dev.");
+    process.exitCode = 1;
+    return;
+  }
+  const results = [];
+  try {
+    const transport = new StreamableHTTPClientTransport(new URL(config.serverUrl), {
+      requestInit: {
+        headers: { "X-API-Key": apiKey }
+      }
+    });
+    const client = new Client(
+      { name: "chanl-cli", version: "1.0.0" },
+      { capabilities: {} }
+    );
+    spinner.text = "Connecting to MCP server...";
+    const connectStart = Date.now();
+    await client.connect(transport);
+    const connectTime = Date.now() - connectStart;
+    results.push({ test: "Connection", passed: true, detail: `${connectTime}ms` });
+    spinner.text = "Testing tools/list...";
+    try {
+      const tools = await client.listTools();
+      results.push({ test: "tools/list", passed: true, detail: `${tools.tools.length} tools` });
+    } catch (err) {
+      results.push({ test: "tools/list", passed: false, detail: err instanceof Error ? err.message : "Failed" });
+    }
+    spinner.text = "Testing resources/list...";
+    try {
+      const resources = await client.listResources();
+      results.push({ test: "resources/list", passed: true, detail: `${resources.resources.length} resources` });
+    } catch (err) {
+      results.push({ test: "resources/list", passed: true, detail: "N/A (no knowledge base)" });
+    }
+    spinner.text = "Testing prompts/list...";
+    try {
+      const prompts = await client.listPrompts();
+      results.push({ test: "prompts/list", passed: true, detail: `${prompts.prompts.length} prompts` });
+    } catch (err) {
+      results.push({ test: "prompts/list", passed: true, detail: "N/A" });
+    }
+    await client.close();
+    spinner.stop();
+    if (isJsonOutput()) {
+      printJson({ serverUrl: config.serverUrl, results });
+      return;
+    }
+    printBlank();
+    console.log(chalk.bold("\u{1F9EA} MCP Protocol Test"));
+    console.log(chalk.dim("\u2500".repeat(50)));
+    printLabel("Server", config.serverUrl);
+    console.log(chalk.dim("\u2500".repeat(50)));
+    let allPassed = true;
+    for (const result of results) {
+      const icon = result.passed ? chalk.green("\u2713") : chalk.red("\u2717");
+      console.log(`${icon} ${result.test}: ${result.detail}`);
+      if (!result.passed) allPassed = false;
+    }
+    console.log(chalk.dim("\u2500".repeat(50)));
+    if (allPassed) {
+      printSuccess("All tests passed");
+    } else {
+      printError("Some tests failed", "Check the results above");
+      process.exitCode = 1;
+    }
+    printBlank();
+  } catch (error) {
+    spinner.fail("MCP protocol test failed");
+    const message = error instanceof Error ? error.message : "Unknown error";
+    printError("Connection failed", message);
+    printInfo("Make sure the MCP server is running and accessible");
+    process.exitCode = 1;
+  }
+}
+export {
+  createMcpCommand
+};
+//# sourceMappingURL=mcp.js.map