@picahq/cli 0.2.0 → 1.3.0

package/dist/index.js

@@ -0,0 +1,1444 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/lib/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".pica");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function configExists() {
+  return fs.existsSync(CONFIG_FILE);
+}
+function readConfig() {
+  if (!configExists()) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { mode: 448 });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 });
+}
+function getApiKey() {
+  const config = readConfig();
+  return config?.apiKey ?? null;
+}
+
+// src/lib/agents.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+function expandPath(p5) {
+  if (p5.startsWith("~/")) {
+    return path2.join(os2.homedir(), p5.slice(2));
+  }
+  return p5;
+}
+function getClaudeDesktopConfigPath() {
+  switch (process.platform) {
+    case "darwin":
+      return "~/Library/Application Support/Claude/claude_desktop_config.json";
+    case "win32":
+      return path2.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
+    default:
+      return "~/.config/Claude/claude_desktop_config.json";
+  }
+}
+function getClaudeDesktopDetectDir() {
+  switch (process.platform) {
+    case "darwin":
+      return "~/Library/Application Support/Claude";
+    case "win32":
+      return path2.join(process.env.APPDATA || "", "Claude");
+    default:
+      return "~/.config/Claude";
+  }
+}
+function getWindsurfConfigPath() {
+  if (process.platform === "win32") {
+    return path2.join(process.env.USERPROFILE || os2.homedir(), ".codeium", "windsurf", "mcp_config.json");
+  }
+  return "~/.codeium/windsurf/mcp_config.json";
+}
+function getWindsurfDetectDir() {
+  if (process.platform === "win32") {
+    return path2.join(process.env.USERPROFILE || os2.homedir(), ".codeium", "windsurf");
+  }
+  return "~/.codeium/windsurf";
+}
+function getCursorConfigPath() {
+  if (process.platform === "win32") {
+    return path2.join(process.env.USERPROFILE || os2.homedir(), ".cursor", "mcp.json");
+  }
+  return "~/.cursor/mcp.json";
+}
+var AGENTS = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    configPath: "~/.claude.json",
+    configKey: "mcpServers",
+    detectDir: "~/.claude",
+    projectConfigPath: ".mcp.json"
+  },
+  {
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    configPath: getClaudeDesktopConfigPath(),
+    configKey: "mcpServers",
+    detectDir: getClaudeDesktopDetectDir()
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    configPath: getCursorConfigPath(),
+    configKey: "mcpServers",
+    detectDir: "~/.cursor",
+    projectConfigPath: ".cursor/mcp.json"
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    configPath: getWindsurfConfigPath(),
+    configKey: "mcpServers",
+    detectDir: getWindsurfDetectDir()
+  }
+];
+function getAllAgents() {
+  return AGENTS;
+}
+function supportsProjectScope(agent) {
+  return agent.projectConfigPath !== void 0;
+}
+function getAgentConfigPath(agent, scope = "global") {
+  if (scope === "project" && agent.projectConfigPath) {
+    return path2.join(process.cwd(), agent.projectConfigPath);
+  }
+  return expandPath(agent.configPath);
+}
+function readAgentConfig(agent, scope = "global") {
+  const configPath = getAgentConfigPath(agent, scope);
+  if (!fs2.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const content = fs2.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function writeAgentConfig(agent, config, scope = "global") {
+  const configPath = getAgentConfigPath(agent, scope);
+  const configDir = path2.dirname(configPath);
+  if (!fs2.existsSync(configDir)) {
+    fs2.mkdirSync(configDir, { recursive: true });
+  }
+  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function getMcpServerConfig(apiKey) {
+  return {
+    command: "npx",
+    args: ["-y", "@picahq/mcp"],
+    env: {
+      PICA_SECRET: apiKey
+    }
+  };
+}
+function installMcpConfig(agent, apiKey, scope = "global") {
+  const config = readAgentConfig(agent, scope);
+  const configKey = agent.configKey;
+  const mcpServers = config[configKey] || {};
+  mcpServers["pica"] = getMcpServerConfig(apiKey);
+  config[configKey] = mcpServers;
+  writeAgentConfig(agent, config, scope);
+}
+function isMcpInstalled(agent, scope = "global") {
+  const config = readAgentConfig(agent, scope);
+  const configKey = agent.configKey;
+  const mcpServers = config[configKey];
+  return mcpServers?.["pica"] !== void 0;
+}
+function getAgentStatuses() {
+  return AGENTS.map((agent) => {
+    const detected = fs2.existsSync(expandPath(agent.detectDir));
+    const globalMcp = detected && isMcpInstalled(agent, "global");
+    const projectMcp = agent.projectConfigPath ? isMcpInstalled(agent, "project") : null;
+    return { agent, detected, globalMcp, projectMcp };
+  });
+}
+
+// src/lib/actions.ts
+var ACTION_ID_PREFIX = "conn_mod_def::";
+function normalizeActionId(id) {
+  if (id.startsWith(ACTION_ID_PREFIX)) return id;
+  return `${ACTION_ID_PREFIX}${id}`;
+}
+function extractPathVariables(path3) {
+  const matches = path3.match(/\{\{(\w+)\}\}/g);
+  if (!matches) return [];
+  return matches.map((m) => m.replace(/\{\{|\}\}/g, ""));
+}
+function replacePathVariables(path3, vars) {
+  let result = path3;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(`{{${key}}}`, encodeURIComponent(value));
+  }
+  return result;
+}
+function resolveTemplateVariables(path3, data, pathVars) {
+  const variables = extractPathVariables(path3);
+  const merged = { ...pathVars };
+  const remaining = { ...data };
+  for (const v of variables) {
+    if (!merged[v] && data[v] != null) {
+      merged[v] = String(data[v]);
+      delete remaining[v];
+    }
+  }
+  return {
+    resolvedPath: replacePathVariables(path3, merged),
+    remainingData: remaining
+  };
+}
+
+// src/lib/api.ts
+var API_BASE = "https://api.picaos.com/v1";
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+var PicaApi = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async request(path3) {
+    return this.requestFull({ path: path3 });
+  }
+  async requestFull(opts) {
+    let url = `${API_BASE}${opts.path}`;
+    if (opts.queryParams && Object.keys(opts.queryParams).length > 0) {
+      const params = new URLSearchParams(opts.queryParams);
+      url += `?${params.toString()}`;
+    }
+    const headers = {
+      "x-pica-secret": this.apiKey,
+      "Content-Type": "application/json",
+      ...opts.headers
+    };
+    const fetchOpts = {
+      method: opts.method || "GET",
+      headers
+    };
+    if (opts.body !== void 0) {
+      fetchOpts.body = JSON.stringify(opts.body);
+    }
+    const response = await fetch(url, fetchOpts);
+    if (!response.ok) {
+      const text4 = await response.text();
+      throw new ApiError(response.status, text4 || `HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  async validateApiKey() {
+    try {
+      await this.listConnections();
+      return true;
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 401) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async listConnections() {
+    const response = await this.request("/vault/connections");
+    return response.rows || [];
+  }
+  async listPlatforms() {
+    const allPlatforms = [];
+    let page = 1;
+    let totalPages = 1;
+    do {
+      const response = await this.request(`/available-connectors?page=${page}&limit=100`);
+      allPlatforms.push(...response.rows || []);
+      totalPages = response.pages || 1;
+      page++;
+    } while (page <= totalPages);
+    return allPlatforms;
+  }
+  async searchActions(platform, query, limit = 10) {
+    const queryParams = {
+      limit: String(limit),
+      executeAgent: "true"
+    };
+    if (query) queryParams.query = query;
+    const response = await this.requestFull({
+      path: `/available-actions/search/${encodeURIComponent(platform)}`,
+      queryParams
+    });
+    return response.rows || [];
+  }
+  async getActionKnowledge(actionId) {
+    const normalized = normalizeActionId(actionId);
+    const response = await this.requestFull({
+      path: "/knowledge",
+      queryParams: { _id: normalized }
+    });
+    return response.rows?.[0] ?? null;
+  }
+  async executeAction(opts) {
+    const headers = {
+      "x-pica-connection-key": opts.connectionKey,
+      "x-pica-action-id": normalizeActionId(opts.actionId),
+      ...opts.headers
+    };
+    if (opts.isFormData) {
+      headers["Content-Type"] = "multipart/form-data";
+    } else if (opts.isFormUrlEncoded) {
+      headers["Content-Type"] = "application/x-www-form-urlencoded";
+    }
+    return this.requestFull({
+      path: `/passthrough${opts.path}`,
+      method: opts.method.toUpperCase(),
+      body: opts.data,
+      headers,
+      queryParams: opts.queryParams
+    });
+  }
+  async waitForConnection(platform, timeoutMs = 5 * 60 * 1e3, pollIntervalMs = 5e3, onPoll) {
+    const startTime = Date.now();
+    const existingConnections = await this.listConnections();
+    const existingIds = new Set(existingConnections.map((c) => c.id));
+    while (Date.now() - startTime < timeoutMs) {
+      await sleep(pollIntervalMs);
+      onPoll?.();
+      const currentConnections = await this.listConnections();
+      const newConnection = currentConnections.find(
+        (c) => c.platform.toLowerCase() === platform.toLowerCase() && !existingIds.has(c.id)
+      );
+      if (newConnection) {
+        return newConnection;
+      }
+    }
+    throw new TimeoutError(`Timed out waiting for ${platform} connection`);
+  }
+};
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/lib/browser.ts
+import open from "open";
+var PICA_APP_URL = "https://app.picaos.com";
+function getConnectionUrl(platform) {
+  return `${PICA_APP_URL}/connections?#open=${platform}`;
+}
+function getApiKeyUrl() {
+  return `${PICA_APP_URL}/settings/api-keys`;
+}
+async function openConnectionPage(platform) {
+  const url = getConnectionUrl(platform);
+  await open(url);
+}
+async function openApiKeyPage() {
+  await open(getApiKeyUrl());
+}
+
+// src/lib/table.ts
+import pc from "picocolors";
+function printTable(columns, rows) {
+  if (rows.length === 0) return;
+  const gap = "  ";
+  const indent = "  ";
+  const widths = columns.map((col) => {
+    const headerLen = col.label.length;
+    const maxValueLen = Math.max(...rows.map((row) => stripAnsi(row[col.key] || "").length));
+    return Math.max(headerLen, maxValueLen);
+  });
+  const header = columns.map((col, i) => {
+    const padded = col.align === "right" ? col.label.padStart(widths[i]) : col.label.padEnd(widths[i]);
+    return pc.dim(padded);
+  }).join(gap);
+  console.log(`${indent}${header}`);
+  const separator = columns.map((_, i) => pc.dim("\u2500".repeat(widths[i]))).join(gap);
+  console.log(`${indent}${separator}`);
+  for (const row of rows) {
+    const line = columns.map((col, i) => {
+      const raw = row[col.key] || "";
+      const rawLen = stripAnsi(raw).length;
+      const padding = widths[i] - rawLen;
+      const colored = col.color ? col.color(raw) : raw;
+      if (col.align === "right") {
+        return " ".repeat(Math.max(0, padding)) + colored;
+      }
+      return colored + " ".repeat(Math.max(0, padding));
+    }).join(gap);
+    console.log(`${indent}${line}`);
+  }
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  p.intro(pc2.bgCyan(pc2.black(" Pica ")));
+  const existingConfig = readConfig();
+  if (existingConfig) {
+    await handleExistingConfig(existingConfig.apiKey, options);
+    return;
+  }
+  await freshSetup(options);
+}
+async function handleExistingConfig(apiKey, options) {
+  const statuses = getAgentStatuses();
+  const masked = maskApiKey(apiKey);
+  console.log();
+  console.log(`  ${pc2.bold("Current Setup")}`);
+  console.log(`  ${pc2.dim("\u2500".repeat(42))}`);
+  console.log(`  ${pc2.dim("API Key:")}  ${masked}`);
+  console.log(`  ${pc2.dim("Config:")}   ${getConfigPath()}`);
+  console.log();
+  printTable(
+    [
+      { key: "agent", label: "Agent" },
+      { key: "global", label: "Global" },
+      { key: "project", label: "Project" }
+    ],
+    statuses.map((s) => ({
+      agent: s.agent.name,
+      global: !s.detected ? pc2.dim("-") : s.globalMcp ? pc2.green("\u25CF yes") : pc2.yellow("\u25CB no"),
+      project: s.projectMcp === null ? pc2.dim("-") : s.projectMcp ? pc2.green("\u25CF yes") : pc2.yellow("\u25CB no")
+    }))
+  );
+  const notDetected = statuses.filter((s) => !s.detected);
+  if (notDetected.length > 0) {
+    console.log(`  ${pc2.dim("- = not detected on this machine")}`);
+  }
+  console.log();
+  const actionOptions = [];
+  actionOptions.push({
+    value: "update-key",
+    label: "Update API key"
+  });
+  const agentsMissingGlobal = statuses.filter((s) => s.detected && !s.globalMcp);
+  if (agentsMissingGlobal.length > 0) {
+    actionOptions.push({
+      value: "install-more",
+      label: "Install MCP to more agents",
+      hint: agentsMissingGlobal.map((s) => s.agent.name).join(", ")
+    });
+  }
+  const agentsMissingProject = statuses.filter((s) => s.projectMcp === false);
+  if (agentsMissingProject.length > 0) {
+    actionOptions.push({
+      value: "install-project",
+      label: "Install MCP for this project",
+      hint: agentsMissingProject.map((s) => s.agent.name).join(", ")
+    });
+  }
+  actionOptions.push({
+    value: "start-fresh",
+    label: "Start fresh (reconfigure everything)"
+  });
+  const action = await p.select({
+    message: "What would you like to do?",
+    options: actionOptions
+  });
+  if (p.isCancel(action)) {
+    p.outro("No changes made.");
+    return;
+  }
+  switch (action) {
+    case "update-key":
+      await handleUpdateKey(statuses);
+      break;
+    case "install-more":
+      await handleInstallMore(apiKey, agentsMissingGlobal);
+      break;
+    case "install-project":
+      await handleInstallProject(apiKey, agentsMissingProject);
+      break;
+    case "start-fresh":
+      await freshSetup({ yes: true });
+      break;
+  }
+}
+async function handleUpdateKey(statuses) {
+  p.note(`Get your API key at:
+${pc2.cyan(getApiKeyUrl())}`, "API Key");
+  const openBrowser = await p.confirm({
+    message: "Open browser to get API key?",
+    initialValue: true
+  });
+  if (p.isCancel(openBrowser)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  if (openBrowser) {
+    await openApiKeyPage();
+  }
+  const newKey = await p.text({
+    message: "Enter your new Pica API key:",
+    placeholder: "sk_live_...",
+    validate: (value) => {
+      if (!value) return "API key is required";
+      if (!value.startsWith("sk_live_") && !value.startsWith("sk_test_")) {
+        return "API key should start with sk_live_ or sk_test_";
+      }
+      return void 0;
+    }
+  });
+  if (p.isCancel(newKey)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const spinner5 = p.spinner();
+  spinner5.start("Validating API key...");
+  const api = new PicaApi(newKey);
+  const isValid = await api.validateApiKey();
+  if (!isValid) {
+    spinner5.stop("Invalid API key");
+    p.cancel(`Invalid API key. Get a valid key at ${getApiKeyUrl()}`);
+    process.exit(1);
+  }
+  spinner5.stop("API key validated");
+  const reinstalled = [];
+  for (const s of statuses) {
+    if (s.globalMcp) {
+      installMcpConfig(s.agent, newKey, "global");
+      reinstalled.push(`${s.agent.name} (global)`);
+    }
+    if (s.projectMcp) {
+      installMcpConfig(s.agent, newKey, "project");
+      reinstalled.push(`${s.agent.name} (project)`);
+    }
+  }
+  const config = readConfig();
+  writeConfig({
+    apiKey: newKey,
+    installedAgents: config?.installedAgents ?? [],
+    createdAt: config?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (reinstalled.length > 0) {
+    p.log.success(`Updated MCP configs: ${reinstalled.join(", ")}`);
+  }
+  p.outro("API key updated.");
+}
+async function handleInstallMore(apiKey, missing) {
+  if (missing.length === 1) {
+    const agent = missing[0].agent;
+    const confirm2 = await p.confirm({
+      message: `Install Pica MCP to ${agent.name}?`,
+      initialValue: true
+    });
+    if (p.isCancel(confirm2) || !confirm2) {
+      p.outro("No changes made.");
+      return;
+    }
+    installMcpConfig(agent, apiKey, "global");
+    updateConfigAgents(agent.id);
+    p.log.success(`${agent.name}: MCP installed`);
+    p.outro("Done.");
+    return;
+  }
+  const selected = await p.multiselect({
+    message: "Select agents to install MCP:",
+    options: missing.map((s) => ({
+      value: s.agent.id,
+      label: s.agent.name
+    }))
+  });
+  if (p.isCancel(selected)) {
+    p.outro("No changes made.");
+    return;
+  }
+  const agents = missing.filter((s) => selected.includes(s.agent.id));
+  for (const s of agents) {
+    installMcpConfig(s.agent, apiKey, "global");
+    updateConfigAgents(s.agent.id);
+    p.log.success(`${s.agent.name}: MCP installed`);
+  }
+  p.outro("Done.");
+}
+async function handleInstallProject(apiKey, missing) {
+  if (missing.length === 1) {
+    const agent = missing[0].agent;
+    const confirm2 = await p.confirm({
+      message: `Install project-level MCP for ${agent.name}?`,
+      initialValue: true
+    });
+    if (p.isCancel(confirm2) || !confirm2) {
+      p.outro("No changes made.");
+      return;
+    }
+    installMcpConfig(agent, apiKey, "project");
+    const configPath = getAgentConfigPath(agent, "project");
+    p.log.success(`${agent.name}: ${configPath} created`);
+    p.note(
+      pc2.yellow("Project config files can be committed to share with your team.\n") + pc2.yellow("Team members will need their own API key."),
+      "Tip"
+    );
+    p.outro("Done.");
+    return;
+  }
+  const selected = await p.multiselect({
+    message: "Select agents for project-level MCP:",
+    options: missing.map((s) => ({
+      value: s.agent.id,
+      label: s.agent.name
+    }))
+  });
+  if (p.isCancel(selected)) {
+    p.outro("No changes made.");
+    return;
+  }
+  const agents = missing.filter((s) => selected.includes(s.agent.id));
+  for (const s of agents) {
+    installMcpConfig(s.agent, apiKey, "project");
+    const configPath = getAgentConfigPath(s.agent, "project");
+    p.log.success(`${s.agent.name}: ${configPath} created`);
+  }
+  p.note(
+    pc2.yellow("Project config files can be committed to share with your team.\n") + pc2.yellow("Team members will need their own API key."),
+    "Tip"
+  );
+  p.outro("Done.");
+}
+async function freshSetup(options) {
+  p.note(`Get your API key at:
+${pc2.cyan(getApiKeyUrl())}`, "API Key");
+  const openBrowser = await p.confirm({
+    message: "Open browser to get API key?",
+    initialValue: true
+  });
+  if (p.isCancel(openBrowser)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  if (openBrowser) {
+    await openApiKeyPage();
+  }
+  const apiKey = await p.text({
+    message: "Enter your Pica API key:",
+    placeholder: "sk_live_...",
+    validate: (value) => {
+      if (!value) return "API key is required";
+      if (!value.startsWith("sk_live_") && !value.startsWith("sk_test_")) {
+        return "API key should start with sk_live_ or sk_test_";
+      }
+      return void 0;
+    }
+  });
+  if (p.isCancel(apiKey)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  const spinner5 = p.spinner();
+  spinner5.start("Validating API key...");
+  const api = new PicaApi(apiKey);
+  const isValid = await api.validateApiKey();
+  if (!isValid) {
+    spinner5.stop("Invalid API key");
+    p.cancel(`Invalid API key. Get a valid key at ${getApiKeyUrl()}`);
+    process.exit(1);
+  }
+  spinner5.stop("API key validated");
+  writeConfig({
+    apiKey,
+    installedAgents: [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const allAgents = getAllAgents();
+  const agentChoice = await p.select({
+    message: "Where do you want to install the MCP?",
+    options: [
+      {
+        value: "all",
+        label: "All agents",
+        hint: "Claude Code, Claude Desktop, Cursor, Windsurf"
+      },
+      ...allAgents.map((agent) => ({
+        value: agent.id,
+        label: agent.name
+      }))
+    ]
+  });
+  if (p.isCancel(agentChoice)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  const selectedAgents = agentChoice === "all" ? allAgents : allAgents.filter((a) => a.id === agentChoice);
+  let scope = "global";
+  const hasProjectScopeAgent = selectedAgents.some((a) => supportsProjectScope(a));
+  if (options.global) {
+    scope = "global";
+  } else if (options.project) {
+    scope = "project";
+  } else if (hasProjectScopeAgent) {
+    const scopeChoice = await p.select({
+      message: "How do you want to install it?",
+      options: [
+        {
+          value: "global",
+          label: "Global (Recommended)",
+          hint: "Available in all your projects"
+        },
+        {
+          value: "project",
+          label: "Project only",
+          hint: "Creates config files in current directory"
+        }
+      ]
+    });
+    if (p.isCancel(scopeChoice)) {
+      p.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    scope = scopeChoice;
+  }
+  if (scope === "project") {
+    const projectAgents = selectedAgents.filter((a) => supportsProjectScope(a));
+    const nonProjectAgents = selectedAgents.filter((a) => !supportsProjectScope(a));
+    if (projectAgents.length === 0) {
+      const supported = allAgents.filter((a) => supportsProjectScope(a)).map((a) => a.name).join(", ");
+      p.note(
+        `${selectedAgents.map((a) => a.name).join(", ")} does not support project-level MCP.
+Project scope is supported by: ${supported}`,
+        "Not Supported"
+      );
+      p.cancel("Run again and choose global scope or a different agent.");
+      process.exit(1);
+    }
+    for (const agent of projectAgents) {
+      const wasInstalled = isMcpInstalled(agent, "project");
+      installMcpConfig(agent, apiKey, "project");
+      const configPath = getAgentConfigPath(agent, "project");
+      const status = wasInstalled ? "updated" : "created";
+      p.log.success(`${agent.name}: ${configPath} ${status}`);
+    }
+    if (nonProjectAgents.length > 0) {
+      p.log.info(`Installing globally for agents without project scope support:`);
+      for (const agent of nonProjectAgents) {
+        const wasInstalled = isMcpInstalled(agent, "global");
+        installMcpConfig(agent, apiKey, "global");
+        const status = wasInstalled ? "updated" : "installed";
+        p.log.success(`${agent.name}: MCP ${status} (global)`);
+      }
+    }
+    const allInstalled = [...projectAgents, ...nonProjectAgents];
+    writeConfig({
+      apiKey,
+      installedAgents: allInstalled.map((a) => a.id),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const configPaths = projectAgents.map((a) => `  ${a.name}: ${pc2.dim(getAgentConfigPath(a, "project"))}`).join("\n");
+    let summary = `Config saved to: ${pc2.dim(getConfigPath())}
+MCP configs:
+${configPaths}
+
+`;
+    if (nonProjectAgents.length > 0) {
+      const globalPaths = nonProjectAgents.map((a) => `  ${a.name}: ${pc2.dim(getAgentConfigPath(a, "global"))}`).join("\n");
+      summary += `Global configs:
+${globalPaths}
+
+`;
+    }
+    summary += pc2.yellow("Note: Project config files can be committed to share with your team.\n") + pc2.yellow("Team members will need their own API key.\n\n") + `Next steps:
+  ${pc2.cyan("pica add gmail")}       - Connect Gmail
+  ${pc2.cyan("pica platforms")}        - See all 200+ integrations`;
+    p.note(summary, "Setup Complete");
+    p.outro("Pica MCP installed!");
+    return;
+  }
+  const installedAgentIds = [];
+  for (const agent of selectedAgents) {
+    const wasInstalled = isMcpInstalled(agent, "global");
+    installMcpConfig(agent, apiKey, "global");
+    installedAgentIds.push(agent.id);
+    const status = wasInstalled ? "updated" : "installed";
+    p.log.success(`${agent.name}: MCP ${status}`);
+  }
+  writeConfig({
+    apiKey,
+    installedAgents: installedAgentIds,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  p.note(
+    `Config saved to: ${pc2.dim(getConfigPath())}
+
+Next steps:
+  ${pc2.cyan("pica add gmail")}       - Connect Gmail
+  ${pc2.cyan("pica platforms")}        - See all 200+ integrations
+  ${pc2.cyan("pica connection list")}  - View your connections`,
+    "Setup Complete"
+  );
+  p.outro("Your AI agents now have access to Pica integrations!");
+}
+function maskApiKey(key) {
+  if (key.length <= 12) return key.slice(0, 8) + "...";
+  return key.slice(0, 8) + "..." + key.slice(-4);
+}
+function updateConfigAgents(agentId) {
+  const config = readConfig();
+  if (!config) return;
+  if (!config.installedAgents.includes(agentId)) {
+    config.installedAgents.push(agentId);
+    writeConfig(config);
+  }
+}
+
+// src/commands/connection.ts
+import * as p2 from "@clack/prompts";
+import pc3 from "picocolors";
+
+// src/lib/platforms.ts
+function findPlatform(platforms, query) {
+  const normalizedQuery = query.toLowerCase().trim();
+  const exact = platforms.find(
+    (p5) => p5.platform.toLowerCase() === normalizedQuery || p5.name.toLowerCase() === normalizedQuery
+  );
+  if (exact) return exact;
+  return null;
+}
+function findSimilarPlatforms(platforms, query, limit = 3) {
+  const normalizedQuery = query.toLowerCase().trim();
+  const scored = platforms.map((p5) => {
+    const name = p5.name.toLowerCase();
+    const slug = p5.platform.toLowerCase();
+    let score = 0;
+    if (name.includes(normalizedQuery) || slug.includes(normalizedQuery)) {
+      score = 10;
+    } else if (normalizedQuery.includes(name) || normalizedQuery.includes(slug)) {
+      score = 5;
+    } else {
+      score = countMatchingChars(normalizedQuery, slug);
+    }
+    return { platform: p5, score };
+  }).filter((item) => item.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+  return scored.map((item) => item.platform);
+}
+function countMatchingChars(a, b) {
+  let count = 0;
+  const bChars = new Set(b.split(""));
+  for (const char of a) {
+    if (bChars.has(char)) count++;
+  }
+  return count;
+}
+
+// src/commands/connection.ts
+async function connectionAddCommand(platformArg) {
+  p2.intro(pc3.bgCyan(pc3.black(" Pica ")));
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    p2.cancel("Not configured. Run `pica init` first.");
+    process.exit(1);
+  }
+  const api = new PicaApi(apiKey);
+  const spinner5 = p2.spinner();
+  spinner5.start("Loading platforms...");
+  let platforms;
+  try {
+    platforms = await api.listPlatforms();
+    spinner5.stop(`${platforms.length} platforms available`);
+  } catch (error) {
+    spinner5.stop("Failed to load platforms");
+    p2.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+  let platform;
+  if (platformArg) {
+    const found = findPlatform(platforms, platformArg);
+    if (found) {
+      platform = found.platform;
+    } else {
+      const similar = findSimilarPlatforms(platforms, platformArg);
+      if (similar.length > 0) {
+        p2.log.warn(`Unknown platform: ${platformArg}`);
+        const suggestion = await p2.select({
+          message: "Did you mean:",
+          options: [
+            ...similar.map((s) => ({ value: s.platform, label: `${s.name} (${s.platform})` })),
+            { value: "__other__", label: "None of these" }
+          ]
+        });
+        if (p2.isCancel(suggestion) || suggestion === "__other__") {
+          p2.note(`Run ${pc3.cyan("pica platforms")} to see all available platforms.`);
+          p2.cancel("Connection cancelled.");
+          process.exit(0);
+        }
+        platform = suggestion;
+      } else {
+        p2.cancel(`Unknown platform: ${platformArg}
+
+Run ${pc3.cyan("pica platforms")} to see available platforms.`);
+        process.exit(1);
+      }
+    }
+  } else {
+    const platformInput = await p2.text({
+      message: "Which platform do you want to connect?",
+      placeholder: "gmail, slack, hubspot...",
+      validate: (value) => {
+        if (!value.trim()) return "Platform name is required";
+        return void 0;
+      }
+    });
+    if (p2.isCancel(platformInput)) {
+      p2.cancel("Connection cancelled.");
+      process.exit(0);
+    }
+    const found = findPlatform(platforms, platformInput);
+    if (found) {
+      platform = found.platform;
+    } else {
+      p2.cancel(`Unknown platform: ${platformInput}
+
+Run ${pc3.cyan("pica platforms")} to see available platforms.`);
+      process.exit(1);
+    }
+  }
+  const url = getConnectionUrl(platform);
+  p2.log.info(`Opening browser to connect ${pc3.cyan(platform)}...`);
+  p2.note(pc3.dim(url), "URL");
+  try {
+    await openConnectionPage(platform);
+  } catch {
+    p2.log.warn("Could not open browser automatically.");
+    p2.note(`Open this URL manually:
+${url}`);
+  }
+  const pollSpinner = p2.spinner();
+  pollSpinner.start("Waiting for connection... (complete auth in browser)");
+  try {
+    const connection2 = await api.waitForConnection(platform, 5 * 60 * 1e3, 5e3);
+    pollSpinner.stop(`${platform} connected!`);
+    p2.log.success(`${pc3.green("\u2713")} ${connection2.platform} is now available to your AI agents.`);
+    p2.outro("Connection complete!");
+  } catch (error) {
+    pollSpinner.stop("Connection timed out");
+    if (error instanceof TimeoutError) {
+      p2.note(
+        `Possible issues:
+  - OAuth flow was not completed in the browser
+  - Browser popup was blocked
+  - Wrong account selected
+
+Try again with: ${pc3.cyan(`pica connection add ${platform}`)}`,
+        "Timed Out"
+      );
+    } else {
+      p2.log.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    process.exit(1);
+  }
+}
+async function connectionListCommand() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    p2.cancel("Not configured. Run `pica init` first.");
+    process.exit(1);
+  }
+  const api = new PicaApi(apiKey);
+  const spinner5 = p2.spinner();
+  spinner5.start("Loading connections...");
+  try {
+    const connections = await api.listConnections();
+    spinner5.stop(`${connections.length} connection${connections.length === 1 ? "" : "s"} found`);
+    if (connections.length === 0) {
+      p2.note(
+        `No connections yet.
+
+Add one with: ${pc3.cyan("pica connection add gmail")}`,
+        "No Connections"
+      );
+      return;
+    }
+    console.log();
+    const rows = connections.map((conn) => ({
+      status: getStatusIndicator(conn.state),
+      platform: conn.platform,
+      state: conn.state,
+      key: conn.key
+    }));
+    printTable(
+      [
+        { key: "status", label: "" },
+        { key: "platform", label: "Platform" },
+        { key: "state", label: "Status" },
+        { key: "key", label: "Connection Key", color: pc3.dim }
+      ],
+      rows
+    );
+    console.log();
+    p2.note(`Add more with: ${pc3.cyan("pica connection add <platform>")}`, "Tip");
+  } catch (error) {
+    spinner5.stop("Failed to load connections");
+    p2.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+}
+function getStatusIndicator(state) {
+  switch (state) {
+    case "operational":
+      return pc3.green("\u25CF");
+    case "degraded":
+      return pc3.yellow("\u25CF");
+    case "failed":
+      return pc3.red("\u25CF");
+    default:
+      return pc3.dim("\u25CB");
+  }
+}
+
+// src/commands/platforms.ts
+import * as p3 from "@clack/prompts";
+import pc4 from "picocolors";
+async function platformsCommand(options) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    p3.cancel("Not configured. Run `pica init` first.");
+    process.exit(1);
+  }
+  const api = new PicaApi(apiKey);
+  const spinner5 = p3.spinner();
+  spinner5.start("Loading platforms...");
+  try {
+    const platforms = await api.listPlatforms();
+    spinner5.stop(`${platforms.length} platforms available`);
+    if (options.json) {
+      console.log(JSON.stringify(platforms, null, 2));
+      return;
+    }
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const plat of platforms) {
+      const category = plat.category || "Other";
+      if (!byCategory.has(category)) {
+        byCategory.set(category, []);
+      }
+      byCategory.get(category).push(plat);
+    }
+    console.log();
+    if (options.category) {
+      const categoryPlatforms = byCategory.get(options.category);
+      if (!categoryPlatforms) {
+        const categories = [...byCategory.keys()].sort();
+        p3.note(`Available categories:
+  ${categories.join(", ")}`, "Unknown Category");
+        process.exit(1);
+      }
+      const rows = categoryPlatforms.sort((a, b) => a.platform.localeCompare(b.platform)).map((plat) => ({
+        platform: plat.platform,
+        name: plat.name,
+        category: plat.category || "Other"
+      }));
+      printTable(
+        [
+          { key: "platform", label: "Platform" },
+          { key: "name", label: "Name" }
+        ],
+        rows
+      );
+    } else {
+      const rows = platforms.sort((a, b) => a.category.localeCompare(b.category) || a.platform.localeCompare(b.platform)).map((plat) => ({
+        platform: plat.platform,
+        name: plat.name,
+        category: plat.category || "Other"
+      }));
+      printTable(
+        [
+          { key: "category", label: "Category" },
+          { key: "platform", label: "Platform" },
+          { key: "name", label: "Name" }
+        ],
+        rows
+      );
+    }
+    console.log();
+    p3.note(`Connect with: ${pc4.cyan("pica connection add <platform>")}`, "Tip");
+  } catch (error) {
+    spinner5.stop("Failed to load platforms");
+    p3.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/actions.ts
+import * as p4 from "@clack/prompts";
+import pc5 from "picocolors";
+function getApi() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    p4.cancel("Not configured. Run `pica init` first.");
+    process.exit(1);
+  }
+  return new PicaApi(apiKey);
+}
+function colorMethod(method) {
+  const m = method.toUpperCase();
+  switch (m) {
+    case "GET":
+      return pc5.green(m);
+    case "POST":
+      return pc5.yellow(m);
+    case "PUT":
+      return pc5.blue(m);
+    case "PATCH":
+      return pc5.cyan(m);
+    case "DELETE":
+      return pc5.red(m);
+    default:
+      return pc5.dim(m);
+  }
+}
+function padMethod(method) {
+  return method.toUpperCase().padEnd(7);
+}
+async function actionsSearchCommand(platform, query, options = {}) {
+  const api = getApi();
+  if (!query) {
+    const input = await p4.text({
+      message: `Search actions on ${pc5.cyan(platform)}:`,
+      placeholder: "send email, create contact, list orders..."
+    });
+    if (p4.isCancel(input)) {
+      p4.cancel("Cancelled.");
+      process.exit(0);
+    }
+    query = input;
+  }
+  const spinner5 = p4.spinner();
+  spinner5.start(`Searching ${platform} actions...`);
+  try {
+    const limit = options.limit ? parseInt(options.limit, 10) : 10;
+    const actions2 = await api.searchActions(platform, query, limit);
+    spinner5.stop(`${actions2.length} action${actions2.length === 1 ? "" : "s"} found`);
+    if (options.json) {
+      console.log(JSON.stringify(actions2, null, 2));
+      return;
+    }
+    if (actions2.length === 0) {
+      p4.note(`No actions found for "${query}" on ${platform}.`, "No Results");
+      return;
+    }
+    console.log();
+    const rows = actions2.map((action) => ({
+      method: colorMethod(padMethod(action.method)),
+      path: action.path,
+      title: action.title,
+      id: action._id
+    }));
+    printTable(
+      [
+        { key: "method", label: "Method" },
+        { key: "title", label: "Title" },
+        { key: "path", label: "Path", color: pc5.dim },
+        { key: "id", label: "Action ID", color: pc5.dim }
+      ],
+      rows
+    );
+    console.log();
+    p4.note(
+      `Get docs:  ${pc5.cyan("pica actions knowledge <actionId>")}
+Execute:   ${pc5.cyan("pica actions execute <actionId>")}`,
+      "Next Steps"
+    );
+  } catch (error) {
+    spinner5.stop("Search failed");
+    p4.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+}
+async function actionsKnowledgeCommand(actionId, options = {}) {
+  const api = getApi();
+  const spinner5 = p4.spinner();
+  spinner5.start("Loading action knowledge...");
+  try {
+    const knowledge = await api.getActionKnowledge(actionId);
+    spinner5.stop("Action knowledge loaded");
+    if (!knowledge) {
+      p4.cancel(`No knowledge found for action: ${actionId}`);
+      process.exit(1);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(knowledge, null, 2));
+      return;
+    }
+    printKnowledge(knowledge, options.full);
+  } catch (error) {
+    spinner5.stop("Failed to load knowledge");
+    p4.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+}
+function printKnowledge(k, full) {
+  console.log();
+  console.log(pc5.bold(`  ${k.title}`));
+  console.log();
+  console.log(`  Platform:  ${pc5.cyan(k.connectionPlatform)}`);
+  console.log(`  Method:    ${colorMethod(k.method)}`);
+  console.log(`  Path:      ${k.path}`);
+  console.log(`  Base URL:  ${pc5.dim(k.baseUrl)}`);
+  if (k.tags?.length) {
+    console.log(`  Tags:      ${k.tags.map((t) => pc5.dim(t)).join(", ")}`);
+  }
+  const pathVars = extractPathVariables(k.path);
+  if (pathVars.length > 0) {
+    console.log(`  Path Vars: ${pathVars.map((v) => pc5.yellow(`{{${v}}}`)).join(", ")}`);
+  }
+  console.log(`  Active:    ${k.active ? pc5.green("yes") : pc5.red("no")}`);
+  console.log(`  ID:        ${pc5.dim(k._id)}`);
+  if (k.knowledge) {
+    console.log();
+    console.log(pc5.bold("  API Documentation"));
+    console.log(pc5.dim("  " + "\u2500".repeat(40)));
+    console.log();
+    const lines = k.knowledge.split("\n");
+    const displayLines = full ? lines : lines.slice(0, 50);
+    for (const line of displayLines) {
+      console.log(`  ${line}`);
+    }
+    if (!full && lines.length > 50) {
+      console.log();
+      console.log(pc5.dim(`  ... ${lines.length - 50} more lines. Use --full to see all.`));
+    }
+  }
+  console.log();
+}
+async function actionsExecuteCommand(actionId, options = {}) {
+  const api = getApi();
+  const spinner5 = p4.spinner();
+  spinner5.start("Loading action details...");
+  let knowledge;
+  try {
+    const k = await api.getActionKnowledge(actionId);
+    if (!k) {
+      spinner5.stop("Action not found");
+      p4.cancel(`No action found for: ${actionId}`);
+      process.exit(1);
+    }
+    knowledge = k;
+    spinner5.stop(`${colorMethod(knowledge.method)} ${knowledge.path}`);
+  } catch (error) {
+    spinner5.stop("Failed to load action");
+    p4.cancel(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    process.exit(1);
+  }
+  let connectionKey = options.connection;
+  if (!connectionKey) {
+    connectionKey = await resolveConnection(api, knowledge.connectionPlatform);
+  }
+  const pathVarMap = parseKeyValuePairs(options.pathVar || []);
+  const pathVars = extractPathVariables(knowledge.path);
+  for (const v of pathVars) {
+    if (!pathVarMap[v]) {
+      const input = await p4.text({
+        message: `Value for path variable ${pc5.yellow(`{{${v}}}`)}:`,
+        validate: (val) => val.trim() ? void 0 : "Value is required"
+      });
+      if (p4.isCancel(input)) {
+        p4.cancel("Cancelled.");
+        process.exit(0);
+      }
+      pathVarMap[v] = input;
+    }
+  }
+  let bodyData = {};
+  if (options.data) {
+    try {
+      bodyData = JSON.parse(options.data);
+    } catch {
+      p4.cancel("Invalid JSON in --data flag.");
+      process.exit(1);
+    }
+  } else if (!["GET", "DELETE", "HEAD"].includes(knowledge.method.toUpperCase())) {
+    const input = await p4.text({
+      message: "Request body (JSON):",
+      placeholder: '{"key": "value"} or leave empty'
+    });
+    if (p4.isCancel(input)) {
+      p4.cancel("Cancelled.");
+      process.exit(0);
+    }
+    if (input.trim()) {
+      try {
+        bodyData = JSON.parse(input);
+      } catch {
+        p4.cancel("Invalid JSON.");
+        process.exit(1);
+      }
+    }
+  }
+  const queryParams = parseKeyValuePairs(options.query || []);
+  const { resolvedPath, remainingData } = resolveTemplateVariables(
+    knowledge.path,
+    bodyData,
+    pathVarMap
+  );
+  console.log();
+  console.log(pc5.bold("  Request Summary"));
+  console.log(`  ${colorMethod(knowledge.method)} ${knowledge.baseUrl}${resolvedPath}`);
+  console.log(`  Connection: ${pc5.dim(connectionKey)}`);
+  if (Object.keys(remainingData).length > 0) {
+    console.log(`  Body: ${pc5.dim(JSON.stringify(remainingData))}`);
+  }
+  if (Object.keys(queryParams).length > 0) {
+    console.log(`  Query: ${pc5.dim(JSON.stringify(queryParams))}`);
+  }
+  console.log();
+  const execSpinner = p4.spinner();
+  execSpinner.start("Executing...");
+  try {
+    const result = await api.executeAction({
+      method: knowledge.method,
+      path: resolvedPath,
+      actionId,
+      connectionKey,
+      data: Object.keys(remainingData).length > 0 ? remainingData : void 0,
+      queryParams: Object.keys(queryParams).length > 0 ? queryParams : void 0,
+      isFormData: options.formData,
+      isFormUrlEncoded: options.formUrlencoded
+    });
+    execSpinner.stop(pc5.green("Success"));
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log();
+      console.log(pc5.bold("  Response"));
+      console.log(pc5.dim("  " + "\u2500".repeat(40)));
+      console.log();
+      console.log(formatResponse(result));
+      console.log();
+    }
+  } catch (error) {
+    execSpinner.stop(pc5.red("Failed"));
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    p4.cancel(`Execution failed: ${msg}`);
+    process.exit(1);
+  }
+}
+async function resolveConnection(api, platform) {
+  const spinner5 = p4.spinner();
+  spinner5.start("Loading connections...");
+  const connections = await api.listConnections();
+  const matching = connections.filter(
+    (c) => c.platform.toLowerCase() === platform.toLowerCase()
+  );
+  spinner5.stop(`${matching.length} ${platform} connection${matching.length === 1 ? "" : "s"} found`);
+  if (matching.length === 0) {
+    p4.cancel(
+      `No ${platform} connections found.
+
+Add one with: ${pc5.cyan(`pica connection add ${platform}`)}`
+    );
+    process.exit(1);
+  }
+  if (matching.length === 1) {
+    p4.log.info(`Using connection: ${pc5.dim(matching[0].key)}`);
+    return matching[0].key;
+  }
+  const selected = await p4.select({
+    message: `Multiple ${platform} connections found. Which one?`,
+    options: matching.map((c) => ({
+      value: c.key,
+      label: `${c.key}`,
+      hint: c.state
+    }))
+  });
+  if (p4.isCancel(selected)) {
+    p4.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return selected;
+}
+function parseKeyValuePairs(pairs) {
+  const result = {};
+  for (const pair of pairs) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = pair.slice(0, eqIdx);
+    const value = pair.slice(eqIdx + 1);
+    result[key] = value;
+  }
+  return result;
+}
+function formatResponse(data, indent = 2) {
+  const prefix = " ".repeat(indent);
+  const json = JSON.stringify(data, null, 2);
+  return json.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.name("pica").description("CLI for managing Pica").version(version);
+program.command("init").description("Set up Pica and install MCP to your AI agents").option("-y, --yes", "Skip confirmations").option("-g, --global", "Install MCP globally (available in all projects)").option("-p, --project", "Install MCP for this project only (creates .mcp.json)").action(async (options) => {
+  await initCommand(options);
+});
+var connection = program.command("connection").description("Manage connections");
+connection.command("add [platform]").alias("a").description("Add a new connection").action(async (platform) => {
+  await connectionAddCommand(platform);
+});
+connection.command("list").alias("ls").description("List your connections").action(async () => {
+  await connectionListCommand();
+});
+program.command("platforms").alias("p").description("List available platforms").option("-c, --category <category>", "Filter by category").option("--json", "Output as JSON").action(async (options) => {
+  await platformsCommand(options);
+});
+program.command("add [platform]").description("Shortcut for: connection add").action(async (platform) => {
+  await connectionAddCommand(platform);
+});
+program.command("list").alias("ls").description("Shortcut for: connection list").action(async () => {
+  await connectionListCommand();
+});
+var actions = program.command("actions").alias("a").description("Discover and execute platform actions");
+actions.command("search <platform> [query]").description("Search actions on a platform").option("--json", "Output as JSON").option("-l, --limit <limit>", "Max results", "10").action(async (platform, query, options) => {
+  await actionsSearchCommand(platform, query, options);
+});
+actions.command("knowledge <actionId>").alias("k").description("Get API docs for an action").option("--json", "Output as JSON").option("--full", "Show full knowledge (no truncation)").action(async (actionId, options) => {
+  await actionsKnowledgeCommand(actionId, options);
+});
+actions.command("execute <actionId>").alias("x").description("Execute an action").option("-c, --connection <key>", "Connection key to use").option("-d, --data <json>", "Request body as JSON").option("-p, --path-var <key=value...>", "Path variable", collectValues).option("-q, --query <key=value...>", "Query parameter", collectValues).option("--form-data", "Send as multipart/form-data").option("--form-urlencoded", "Send as application/x-www-form-urlencoded").option("--json", "Output as JSON").action(async (actionId, options) => {
+  await actionsExecuteCommand(actionId, options);
+});
+program.command("search <platform> [query]").description("Shortcut for: actions search").option("--json", "Output as JSON").option("-l, --limit <limit>", "Max results", "10").action(async (platform, query, options) => {
+  await actionsSearchCommand(platform, query, options);
+});
+program.command("exec <actionId>").description("Shortcut for: actions execute").option("-c, --connection <key>", "Connection key to use").option("-d, --data <json>", "Request body as JSON").option("-p, --path-var <key=value...>", "Path variable", collectValues).option("-q, --query <key=value...>", "Query parameter", collectValues).option("--form-data", "Send as multipart/form-data").option("--form-urlencoded", "Send as application/x-www-form-urlencoded").option("--json", "Output as JSON").action(async (actionId, options) => {
+  await actionsExecuteCommand(actionId, options);
+});
+function collectValues(value, previous) {
+  return (previous || []).concat([value]);
+}
+program.parse();