@sarjallab09/figma-intelligence 1.0.0

package/bin/cli.js

@@ -0,0 +1,859 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * figma-intelligence CLI
+ *
+ * Usage:
+ *   npx figma-intelligence start    # Start the bridge relay server
+ *   npx figma-intelligence stop     # Stop the relay server
+ *   npx figma-intelligence status   # Show relay + CLI auth status
+ *   npx figma-intelligence doctor   # Diagnose common issues
+ *   npx figma-intelligence setup    # Full interactive setup (install deps, register MCP, start relay)
+ */
+
+const { spawn, spawnSync, execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const readline = require("readline");
+
+// ── Paths ───────────────────────────────────────────────────────────────────
+const ROOT_DIR = path.resolve(__dirname, "..");
+const RELAY_SCRIPT = path.join(ROOT_DIR, "figma-bridge-plugin", "bridge-relay.js");
+const MCP_BUILD = path.join(ROOT_DIR, "figma-intelligence-layer", "dist", "index.js");
+const MCP_SRC = path.join(ROOT_DIR, "figma-intelligence-layer");
+const BRIDGE_DIR = path.join(ROOT_DIR, "figma-bridge-plugin");
+const DESIGN_BRIDGE_DIR = path.join(ROOT_DIR, "design-bridge");
+const DATA_DIR = path.join(os.homedir(), ".figma-intelligence");
+const PID_FILE = path.join(DATA_DIR, "relay.pid");
+const LOG_FILE = path.join(DATA_DIR, "relay.log");
+const PORT = parseInt(process.env.BRIDGE_PORT || "9001", 10);
+
+const PLIST_LABEL = "com.figma-intelligence.bridge-relay";
+const PLIST_DIR = path.join(os.homedir(), "Library", "LaunchAgents");
+const PLIST_PATH = path.join(PLIST_DIR, `${PLIST_LABEL}.plist`);
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function log(msg) { console.log(msg); }
+function success(msg) { console.log(`  \u2714 ${msg}`); }
+function warn(msg) { console.log(`  \u26A0 ${msg}`); }
+function fail(msg) { console.log(`  \u274C ${msg}`); }
+function info(msg) { console.log(`  \u2139 ${msg}`); }
+
+function run(cmd, args, opts = {}) {
+  const r = spawnSync(cmd, args, { encoding: "utf8", shell: true, ...opts });
+  return { ok: r.status === 0, stdout: (r.stdout || "").trim(), stderr: (r.stderr || "").trim() };
+}
+
+function which(cmd) {
+  const r = run("which", [cmd]);
+  return r.ok ? r.stdout : null;
+}
+
+function extractEmail(text) {
+  const m = text.match(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/);
+  return m ? m[0] : "";
+}
+
+function maskToken(t) {
+  if (!t || t.length < 8) return "(not set)";
+  return `${t.slice(0, 4)}....${t.slice(-4)}`;
+}
+
+function ensureDataDir() {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function isPortInUse(port) {
+  const r = run("lsof", ["-n", "-P", `-iTCP:${port}`, "-sTCP:LISTEN"]);
+  return r.ok && r.stdout.length > 0;
+}
+
+function getRelayPid() {
+  if (!fs.existsSync(PID_FILE)) return null;
+  const pid = parseInt(fs.readFileSync(PID_FILE, "utf8").trim(), 10);
+  if (isNaN(pid)) return null;
+  try { process.kill(pid, 0); return pid; } catch { return null; }
+}
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+  });
+}
+
+// ── CLI Detection ───────────────────────────────────────────────────────────
+
+function detectCLIs() {
+  const clis = {};
+
+  // Claude
+  const claudeBin = which("claude");
+  if (claudeBin) {
+    const authResult = run(claudeBin, ["auth", "status"]);
+    const output = authResult.stdout + " " + authResult.stderr;
+    clis.claude = {
+      bin: claudeBin,
+      loggedIn: authResult.ok,
+      email: extractEmail(output),
+    };
+  }
+
+  // Codex
+  let codexBin = which("codex");
+  if (!codexBin && fs.existsSync("/Applications/Codex.app/Contents/Resources/codex")) {
+    codexBin = "/Applications/Codex.app/Contents/Resources/codex";
+  }
+  if (codexBin) {
+    const authResult = run(codexBin, ["login", "status"]);
+    const output = authResult.stdout + " " + authResult.stderr;
+    clis.codex = {
+      bin: codexBin,
+      loggedIn: authResult.ok,
+      email: extractEmail(output),
+    };
+  }
+
+  // Gemini
+  const geminiBin = which("gemini");
+  if (geminiBin) {
+    let loggedIn = false;
+    let email = "";
+
+    // Check macOS Keychain first
+    if (process.platform === "darwin") {
+      const kcResult = run("security", ["find-generic-password", "-s", "gemini-cli-oauth", "-a", "main-account"]);
+      if (kcResult.ok) {
+        loggedIn = true;
+        try {
+          const pwResult = run("security", ["find-generic-password", "-s", "gemini-cli-oauth", "-a", "main-account", "-w"]);
+          if (pwResult.ok && pwResult.stdout) {
+            try {
+              const parsed = JSON.parse(Buffer.from(pwResult.stdout, "base64").toString("utf8"));
+              email = parsed.email || parsed.client_email || "";
+            } catch {
+              try { const p = JSON.parse(pwResult.stdout); email = p.email || p.client_email || ""; } catch {}
+            }
+          }
+        } catch {}
+      }
+    }
+
+    // Fallback: check credential files
+    if (!loggedIn) {
+      const credPaths = [
+        path.join(os.homedir(), ".gemini", "oauth_creds.json"),
+        path.join(os.homedir(), ".gemini", "credentials.json"),
+        path.join(os.homedir(), ".gemini", "auth.json"),
+      ];
+      for (const cp of credPaths) {
+        if (fs.existsSync(cp)) {
+          loggedIn = true;
+          try {
+            const d = JSON.parse(fs.readFileSync(cp, "utf8"));
+            email = d.email || d.client_email || (d.user && d.user.email) || "";
+          } catch {}
+          break;
+        }
+      }
+    }
+
+    clis.gemini = { bin: geminiBin, loggedIn, email };
+  }
+
+  return clis;
+}
+
+// ── MCP Registration ────────────────────────────────────────────────────────
+
+function registerMcpWithClaude(claudeBin, figmaToken, envExtras = {}) {
+  // Remove stale first
+  run(claudeBin, ["mcp", "remove", "figma-intelligence-layer"]);
+  run(claudeBin, ["mcp", "remove", "design-bridge"]);
+
+  const envArgs = [
+    "-e", `FIGMA_ACCESS_TOKEN=${figmaToken}`,
+    "-e", "FIGMA_BRIDGE_PORT=9001",
+    "-e", "ENABLE_DECISION_LOG=true",
+  ];
+  if (envExtras.UNSPLASH_ACCESS_KEY) envArgs.push("-e", `UNSPLASH_ACCESS_KEY=${envExtras.UNSPLASH_ACCESS_KEY}`);
+  if (envExtras.PEXELS_API_KEY) envArgs.push("-e", `PEXELS_API_KEY=${envExtras.PEXELS_API_KEY}`);
+
+  const r = run(claudeBin, ["mcp", "add", "-s", "user", ...envArgs, "figma-intelligence-layer", "--", "node", MCP_BUILD]);
+  return r.ok;
+}
+
+function registerMcpWithCodex(codexBin, figmaToken) {
+  run(codexBin, ["mcp", "remove", "figma-intelligence-layer"]);
+  const r = run(codexBin, [
+    "mcp", "add", "figma-intelligence-layer",
+    "--env", `FIGMA_ACCESS_TOKEN=${figmaToken}`,
+    "--env", "FIGMA_BRIDGE_PORT=9001",
+    "--env", "ENABLE_DECISION_LOG=true",
+    "--", "node", MCP_BUILD,
+  ]);
+  return r.ok;
+}
+
+function registerMcpWithGemini(figmaToken) {
+  const settingsDir = path.join(os.homedir(), ".gemini");
+  const settingsPath = path.join(settingsDir, "settings.json");
+  fs.mkdirSync(settingsDir, { recursive: true });
+
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    try { settings = JSON.parse(fs.readFileSync(settingsPath, "utf8")); } catch {}
+  }
+  if (!settings.mcpServers) settings.mcpServers = {};
+
+  settings.mcpServers["figma-intelligence-layer"] = {
+    command: "node",
+    args: [MCP_BUILD],
+    env: {
+      FIGMA_ACCESS_TOKEN: figmaToken,
+      FIGMA_BRIDGE_PORT: "9001",
+      ENABLE_DECISION_LOG: "true",
+    },
+  };
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  return true;
+}
+
+function writeClaudePermissions() {
+  const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    try { settings = JSON.parse(fs.readFileSync(settingsPath, "utf8")); } catch {}
+  }
+  if (!settings.permissions) settings.permissions = {};
+  if (!Array.isArray(settings.permissions.allow)) settings.permissions.allow = [];
+  const perms = ["mcp__figma-intelligence-layer__*", "mcp__design-bridge__*"];
+  for (const p of perms) {
+    if (!settings.permissions.allow.includes(p)) settings.permissions.allow.push(p);
+  }
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+
+// ── Commands ────────────────────────────────────────────────────────────────
+
+async function cmdStart() {
+  ensureDataDir();
+
+  // Check if already running
+  const existingPid = getRelayPid();
+  if (existingPid) {
+    success(`Relay already running (PID: ${existingPid})`);
+    log(`  WebSocket: ws://localhost:${PORT}`);
+    log(`  Logs: ${LOG_FILE}`);
+    return;
+  }
+
+  if (isPortInUse(PORT)) {
+    warn(`Port ${PORT} is already in use by another process.`);
+    info(`Run 'npx figma-intelligence stop' first or use BRIDGE_PORT=9002 npx figma-intelligence start`);
+    return;
+  }
+
+  // Check prerequisites
+  if (!fs.existsSync(RELAY_SCRIPT)) {
+    fail("Bridge relay not found. Run 'npx figma-intelligence setup' first.");
+    return;
+  }
+
+  // Detect CLIs for PATH
+  const clis = detectCLIs();
+  const pathDirs = new Set(["/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]);
+  if (clis.claude) pathDirs.add(path.dirname(clis.claude.bin));
+  if (clis.codex) pathDirs.add(path.dirname(clis.codex.bin));
+  if (clis.gemini) pathDirs.add(path.dirname(clis.gemini.bin));
+
+  const env = {
+    ...process.env,
+    HOME: os.homedir(),
+    PATH: [...pathDirs].join(":") + ":" + (process.env.PATH || ""),
+  };
+  if (clis.claude) env.CLAUDE_BIN_PATH = clis.claude.bin;
+  if (clis.codex) env.CODEX_BIN_PATH = clis.codex.bin;
+  if (clis.gemini) env.GEMINI_BIN_PATH = clis.gemini.bin;
+
+  log("");
+  log("Starting Figma Intelligence relay server...");
+
+  // Start relay as detached background process
+  const logStream = fs.openSync(LOG_FILE, "a");
+  const child = spawn("node", [RELAY_SCRIPT], {
+    cwd: BRIDGE_DIR,
+    env,
+    detached: true,
+    stdio: ["ignore", logStream, logStream],
+  });
+
+  child.unref();
+  fs.writeFileSync(PID_FILE, String(child.pid));
+
+  // Wait briefly and verify
+  await new Promise((r) => setTimeout(r, 2000));
+
+  if (getRelayPid()) {
+    success(`Relay started (PID: ${child.pid})`);
+    log(`  WebSocket: ws://localhost:${PORT}`);
+    log(`  Logs: ${LOG_FILE}`);
+    log("");
+
+    // Show CLI status
+    const anyLoggedIn = Object.values(clis).some((c) => c.loggedIn);
+    if (anyLoggedIn) {
+      log("  Available providers:");
+      if (clis.claude?.loggedIn) success(`Claude${clis.claude.email ? ` (${clis.claude.email})` : ""}`);
+      if (clis.codex?.loggedIn) success(`OpenAI Codex${clis.codex.email ? ` (${clis.codex.email})` : ""}`);
+      if (clis.gemini?.loggedIn) success(`Gemini${clis.gemini.email ? ` (${clis.gemini.email})` : ""}`);
+    } else {
+      warn("No AI providers are logged in. Run one of:");
+      info("  claude login");
+      info("  codex login");
+      info("  gemini");
+    }
+
+    log("");
+    log("  Now open your Figma plugin - it will auto-connect.");
+  } else {
+    fail("Relay failed to start. Check logs:");
+    log(`  ${LOG_FILE}`);
+  }
+}
+
+function cmdStop() {
+  let stopped = false;
+
+  // Stop via PID file
+  const pid = getRelayPid();
+  if (pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+      stopped = true;
+      success(`Stopped relay (PID: ${pid})`);
+    } catch (e) {
+      warn(`Could not stop PID ${pid}: ${e.message}`);
+    }
+    try { fs.unlinkSync(PID_FILE); } catch {}
+  }
+
+  // Also try launchctl on macOS
+  if (process.platform === "darwin" && fs.existsSync(PLIST_PATH)) {
+    run("launchctl", ["unload", PLIST_PATH]);
+    info("Unloaded launchd service");
+    stopped = true;
+  }
+
+  // Kill any remaining relay processes
+  const r = run("pkill", ["-f", "bridge-relay.js"]);
+  if (r.ok) stopped = true;
+
+  if (stopped) {
+    success("Relay stopped");
+  } else {
+    info("No relay process found");
+  }
+}
+
+function cmdStatus() {
+  log("");
+  log("Figma Intelligence Status");
+  log("=".repeat(50));
+  log("");
+
+  // Relay status
+  const pid = getRelayPid();
+  const portActive = isPortInUse(PORT);
+
+  if (pid) {
+    success(`Relay: RUNNING (PID: ${pid}, port ${PORT})`);
+  } else if (portActive) {
+    warn(`Relay: Port ${PORT} in use (unknown process)`);
+  } else {
+    fail(`Relay: NOT RUNNING`);
+  }
+
+  // MCP build
+  if (fs.existsSync(MCP_BUILD)) {
+    success("MCP server: BUILT");
+  } else {
+    fail("MCP server: NOT BUILT (run 'npx figma-intelligence setup')");
+  }
+
+  log("");
+
+  // CLI status
+  const clis = detectCLIs();
+  log("AI Providers:");
+
+  if (clis.claude) {
+    if (clis.claude.loggedIn) {
+      success(`Claude: logged in${clis.claude.email ? ` as ${clis.claude.email}` : ""}`);
+    } else {
+      warn("Claude: installed but not logged in (run 'claude login')");
+    }
+  } else {
+    info("Claude: not installed (https://claude.ai/download)");
+  }
+
+  if (clis.codex) {
+    if (clis.codex.loggedIn) {
+      success(`OpenAI Codex: logged in${clis.codex.email ? ` as ${clis.codex.email}` : ""}`);
+    } else {
+      warn("OpenAI Codex: installed but not logged in (run 'codex login')");
+    }
+  } else {
+    info("OpenAI Codex: not installed (npm i -g @openai/codex)");
+  }
+
+  if (clis.gemini) {
+    if (clis.gemini.loggedIn) {
+      success(`Gemini: logged in${clis.gemini.email ? ` as ${clis.gemini.email}` : ""}`);
+    } else {
+      warn("Gemini: installed but not logged in (run 'gemini')");
+    }
+  } else {
+    info("Gemini: not installed (npm i -g @google/gemini-cli)");
+  }
+
+  // Figma token
+  log("");
+  const claudeSettings = path.join(os.homedir(), ".claude", "settings.json");
+  if (fs.existsSync(claudeSettings)) {
+    try {
+      const s = JSON.parse(fs.readFileSync(claudeSettings, "utf8"));
+      const token = s?.mcpServers?.["figma-intelligence-layer"]?.env?.FIGMA_ACCESS_TOKEN || "";
+      if (token && token !== "YOUR_FIGMA_TOKEN_HERE") {
+        success(`Figma token: ${maskToken(token)}`);
+      } else {
+        warn("Figma token: not set");
+      }
+    } catch {
+      warn("Could not read Claude settings");
+    }
+  }
+
+  log("");
+}
+
+function cmdDoctor() {
+  log("");
+  log("Figma Intelligence Doctor");
+  log("=".repeat(50));
+  log("");
+
+  let issues = 0;
+
+  // 1. Node.js version
+  const nodeVer = process.version;
+  const major = parseInt(nodeVer.slice(1), 10);
+  if (major >= 18) {
+    success(`Node.js ${nodeVer}`);
+  } else {
+    fail(`Node.js ${nodeVer} - requires >= 18`);
+    issues++;
+  }
+
+  // 2. Dependencies installed
+  const bridgeDeps = path.join(BRIDGE_DIR, "node_modules");
+  const mcpDeps = path.join(MCP_SRC, "node_modules");
+  if (fs.existsSync(bridgeDeps)) {
+    success("Bridge relay dependencies installed");
+  } else {
+    fail("Bridge relay dependencies missing (run 'npx figma-intelligence setup')");
+    issues++;
+  }
+  if (fs.existsSync(mcpDeps)) {
+    success("MCP server dependencies installed");
+  } else {
+    fail("MCP server dependencies missing (run 'npx figma-intelligence setup')");
+    issues++;
+  }
+
+  // 3. MCP build
+  if (fs.existsSync(MCP_BUILD)) {
+    success("MCP server built");
+  } else {
+    fail("MCP server not built");
+    issues++;
+  }
+
+  // 4. Relay running
+  const pid = getRelayPid();
+  if (pid) {
+    success(`Relay running (PID: ${pid})`);
+  } else if (isPortInUse(PORT)) {
+    warn(`Port ${PORT} in use but not by our relay`);
+    issues++;
+  } else {
+    fail("Relay not running (run 'npx figma-intelligence start')");
+    issues++;
+  }
+
+  // 5. CLIs
+  const clis = detectCLIs();
+  const anyInstalled = Object.keys(clis).length > 0;
+  const anyLoggedIn = Object.values(clis).some((c) => c.loggedIn);
+  if (!anyInstalled) {
+    fail("No AI CLI installed. Install at least one: claude, codex, or gemini");
+    issues++;
+  } else if (!anyLoggedIn) {
+    fail("No AI CLI is logged in. Log in to at least one provider");
+    issues++;
+  } else {
+    success("AI provider(s) authenticated");
+  }
+
+  // 6. Sharp module
+  try {
+    require(path.join(MCP_SRC, "node_modules", "sharp"));
+    success("Sharp image module OK");
+  } catch {
+    warn("Sharp module not loadable (some vision tools may not work)");
+  }
+
+  // 7. MCP server handshake test
+  if (fs.existsSync(MCP_BUILD)) {
+    log("\n  Testing MCP server handshake...");
+    const testResult = run("node", ["-e", `
+      const { spawn } = require('child_process');
+      const p = spawn('node', ['${MCP_BUILD}'], {
+        env: { ...process.env, FIGMA_ACCESS_TOKEN: 'test', FIGMA_BRIDGE_PORT: '0' },
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+      const msg = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'doctor', version: '1.0.0' } } });
+      let responded = false;
+      p.stdout.on('data', () => { if (!responded) { responded = true; console.log('ok'); p.kill(); } });
+      p.stdin.write(msg + '\\n');
+      setTimeout(() => { if (!responded) console.log('timeout'); p.kill(); process.exit(0); }, 5000);
+    `], { timeout: 8000 });
+
+    if (testResult.stdout.includes("ok")) {
+      success("MCP server responds to handshake");
+    } else {
+      fail("MCP server did not respond");
+      issues++;
+    }
+  }
+
+  log("");
+  if (issues === 0) {
+    log("  All checks passed! Your setup is healthy.");
+  } else {
+    log(`  ${issues} issue(s) found. Fix them and run doctor again.`);
+  }
+  log("");
+}
+
+async function cmdSetup() {
+  log("");
+  log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+  log("\u2502        Figma Intelligence \u2014 Setup                    \u2502");
+  log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+  log("");
+
+  ensureDataDir();
+
+  // Step 1: Check Node.js
+  const major = parseInt(process.version.slice(1), 10);
+  if (major < 18) {
+    fail(`Node.js ${process.version} is too old. Install Node.js 18+ from https://nodejs.org`);
+    process.exit(1);
+  }
+  success(`Node.js ${process.version}`);
+
+  // Step 2: Detect and check CLIs
+  log("");
+  log("Checking AI provider authentication...");
+  const clis = detectCLIs();
+
+  if (clis.claude) {
+    if (clis.claude.loggedIn) {
+      success(`Claude logged in${clis.claude.email ? ` as ${clis.claude.email}` : ""}`);
+    } else {
+      warn("Claude CLI installed but not logged in.");
+      info("Run 'claude login' to authenticate");
+    }
+  } else {
+    info("Claude CLI not found. Install from: https://claude.ai/download");
+  }
+
+  if (clis.codex) {
+    if (clis.codex.loggedIn) {
+      success(`Codex logged in${clis.codex.email ? ` as ${clis.codex.email}` : ""}`);
+    } else {
+      warn("Codex CLI installed but not logged in.");
+      info("Run 'codex login' to authenticate");
+    }
+  } else {
+    info("OpenAI Codex not found. Install with: npm i -g @openai/codex");
+  }
+
+  if (clis.gemini) {
+    if (clis.gemini.loggedIn) {
+      success(`Gemini logged in${clis.gemini.email ? ` as ${clis.gemini.email}` : ""}`);
+    } else {
+      warn("Gemini CLI installed but not logged in.");
+      info("Run 'gemini' to authenticate via Google");
+    }
+  } else {
+    info("Gemini CLI not found. Install with: npm i -g @google/gemini-cli");
+  }
+
+  const anyLoggedIn = Object.values(clis).some((c) => c.loggedIn);
+  if (!Object.keys(clis).length) {
+    log("");
+    fail("No supported AI CLI found. Install at least one:");
+    info("  Claude:       https://claude.ai/download");
+    info("  OpenAI Codex: npm i -g @openai/codex");
+    info("  Gemini CLI:   npm i -g @google/gemini-cli");
+    process.exit(1);
+  }
+
+  if (!anyLoggedIn) {
+    log("");
+    fail("No AI provider is logged in. Log in to at least one:");
+    if (clis.claude) info("  claude login");
+    if (clis.codex) info("  codex login");
+    if (clis.gemini) info("  gemini");
+    process.exit(1);
+  }
+
+  // Step 3: Install dependencies
+  log("");
+  log("Installing dependencies...");
+
+  const packages = [
+    { name: "Bridge relay", dir: BRIDGE_DIR },
+    { name: "MCP server", dir: MCP_SRC },
+  ];
+  if (fs.existsSync(DESIGN_BRIDGE_DIR)) {
+    packages.push({ name: "Design bridge", dir: DESIGN_BRIDGE_DIR });
+  }
+
+  for (const pkg of packages) {
+    log(`  Installing ${pkg.name}...`);
+    const r = run("npm", ["install"], { cwd: pkg.dir });
+    if (r.ok) {
+      success(`${pkg.name} dependencies installed`);
+    } else {
+      fail(`${pkg.name} install failed: ${r.stderr}`);
+      process.exit(1);
+    }
+  }
+
+  // Step 4: Build MCP server
+  log("");
+  log("Building MCP server...");
+  const buildResult = run("npm", ["run", "build"], { cwd: MCP_SRC });
+  if (buildResult.ok) {
+    success("MCP server built");
+  } else {
+    fail(`Build failed: ${buildResult.stderr}`);
+    process.exit(1);
+  }
+
+  // Step 5: Figma Access Token
+  log("");
+  log("Figma Personal Access Token");
+  info("Required to read your Figma files.");
+  info("Get one: Figma Desktop > Account Settings > Security > Personal access tokens");
+  log("");
+
+  let existingToken = "";
+  const claudeSettingsPath = path.join(os.homedir(), ".claude", "settings.json");
+  if (fs.existsSync(claudeSettingsPath)) {
+    try {
+      const s = JSON.parse(fs.readFileSync(claudeSettingsPath, "utf8"));
+      const t = s?.mcpServers?.["figma-intelligence-layer"]?.env?.FIGMA_ACCESS_TOKEN || "";
+      if (t && t !== "YOUR_FIGMA_TOKEN_HERE") existingToken = t;
+    } catch {}
+  }
+
+  let figmaToken;
+  if (existingToken) {
+    log(`  Found existing token: ${maskToken(existingToken)}`);
+    const input = await prompt("  Press Enter to keep, or paste a new token: ");
+    figmaToken = input || existingToken;
+  } else {
+    figmaToken = await prompt("  Paste your token: ");
+    if (!figmaToken) {
+      figmaToken = "YOUR_FIGMA_TOKEN_HERE";
+      warn("No token provided. Set it later in ~/.claude/settings.json");
+    }
+  }
+
+  // Step 6: Register MCP servers
+  log("");
+  log("Registering MCP servers...");
+
+  if (clis.claude) {
+    if (registerMcpWithClaude(clis.claude.bin, figmaToken)) {
+      success("Registered with Claude Code");
+    } else {
+      warn("Could not register with Claude Code");
+    }
+  }
+
+  if (clis.codex) {
+    if (registerMcpWithCodex(clis.codex.bin, figmaToken)) {
+      success("Registered with Codex");
+    } else {
+      warn("Could not register with Codex");
+    }
+  }
+
+  if (clis.gemini) {
+    if (registerMcpWithGemini(figmaToken)) {
+      success("Registered with Gemini CLI");
+    } else {
+      warn("Could not register with Gemini");
+    }
+  }
+
+  // Write permissions
+  writeClaudePermissions();
+  success("MCP tool permissions auto-enabled");
+
+  // Step 7: Start relay
+  log("");
+  log("Starting relay server...");
+  await cmdStart();
+
+  // Step 8: Install as background service on macOS
+  if (process.platform === "darwin") {
+    log("");
+    const installService = await prompt("  Install as login service (auto-starts on reboot)? [Y/n]: ");
+    if (!installService || installService.toLowerCase() !== "n") {
+      installLaunchdService(clis);
+    }
+  }
+
+  // Done
+  log("");
+  log("=".repeat(53));
+  log("  Setup complete!");
+  log("");
+  log("  If you installed the plugin from Figma Community:");
+  log("    Just open it - it will auto-connect.");
+  log("");
+  log("  If loading from development:");
+  log("    1. Figma Desktop > Plugins > Development > Import plugin from manifest");
+  log(`    2. Select: ${path.join(BRIDGE_DIR, "manifest.json")}`);
+  log("    3. Run the plugin - you should see 'Connected'");
+  log("");
+  log("  Restart these apps to pick up MCP changes:");
+  info("  Claude Code: exit terminal and run 'claude' again");
+  info("  VS Code: Cmd+Shift+P > 'Reload Window'");
+  log("=".repeat(53));
+  log("");
+}
+
+function installLaunchdService(clis) {
+  // Build PATH
+  const pathDirs = ["/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
+  if (clis.claude) pathDirs.unshift(path.dirname(clis.claude.bin));
+  if (clis.codex) pathDirs.unshift(path.dirname(clis.codex.bin));
+  if (clis.gemini) pathDirs.unshift(path.dirname(clis.gemini.bin));
+  const launchdPath = [...new Set(pathDirs)].join(":");
+  const nodePath = process.execPath;
+
+  // Stop existing
+  run("launchctl", ["unload", PLIST_PATH]);
+
+  fs.mkdirSync(PLIST_DIR, { recursive: true });
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${RELAY_SCRIPT}</string>
+    </array>
+    <key>WorkingDirectory</key>
+    <string>${BRIDGE_DIR}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>HOME</key>
+        <string>${os.homedir()}</string>
+        <key>PATH</key>
+        <string>${launchdPath}</string>${clis.claude ? `
+        <key>CLAUDE_BIN_PATH</key>
+        <string>${clis.claude.bin}</string>` : ""}${clis.codex ? `
+        <key>CODEX_BIN_PATH</key>
+        <string>${clis.codex.bin}</string>` : ""}${clis.gemini ? `
+        <key>GEMINI_BIN_PATH</key>
+        <string>${clis.gemini.bin}</string>` : ""}
+    </dict>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${LOG_FILE}</string>
+    <key>StandardErrorPath</key>
+    <string>${LOG_FILE}</string>
+</dict>
+</plist>`;
+
+  fs.writeFileSync(PLIST_PATH, plist);
+  const r = run("launchctl", ["load", PLIST_PATH]);
+  if (r.ok) {
+    success("Installed as login service (auto-starts on reboot)");
+    info(`To stop: launchctl unload ${PLIST_PATH}`);
+  } else {
+    warn("Could not install launchd service. The relay was started manually instead.");
+  }
+}
+
+// ── Main ────────────────────────────────────────────────────────────────────
+
+const command = process.argv[2] || "start";
+
+switch (command) {
+  case "start":
+    cmdStart();
+    break;
+  case "stop":
+    cmdStop();
+    break;
+  case "status":
+    cmdStatus();
+    break;
+  case "doctor":
+    cmdDoctor();
+    break;
+  case "setup":
+    cmdSetup();
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+    log("");
+    log("Figma Intelligence CLI");
+    log("");
+    log("Usage: npx figma-intelligence <command>");
+    log("");
+    log("Commands:");
+    log("  start    Start the bridge relay server (default)");
+    log("  stop     Stop the relay server");
+    log("  status   Show relay + CLI auth status");
+    log("  doctor   Diagnose common issues");
+    log("  setup    Full interactive setup (install deps, register MCP, start relay)");
+    log("  help     Show this help message");
+    log("");
+    break;
+  default:
+    fail(`Unknown command: ${command}`);
+    log("Run 'npx figma-intelligence help' for usage.");
+    process.exit(1);
+}