@createlex/figgen 1.4.2

package/companion/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "figma-swiftui-companion",
+  "version": "1.0.9",
+  "description": "Local server that writes Figma-generated SwiftUI code and images into an Xcode project",
+  "main": "server.js",
+  "scripts": {
+    "login": "node login.mjs",
+    "start": "node mcp-server.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "cors": "^2.8.5",
+    "express": "^4.18.0",
+    "ws": "^8.20.0",
+    "zod": "^4.3.6"
+  }
+}

package/companion/server.js

@@ -0,0 +1,65 @@
+const { startBridgeServer } = require('./bridge-server.cjs');
+const { authorizeRuntimeStartup, validateRuntimeSession } = require('./createlex-auth.cjs');
+
+const AUTH_REVALIDATION_INTERVAL_MS = Number(process.env.FIGMA_SWIFTUI_AUTH_REVALIDATION_MS || (10 * 60 * 1000));
+
+function readProjectPathArg(argv) {
+  const argIdx = argv.indexOf('--project');
+  if (argIdx !== -1 && argv[argIdx + 1]) {
+    return argv[argIdx + 1];
+  }
+  return null;
+}
+
+async function main() {
+  let authState = await authorizeRuntimeStartup();
+  console.log(
+    authState.bypass
+      ? '[figma-swiftui-bridge] Authorization bypass enabled'
+      : `[figma-swiftui-bridge] Authorized CreateLex user ${authState.email || authState.userId || 'unknown-user'}`
+  );
+
+  const projectPath = readProjectPathArg(process.argv);
+  const bridgeRuntime = await startBridgeServer({
+    projectPath,
+    logger: console,
+  });
+
+  const authValidationTimer = setInterval(async () => {
+    try {
+      const validation = await validateRuntimeSession(authState);
+      if (!validation.valid) {
+        console.error(`[figma-swiftui-bridge] Authorization lost: ${validation.error}`);
+        // Signal the bridge to return authRequired from /ping so the plugin UI
+        // can show a "Login required" panel instead of just "runtime off".
+        if (bridgeRuntime && typeof bridgeRuntime.setAuthRequired === 'function') {
+          bridgeRuntime.setAuthRequired(validation.error || 'Token expired. Run: npx @createlex/figma-swiftui-mcp login');
+        } else {
+          process.exit(1);
+        }
+        return;
+      }
+
+      authState = validation.session;
+      if (validation.refreshed) {
+        console.log('[figma-swiftui-bridge] Refreshed CreateLex MCP authorization');
+      }
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : 'unknown_error';
+      console.error(`[figma-swiftui-bridge] Authorization revalidation failed: ${reason}`);
+      if (bridgeRuntime && typeof bridgeRuntime.setAuthRequired === 'function') {
+        bridgeRuntime.setAuthRequired(`Session revalidation failed: ${reason}`);
+      } else {
+        process.exit(1);
+      }
+    }
+  }, AUTH_REVALIDATION_INTERVAL_MS);
+
+  authValidationTimer.unref?.();
+  console.log('\nReady to receive from Figma plugin.\n');
+}
+
+main().catch((error) => {
+  console.error('[figma-swiftui-bridge] Server error:', error);
+  process.exit(1);
+});

package/companion/setup.cjs

