@danainnovations/cortex-mcp 1.0.0

package/dist/cli.js

@@ -0,0 +1,740 @@
+#!/usr/bin/env node
+
+// bin/cli.ts
+import { Command } from "commander";
+
+// src/cli/setup.ts
+import * as readline from "readline";
+
+// src/constants.ts
+var DEFAULT_SERVER_URL = "https://cortex-bice.vercel.app";
+var PROTOCOL_VERSION = "2024-11-05";
+var AVAILABLE_MCPS = [
+  {
+    name: "github",
+    displayName: "GitHub",
+    description: "Repos, PRs, issues, branches, code review (30 tools)",
+    serverName: "cortex-github"
+  },
+  {
+    name: "vercel",
+    displayName: "Vercel",
+    description: "Deployments, projects, env vars (15 tools)",
+    serverName: "cortex-vercel"
+  },
+  {
+    name: "supabase",
+    displayName: "Supabase",
+    description: "Database, migrations, edge functions (20+ tools)",
+    serverName: "cortex-supabase"
+  },
+  {
+    name: "sonance_brand",
+    displayName: "Sonance Brand",
+    description: "Brand design system, product data",
+    serverName: "cortex-sonance-brand"
+  }
+];
+var MCP_NAMES = AVAILABLE_MCPS.map((m) => m.name);
+var DEFAULT_MCPS = [...MCP_NAMES];
+var CONFIG_DIR_NAME = ".cortex-mcp";
+var CONFIG_FILE_NAME = "config.json";
+
+// src/config/storage.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/utils/platform.ts
+import { homedir, platform } from "os";
+import { join } from "path";
+function getHomeDir() {
+  return homedir();
+}
+function getPlatform() {
+  const p = platform();
+  if (p === "darwin") return "macos";
+  if (p === "win32") return "windows";
+  return "linux";
+}
+function getClaudeDesktopConfigPath() {
+  const home = getHomeDir();
+  const p = getPlatform();
+  switch (p) {
+    case "macos":
+      return join(
+        home,
+        "Library",
+        "Application Support",
+        "Claude",
+        "claude_desktop_config.json"
+      );
+    case "windows":
+      return join(
+        process.env.APPDATA || join(home, "AppData", "Roaming"),
+        "Claude",
+        "claude_desktop_config.json"
+      );
+    case "linux":
+      return join(home, ".config", "Claude", "claude_desktop_config.json");
+  }
+}
+function getCursorConfigPath() {
+  const home = getHomeDir();
+  return join(home, ".cursor", "mcp.json");
+}
+
+// src/config/storage.ts
+function getConfigDir() {
+  return join2(getHomeDir(), CONFIG_DIR_NAME);
+}
+function getConfigPath() {
+  return join2(getConfigDir(), CONFIG_FILE_NAME);
+}
+function readConfig() {
+  const path = getConfigPath();
+  if (!existsSync(path)) return null;
+  try {
+    const raw = readFileSync(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const path = getConfigPath();
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", {
+    mode: 384
+  });
+}
+function createConfig(apiKey, mcps) {
+  return {
+    version: 1,
+    server: DEFAULT_SERVER_URL,
+    apiKey,
+    mcps,
+    configuredClients: []
+  };
+}
+
+// src/config/clients.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { execSync } from "child_process";
+function detectClients() {
+  const clients = [];
+  const desktopPath = getClaudeDesktopConfigPath();
+  const desktopDir = dirname(desktopPath);
+  clients.push({
+    type: "claude-desktop",
+    name: "Claude Desktop",
+    configPath: desktopPath,
+    detected: existsSync2(desktopDir)
+  });
+  let claudeCodeDetected = false;
+  try {
+    execSync("which claude", { stdio: "pipe" });
+    claudeCodeDetected = true;
+  } catch {
+  }
+  clients.push({
+    type: "claude-code",
+    name: "Claude Code",
+    configPath: null,
+    detected: claudeCodeDetected
+  });
+  const cursorPath = getCursorConfigPath();
+  const cursorDir = dirname(cursorPath);
+  clients.push({
+    type: "stdio",
+    name: "Cursor",
+    configPath: cursorPath,
+    detected: existsSync2(cursorDir)
+  });
+  return clients;
+}
+function buildHttpEntries(serverUrl, apiKey, mcps) {
+  const entries = {};
+  for (const mcp of AVAILABLE_MCPS) {
+    if (!mcps.includes(mcp.name)) continue;
+    entries[mcp.serverName] = {
+      url: `${serverUrl}/mcp/${mcp.name}`,
+      headers: { "x-api-key": apiKey }
+    };
+  }
+  return entries;
+}
+function configureClaudeDesktop(serverUrl, apiKey, mcps) {
+  const configPath = getClaudeDesktopConfigPath();
+  const dir = dirname(configPath);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  let config = {};
+  if (existsSync2(configPath)) {
+    try {
+      config = JSON.parse(readFileSync2(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (!config.mcpServers || typeof config.mcpServers !== "object") {
+    config.mcpServers = {};
+  }
+  const servers = config.mcpServers;
+  for (const key of Object.keys(servers)) {
+    if (key.startsWith("cortex-")) {
+      delete servers[key];
+    }
+  }
+  const entries = buildHttpEntries(serverUrl, apiKey, mcps);
+  Object.assign(servers, entries);
+  writeFileSync2(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+function configureClaudeCode(serverUrl, apiKey, mcps) {
+  for (const mcp of AVAILABLE_MCPS) {
+    if (!mcps.includes(mcp.name)) continue;
+    const url = `${serverUrl}/mcp/${mcp.name}`;
+    try {
+      execSync(`claude mcp remove ${mcp.serverName}`, { stdio: "pipe" });
+    } catch {
+    }
+    execSync(
+      `claude mcp add ${mcp.serverName} --transport http --url "${url}" --header "x-api-key: ${apiKey}"`,
+      { stdio: "pipe" }
+    );
+  }
+}
+function generateStdioSnippet(apiKey) {
+  const config = {
+    mcpServers: {
+      cortex: {
+        command: "npx",
+        args: ["-y", "@danainnovations/cortex-mcp", "serve"],
+        env: { CORTEX_API_KEY: apiKey }
+      }
+    }
+  };
+  return JSON.stringify(config, null, 2);
+}
+function resetClaudeDesktop() {
+  const configPath = getClaudeDesktopConfigPath();
+  if (!existsSync2(configPath)) return false;
+  try {
+    const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+    if (!config.mcpServers) return false;
+    const servers = config.mcpServers;
+    let removed = false;
+    for (const key of Object.keys(servers)) {
+      if (key.startsWith("cortex-") || key === "cortex") {
+        delete servers[key];
+        removed = true;
+      }
+    }
+    if (removed) {
+      writeFileSync2(configPath, JSON.stringify(config, null, 2) + "\n");
+    }
+    return removed;
+  } catch {
+    return false;
+  }
+}
+function resetClaudeCode() {
+  let removed = false;
+  for (const mcp of AVAILABLE_MCPS) {
+    try {
+      execSync(`claude mcp remove ${mcp.serverName}`, { stdio: "pipe" });
+      removed = true;
+    } catch {
+    }
+  }
+  return removed;
+}
+function configureClient(clientType, serverUrl, apiKey, mcps) {
+  switch (clientType) {
+    case "claude-desktop":
+      configureClaudeDesktop(serverUrl, apiKey, mcps);
+      return "Claude Desktop configured";
+    case "claude-code":
+      configureClaudeCode(serverUrl, apiKey, mcps);
+      return "Claude Code configured";
+    case "stdio":
+      return "Add this to your client config:\n\n" + generateStdioSnippet(apiKey);
+  }
+}
+
+// src/utils/validation.ts
+function isValidApiKey(key) {
+  return /^ctx_[a-zA-Z0-9]+_[a-zA-Z0-9]+$/.test(key.trim());
+}
+async function validateApiKeyRemote(serverUrl, apiKey) {
+  try {
+    const response = await fetch(`${serverUrl}/mcp/github`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "mcp-protocol-version": "2024-11-05"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "cortex-mcp-setup", version: "1.0.0" }
+        },
+        id: "validate"
+      })
+    });
+    if (response.status === 401 || response.status === 403) {
+      return { valid: false, error: "Invalid or expired API key" };
+    }
+    if (!response.ok) {
+      return { valid: false, error: `Server returned ${response.status}` };
+    }
+    return { valid: true };
+  } catch {
+    return { valid: false, error: "Could not reach the Cortex server" };
+  }
+}
+
+// src/cli/setup.ts
+var rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stderr
+});
+function ask(question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+function log(msg) {
+  process.stderr.write(msg + "\n");
+}
+async function runSetup() {
+  log("");
+  log("  Cortex MCP Setup");
+  log("  Connect your AI tools to GitHub, Vercel, Supabase & Sonance Brand");
+  log("");
+  log("  Step 1: API Key");
+  log("  Get one at https://aidentity.app/settings/keys");
+  log("");
+  let apiKey = "";
+  while (true) {
+    apiKey = await ask("  Enter your Cortex API key: ");
+    if (!isValidApiKey(apiKey)) {
+      log(
+        "  That doesn't look like a Cortex API key. It should start with 'ctx_'."
+      );
+      continue;
+    }
+    log("  Validating...");
+    const { valid, error } = await validateApiKeyRemote(
+      DEFAULT_SERVER_URL,
+      apiKey
+    );
+    if (!valid) {
+      log(`  Key validation failed: ${error}`);
+      log("  Please try again.\n");
+      continue;
+    }
+    log("  Key validated successfully.\n");
+    break;
+  }
+  log("  Step 2: Select MCPs");
+  log("  Available MCPs (all enabled by default):\n");
+  for (const mcp of AVAILABLE_MCPS) {
+    log(`    - ${mcp.displayName.padEnd(15)} ${mcp.description}`);
+  }
+  log("");
+  const mcpInput = await ask(
+    `  MCPs to enable (comma-separated, or press Enter for all): `
+  );
+  let selectedMcps;
+  if (!mcpInput) {
+    selectedMcps = [...DEFAULT_MCPS];
+    log("  All MCPs enabled.\n");
+  } else {
+    selectedMcps = mcpInput.split(",").map((s) => s.trim().toLowerCase()).filter(
+      (s) => AVAILABLE_MCPS.some(
+        (m) => m.name === s || m.displayName.toLowerCase() === s
+      )
+    );
+    selectedMcps = selectedMcps.map((s) => {
+      const found = AVAILABLE_MCPS.find(
+        (m) => m.displayName.toLowerCase() === s
+      );
+      return found ? found.name : s;
+    });
+    if (selectedMcps.length === 0) {
+      selectedMcps = [...DEFAULT_MCPS];
+      log("  No valid MCPs recognized. Enabling all.\n");
+    } else {
+      log(`  Enabled: ${selectedMcps.join(", ")}
+`);
+    }
+  }
+  log("  Step 3: Configure AI Clients\n");
+  const clients = detectClients();
+  const configuredClients = [];
+  for (const client of clients) {
+    if (!client.detected) {
+      log(`    ${client.name}: not detected, skipping`);
+      continue;
+    }
+    const answer = await ask(`    Configure ${client.name}? (Y/n): `);
+    if (answer.toLowerCase() === "n") {
+      log(`    Skipping ${client.name}`);
+      continue;
+    }
+    try {
+      if (client.type === "claude-desktop") {
+        configureClaudeDesktop(DEFAULT_SERVER_URL, apiKey, selectedMcps);
+        log(`    ${client.name}: configured`);
+        configuredClients.push(client.type);
+      } else if (client.type === "claude-code") {
+        configureClaudeCode(DEFAULT_SERVER_URL, apiKey, selectedMcps);
+        log(`    ${client.name}: configured`);
+        configuredClients.push(client.type);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log(`    ${client.name}: failed \u2014 ${msg}`);
+    }
+  }
+  log("");
+  const stdioAnswer = await ask(
+    "  Do you also need a config snippet for OpenClaw or other stdio clients? (y/N): "
+  );
+  if (stdioAnswer.toLowerCase() === "y") {
+    log("\n  Add this to your client's MCP config:\n");
+    log(generateStdioSnippet(apiKey));
+    log("");
+    configuredClients.push("stdio");
+  }
+  const config = createConfig(apiKey, selectedMcps);
+  config.configuredClients = configuredClients;
+  writeConfig(config);
+  log("");
+  log("  Setup complete! Restart your AI clients to see the new tools.");
+  log(`  Config saved to ~/.cortex-mcp/config.json`);
+  log("");
+  rl.close();
+}
+
+// src/cli/configure.ts
+var VALID_CLIENTS = {
+  "claude-desktop": "claude-desktop",
+  "claude-code": "claude-code",
+  stdio: "stdio"
+};
+async function runConfigure(options) {
+  const { key, client } = options;
+  if (!isValidApiKey(key)) {
+    console.error(
+      "Invalid API key format. Must start with 'ctx_'. Get one at https://aidentity.app/settings/keys"
+    );
+    process.exit(1);
+  }
+  const clientType = VALID_CLIENTS[client];
+  if (!clientType) {
+    console.error(
+      `Unknown client: ${client}. Valid options: ${Object.keys(VALID_CLIENTS).join(", ")}`
+    );
+    process.exit(1);
+  }
+  let selectedMcps;
+  if (options.mcps) {
+    selectedMcps = options.mcps.split(",").map((s) => s.trim()).filter((s) => MCP_NAMES.includes(s));
+    if (selectedMcps.length === 0) {
+      console.error(
+        `No valid MCPs. Available: ${MCP_NAMES.join(", ")}`
+      );
+      process.exit(1);
+    }
+  } else {
+    selectedMcps = [...DEFAULT_MCPS];
+  }
+  try {
+    const result = configureClient(
+      clientType,
+      DEFAULT_SERVER_URL,
+      key,
+      selectedMcps
+    );
+    console.log(result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to configure ${client}: ${msg}`);
+    process.exit(1);
+  }
+  const config = createConfig(key, selectedMcps);
+  config.configuredClients = [clientType];
+  writeConfig(config);
+  console.log(`Config saved to ~/.cortex-mcp/config.json`);
+}
+
+// src/proxy/stdio-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/proxy/http-client.ts
+var CortexHttpClient = class {
+  constructor(serverUrl, apiKey, endpoint = "cortex") {
+    this.serverUrl = serverUrl;
+    this.apiKey = apiKey;
+    this.endpoint = endpoint;
+  }
+  sessionId = null;
+  requestId = 0;
+  /** Send an initialize request to establish a session */
+  async initialize() {
+    const response = await this.sendRequest("initialize", {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: { name: "cortex-mcp-proxy", version: "1.0.0" }
+    });
+    await this.sendNotification("notifications/initialized", {});
+    return response;
+  }
+  /** List available tools */
+  async listTools() {
+    return this.sendRequest("tools/list", {});
+  }
+  /** Call a tool */
+  async callTool(name, args) {
+    return this.sendRequest("tools/call", { name, arguments: args });
+  }
+  /** Send a JSON-RPC request and return the response */
+  async sendRequest(method, params) {
+    const id = String(++this.requestId);
+    const body = { jsonrpc: "2.0", method, params, id };
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey,
+      "mcp-protocol-version": PROTOCOL_VERSION
+    };
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    const url = `${this.serverUrl}/mcp/${this.endpoint}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    const newSessionId = response.headers.get("mcp-session-id");
+    if (newSessionId) {
+      this.sessionId = newSessionId;
+    }
+    if (!response.ok) {
+      const text = await response.text();
+      return {
+        jsonrpc: "2.0",
+        error: {
+          code: -32e3,
+          message: this.humanReadableError(response.status, text)
+        },
+        id
+      };
+    }
+    return await response.json();
+  }
+  /** Send a JSON-RPC notification (no response expected) */
+  async sendNotification(method, params) {
+    const body = { jsonrpc: "2.0", method, params };
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey,
+      "mcp-protocol-version": PROTOCOL_VERSION
+    };
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    const url = `${this.serverUrl}/mcp/${this.endpoint}`;
+    try {
+      await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+    } catch {
+    }
+  }
+  /** Convert HTTP status codes to user-friendly messages */
+  humanReadableError(status, body) {
+    switch (status) {
+      case 401:
+        return "Invalid API key. Check your key at https://aidentity.app/settings/keys";
+      case 403:
+        return "API key lacks MCP permissions. Create a new key with MCP access.";
+      case 404:
+        return "MCP endpoint not found. The server may be misconfigured.";
+      case 503:
+        return "MCP protocol is disabled on the server.";
+      default:
+        return `Server error (${status}): ${body.slice(0, 200)}`;
+    }
+  }
+};
+
+// src/proxy/stdio-server.ts
+async function startStdioServer(options) {
+  const { serverUrl, apiKey, endpoint = "cortex" } = options;
+  const cortex = new CortexHttpClient(serverUrl, apiKey, endpoint);
+  const server = new Server(
+    { name: "cortex-mcp", version: "1.0.0" },
+    { capabilities: { tools: { listChanged: false } } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const response = await cortex.listTools();
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    const result = response.result;
+    return { tools: result.tools || [] };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const response = await cortex.callTool(name, args ?? {});
+    if (response.error) {
+      return {
+        content: [{ type: "text", text: response.error.message }],
+        isError: true
+      };
+    }
+    const result = response.result;
+    return result;
+  });
+  await cortex.initialize();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/cli/serve.ts
+async function runServe() {
+  let apiKey = process.env.CORTEX_API_KEY;
+  let serverUrl = DEFAULT_SERVER_URL;
+  if (!apiKey) {
+    const config = readConfig();
+    if (config) {
+      apiKey = config.apiKey;
+      serverUrl = config.server || DEFAULT_SERVER_URL;
+    }
+  }
+  if (!apiKey) {
+    process.stderr.write(
+      "No API key found. Set CORTEX_API_KEY env var or run: npx @danainnovations/cortex-mcp setup\n"
+    );
+    process.exit(1);
+  }
+  await startStdioServer({ serverUrl, apiKey });
+}
+
+// src/cli/status.ts
+function runStatus() {
+  const config = readConfig();
+  if (!config) {
+    console.log("No configuration found. Run: npx @danainnovations/cortex-mcp setup");
+    return;
+  }
+  const maskedKey = config.apiKey.slice(0, 8) + "****" + config.apiKey.slice(-4);
+  console.log("");
+  console.log("  Cortex MCP Status");
+  console.log("  -----------------");
+  console.log(`  Config:  ${getConfigPath()}`);
+  console.log(`  Server:  ${config.server}`);
+  console.log(`  API Key: ${maskedKey}`);
+  console.log("");
+  console.log("  Enabled MCPs:");
+  for (const mcpName of config.mcps) {
+    const mcp = AVAILABLE_MCPS.find((m) => m.name === mcpName);
+    const display = mcp ? mcp.displayName : mcpName;
+    console.log(`    ${display.padEnd(15)} ${config.server}/mcp/${mcpName}`);
+  }
+  console.log("");
+  console.log("  Configured Clients:");
+  if (config.configuredClients.length === 0) {
+    console.log("    (none)");
+  } else {
+    for (const client of config.configuredClients) {
+      console.log(`    ${client}`);
+    }
+  }
+  console.log("");
+}
+
+// src/cli/reset.ts
+import { existsSync as existsSync3, unlinkSync, rmdirSync } from "fs";
+function runReset() {
+  console.log("");
+  console.log("  Resetting Cortex MCP configuration...");
+  const desktopReset = resetClaudeDesktop();
+  console.log(
+    `  Claude Desktop: ${desktopReset ? "entries removed" : "no entries found"}`
+  );
+  const codeReset = resetClaudeCode();
+  console.log(
+    `  Claude Code:    ${codeReset ? "entries removed" : "no entries found"}`
+  );
+  const configPath = getConfigPath();
+  if (existsSync3(configPath)) {
+    unlinkSync(configPath);
+    console.log(`  Config file:    removed`);
+  }
+  const configDir = getConfigDir();
+  try {
+    rmdirSync(configDir);
+  } catch {
+  }
+  console.log("");
+  console.log("  Done. Restart your AI clients to apply changes.");
+  console.log("");
+}
+
+// bin/cli.ts
+var program = new Command();
+program.name("cortex-mcp").description(
+  "Connect your AI tools to GitHub, Vercel, Supabase & Sonance Brand via Cortex"
+).version("1.0.0");
+program.command("setup").description("Interactive setup wizard \u2014 configure API key, MCPs, and clients").action(async () => {
+  try {
+    await runSetup();
+  } catch (err) {
+    if (err.code === "ERR_USE_AFTER_CLOSE") {
+      process.exit(0);
+    }
+    console.error("Setup failed:", err);
+    process.exit(1);
+  }
+});
+program.command("configure").description("Non-interactive configuration for a specific client").requiredOption("--key <key>", "Cortex API key (ctx_...)").requiredOption(
+  "--client <client>",
+  "Client to configure (claude-desktop, claude-code, stdio)"
+).option(
+  "--mcps <mcps>",
+  "Comma-separated MCP names (default: all)"
+).action(async (options) => {
+  await runConfigure(options);
+});
+program.command("serve").description(
+  "Start stdio MCP proxy server (for OpenClaw and other stdio clients)"
+).action(async () => {
+  await runServe();
+});
+program.command("status").description("Show current Cortex MCP configuration").action(() => {
+  runStatus();
+});
+program.command("reset").description("Remove all Cortex MCP entries from AI clients").action(() => {
+  runReset();
+});
+program.parse();
+//# sourceMappingURL=cli.js.map