@@ -0,0 +1,309 @@
+/**
+ * figma-swiftui-mcp setup
+ *
+ * Auto-detect installed IDEs / CLI tools and add the figma-swiftui MCP
+ * server entry to each config file.
+ *
+ * Supported targets:
+ *   - Claude Desktop  (~/Library/Application Support/Claude/claude_desktop_config.json)
+ *   - Claude Code     (~/.claude.json  → mcpServers)  (covers CLI + desktop + web)
+ *   - Cursor          (~/.cursor/mcp.json)
+ *   - Windsurf        (~/.codeium/windsurf/mcp_config.json)
+ *   - VS Code         (~/.vscode/mcp.json  — user-level)
+ *   - OpenCode        (~/.config/opencode/opencode.json  → mcp)
+ *   - Codex CLI       (~/.codex/config.toml  → [mcp_servers.figma-swiftui])
+ *   - Gemini CLI      (~/.gemini/settings.json)
+ *   - Antigravity     (~/.gemini/antigravity/mcp_config.json)
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const MCP_KEY = 'figma-swiftui';
+
+// ── Resolve the absolute path to the bin script and node ─────────────
+// IDEs (Cursor, VS Code, etc.) do NOT source shell profiles, so
+// `#!/usr/bin/env node` fails when node is managed by nvm/fnm/volta.
+// Instead we record the absolute node path and the bin script separately.
+function resolvePaths() {
+  const nodePath = process.execPath; // absolute path to node binary
+
+  // Try to find the bin JS file
+  const binScript = process.argv[1];
+  if (binScript) {
+    const resolved = fs.realpathSync(binScript);
+    const dir = path.dirname(resolved);
+    // Check for the .js bin entry point
+    const jsCandidate = path.join(dir, 'figma-swiftui-mcp.js');
+    if (fs.existsSync(jsCandidate)) {
+      return { nodePath, scriptPath: jsCandidate };
+    }
+    // Check for the wrapper (symlink without .js)
+    const candidate = path.join(dir, 'figma-swiftui-mcp');
+    if (fs.existsSync(candidate)) {
+      // Resolve symlinks to get the actual .js file
+      const real = fs.realpathSync(candidate);
+      return { nodePath, scriptPath: real };
+    }
+  }
+
+  // Fallback: search PATH for the binary, then resolve to its .js source
+  const whichCmd = require('node:child_process')
+    .execSync('which figma-swiftui-mcp 2>/dev/null || true')
+    .toString()
+    .trim();
+  if (whichCmd) {
+    const real = fs.realpathSync(whichCmd);
+    return { nodePath, scriptPath: real };
+  }
+
+  // Last resort: use npx invocation
+  return { nodePath, scriptPath: null };
+}
+
+// ── Resolve absolute npx path for fallback ───────────────────────────
+function resolveNpxPath() {
+  try {
+    const npxPath = require('node:child_process')
+      .execSync('which npx 2>/dev/null || true')
+      .toString()
+      .trim();
+    return npxPath || 'npx';
+  } catch {
+    return 'npx';
+  }
+}
+
+// ── IDE config definitions ────────────────────────────────────────────
+function getTargets({ nodePath, scriptPath }) {
+  const home = os.homedir();
+
+  // Use absolute node path + script to avoid #!/usr/bin/env node failures
+  // in IDEs that don't source shell profiles (nvm/fnm/volta).
+  const stdioEntry = scriptPath
+    ? { command: nodePath, args: [scriptPath, 'start'] }
+    : { command: resolveNpxPath(), args: ['-y', '@createlex/figma-swiftui-mcp', 'start'] };
+
+  const stdioEntryWithType = { type: 'stdio', ...stdioEntry };
+
+  return [
+    {
+      name: 'Claude Desktop',
+      path: path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+      key: 'mcpServers',
+      entry: stdioEntry,
+    },
+    {
+      name: 'Claude Code',
+      path: path.join(home, '.claude.json'),
+      key: 'mcpServers',
+      entry: stdioEntryWithType,
+    },
+    {
+      name: 'Cursor',
+      path: path.join(home, '.cursor', 'mcp.json'),
+      key: 'mcpServers',
+      entry: stdioEntry,
+    },
+    {
+      name: 'Windsurf',
+      path: path.join(home, '.codeium', 'windsurf', 'mcp_config.json'),
+      key: 'mcpServers',
+      entry: stdioEntry,
+    },
+    {
+      name: 'VS Code (user)',
+      path: path.join(home, '.vscode', 'mcp.json'),
+      key: 'servers',
+      entry: stdioEntry,
+      wrapKey: null, // VS Code uses { servers: { ... } } at top level
+    },
+    {
+      name: 'OpenCode',
+      path: path.join(home, '.config', 'opencode', 'opencode.json'),
+      key: 'mcp',
+      entry: scriptPath
+        ? { type: 'local', command: [nodePath, scriptPath, 'start'], enabled: true }
+        : { type: 'local', command: [resolveNpxPath(), '-y', '@createlex/figma-swiftui-mcp', 'start'], enabled: true },
+    },
+    {
+      name: 'Codex CLI',
+      path: path.join(home, '.codex', 'config.toml'),
+      format: 'toml',
+      entry: { command: stdioEntry.command, args: stdioEntry.args },
+    },
+    {
+      name: 'Gemini CLI',
+      path: path.join(home, '.gemini', 'settings.json'),
+      key: 'mcpServers',
+      entry: stdioEntry,
+    },
+    {
+      name: 'Antigravity (Gemini)',
+      path: path.join(home, '.gemini', 'antigravity', 'mcp_config.json'),
+      key: 'mcpServers',
+      entry: { ...stdioEntry, env: {}, disabled: false },
+    },
+  ];
+}
+
+// ── Read / write helpers ──────────────────────────────────────────────
+function readJsonSafe(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonSafe(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+
+// ── TOML helpers (minimal, for Codex config.toml) ────────────────────
+// We only need to append/check a [mcp_servers.<name>] section — no full
+// TOML parser required.
+
+function tomlHasServer(raw, serverName) {
+  const pattern = new RegExp(`^\\[mcp_servers\\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\]`, 'm');
+  return pattern.test(raw);
+}
+
+function tomlFormatValue(v) {
+  if (typeof v === 'string') return `"${v.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+  if (typeof v === 'boolean') return v ? 'true' : 'false';
+  if (typeof v === 'number') return String(v);
+  if (Array.isArray(v)) return `[${v.map(tomlFormatValue).join(', ')}]`;
+  return `"${v}"`;
+}
+
+function buildTomlSection(serverName, entry) {
+  const lines = [`[mcp_servers.${serverName}]`];
+  for (const [k, v] of Object.entries(entry)) {
+    if (k === 'env' && typeof v === 'object') continue; // handle env as sub-table
+    lines.push(`${k} = ${tomlFormatValue(v)}`);
+  }
+  if (entry.env && Object.keys(entry.env).length > 0) {
+    lines.push(`[mcp_servers.${serverName}.env]`);
+    for (const [ek, ev] of Object.entries(entry.env)) {
+      lines.push(`${ek} = ${tomlFormatValue(ev)}`);
+    }
+  }
+  return lines.join('\n') + '\n';
+}
+
+function appendTomlServer(filePath, serverName, entry, dryRun) {
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  if (tomlHasServer(raw, serverName)) return false; // already present
+  const section = '\n' + buildTomlSection(serverName, entry);
+  if (!dryRun) {
+    fs.appendFileSync(filePath, section, 'utf-8');
+  }
+  return true;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────
+function runSetup(flags = {}) {
+  const force = flags.force || false;
+  const dryRun = flags.dryRun || false;
+
+  const paths = resolvePaths();
+
+  console.log();
+  console.log('  🔧  figma-swiftui-mcp setup');
+  console.log('  ─────────────────────────────────────');
+  console.log(`  Node:   ${paths.nodePath}`);
+  if (paths.scriptPath) {
+    console.log(`  Script: ${paths.scriptPath}`);
+  } else {
+    console.log('  Script: not found — will use npx fallback');
+  }
+  console.log();
+
+  const targets = getTargets(paths);
+  let configured = 0;
+  let skipped = 0;
+  let notInstalled = 0;
+
+  for (const target of targets) {
+    const exists = fs.existsSync(target.path);
+
+    if (!exists) {
+      console.log(`  ⚪  ${target.name}  — not installed (${path.basename(target.path)} not found)`);
+      notInstalled++;
+      continue;
+    }
+
+    // ── TOML targets (Codex) ──────────────────────────────────────
+    if (target.format === 'toml') {
+      const raw = fs.readFileSync(target.path, 'utf-8');
+      if (tomlHasServer(raw, MCP_KEY) && !force) {
+        console.log(`  ✅  ${target.name}  — already configured`);
+        skipped++;
+        continue;
+      }
+      if (dryRun) {
+        console.log(`  🟡  ${target.name}  — would configure (dry run)`);
+      } else {
+        appendTomlServer(target.path, MCP_KEY, target.entry, false);
+        console.log(`  ✅  ${target.name}  — configured!`);
+      }
+      configured++;
+      continue;
+    }
+
+    // ── JSON targets ────────────────────────────────────────────
+    const config = readJsonSafe(target.path);
+    if (!config) {
+      console.log(`  ⚠️  ${target.name}  — could not parse config`);
+      skipped++;
+      continue;
+    }
+
+    // Ensure the server container key exists
+    if (!config[target.key]) {
+      config[target.key] = {};
+    }
+
+    const servers = config[target.key];
+
+    // Check if already configured
+    if (servers[MCP_KEY] && !force) {
+      console.log(`  ✅  ${target.name}  — already configured`);
+      skipped++;
+      continue;
+    }
+
+    // Add the entry
+    servers[MCP_KEY] = target.entry;
+
+    if (dryRun) {
+      console.log(`  🟡  ${target.name}  — would configure (dry run)`);
+    } else {
+      writeJsonSafe(target.path, config);
+      console.log(`  ✅  ${target.name}  — configured!`);
+    }
+    configured++;
+  }
+
+  console.log();
+  console.log(`  ─────────────────────────────────────`);
+  console.log(`  ${configured} configured · ${skipped} skipped · ${notInstalled} not installed`);
+
+  if (configured > 0 && !dryRun) {
+    console.log();
+    console.log('  💡 Restart your IDE(s) for the new MCP config to take effect.');
+  }
+
+  console.log();
+}
+
+module.exports = { runSetup };