@createlex/figma-swiftui-mcp 1.0.5 → 1.0.7

package/companion/bridge-server.cjs

@@ -51,13 +51,50 @@ async function waitForExistingBridge({ host, port }) {
       throw new Error(`HTTP ${response.status}`);
     }
     const data = await response.json();
+
+    // Verify WebSocket is also healthy, not just HTTP
+    await new Promise((resolve, reject) => {
+      const testWs = new WebSocket(`ws://${host}:${port}/bridge`);
+      const timeout = setTimeout(() => {
+        testWs.terminate();
+        reject(new Error('WebSocket health check timed out'));
+      }, 3000);
+      testWs.on('open', () => {
+        clearTimeout(timeout);
+        testWs.close();
+        resolve();
+      });
+      testWs.on('error', (err) => {
+        clearTimeout(timeout);
+        reject(new Error(`WebSocket health check failed: ${err.message}`));
+      });
+    });
+
     return {
       ok: true,
       alreadyRunning: true,
       info: data,
     };
   } catch (error) {
-    throw new Error(`Port ${port} is already in use and does not look like a Figma SwiftUI bridge`);
+    throw new Error(`Port ${port} is already in use and does not look like a healthy Figma SwiftUI bridge (${error.message})`);
+  }
+}
+
+async function killStaleAndRetry({ host, port, logger }) {
+  const { execSync } = require('child_process');
+  try {
+    const lsofOutput = execSync(`lsof -ti :${port}`, { encoding: 'utf8' }).trim();
+    const pids = lsofOutput.split('\n').filter(Boolean);
+    if (pids.length > 0) {
+      logger.warn(`⚠️  Killing ${pids.length} stale process(es) on port ${port}: ${pids.join(', ')}`);
+      for (const pid of pids) {
+        try { process.kill(Number(pid), 'SIGTERM'); } catch (_) {}
+      }
+      // Wait for port to free up
+      await new Promise((r) => setTimeout(r, 1500));
+    }
+  } catch (_) {
+    // lsof returns non-zero if no matches — port is already free
   }
 }
 
@@ -527,7 +564,7 @@ function startBridgeServer(options = {}) {
       if (error && error.code === 'EADDRINUSE') {
         try {
           const running = await waitForExistingBridge({ host, port });
-          logger.warn(`ℹ️ Using existing bridge at http://${host}:${port}`);
+          logger.warn(`ℹ️  Using existing healthy bridge at http://${host}:${port}`);
           resolve({
             app,
             server: null,
@@ -542,8 +579,47 @@ function startBridgeServer(options = {}) {
           });
           return;
         } catch (existingError) {
-          reject(existingError);
-          return;
+          // Existing bridge is unhealthy — kill stale processes and start fresh
+          logger.warn(`⚠️  ${existingError.message}`);
+          try {
+            await killStaleAndRetry({ host, port, logger });
+            // Re-attempt listen after killing stale processes
+            server.listen(port, host, () => {
+              logger.info(`🚀 Figma SwiftUI bridge running at http://${host}:${port} (recovered from stale)`);
+              if (projectPath) {
+                logger.info(`📂 Project path: ${projectPath}`);
+              }
+              logger.info(`🌉 Bridge ready at ws://${host}:${port}/bridge`);
+              resolve({
+                app,
+                server,
+                bridgeWss,
+                port,
+                host,
+                alreadyRunning: false,
+                getProjectPath: () => projectPath,
+                getBridgeInfo: () => ({
+                  protocolVersion: BRIDGE_PROTOCOL_VERSION,
+                  pluginConnected: !!pluginBridgeClient,
+                  connectedAgents: agentBridgeClients.size,
+                  pendingRequests: pendingBridgeRequests.size,
+                  supportedActions: SUPPORTED_BRIDGE_ACTIONS,
+                }),
+                close: () => new Promise((closeResolve, closeReject) => {
+                  bridgeWss.close(() => {
+                    server.close((closeError) => {
+                      if (closeError) closeReject(closeError);
+                      else closeResolve();
+                    });
+                  });
+                }),
+              });
+            });
+            return;
+          } catch (retryError) {
+            reject(new Error(`Failed to recover bridge: ${retryError.message}`));
+            return;
+          }
         }
       }
 

package/companion/mcp-server.mjs

@@ -237,7 +237,15 @@ function handleBridgeMessage(rawMessage) {
   }
 
   if (message.type === 'bridge-event') {
-    console.error(`[figma-swiftui-mcp] Bridge event ${message.event}: ${JSON.stringify(message.data)}`);
+    // Log bridge events concisely — skip full JSON payloads for noisy events
+    const summary = message.data && message.event === 'selectionchange'
+      ? `${message.data.selection?.count ?? 0} node(s) selected`
+      : message.data && message.event === 'currentpagechange'
+        ? `page "${message.data.currentPage?.name || 'unknown'}"`
+        : '';
+    if (summary) {
+      console.error(`[figma-swiftui-mcp] ${message.event}: ${summary}`);
+    }
   }
 }
 

package/companion/setup.cjs

@@ -21,38 +21,68 @@ const os = require('node:os');
 
 const MCP_KEY = 'figma-swiftui';
 
-// ── Resolve the absolute path to this binary ──────────────────────────
-function resolveBinaryPath() {
-  // If installed globally via npm, process.argv[1] points at the bin script
+// ── 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)) {
-      return candidate;
+      // Resolve symlinks to get the actual .js file
+      const real = fs.realpathSync(candidate);
+      return { nodePath, scriptPath: real };
     }
   }
 
-  // Fallback: search PATH
+  // 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) return whichCmd;
+  if (whichCmd) {
+    const real = fs.realpathSync(whichCmd);
+    return { nodePath, scriptPath: real };
+  }
 
   // Last resort: use npx invocation
-  return null;
+  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(binaryPath) {
+function getTargets({ nodePath, scriptPath }) {
   const home = os.homedir();
 
-  // The entry we want in every config
-  const stdioEntry = binaryPath
-    ? { command: binaryPath, args: ['start'] }
-    : { command: 'npx', args: ['-y', '@createlex/figma-swiftui-mcp', 'start'] };
+  // 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 };
 
@@ -120,19 +150,20 @@ function runSetup(flags = {}) {
   const force = flags.force || false;
   const dryRun = flags.dryRun || false;
 
-  const binaryPath = resolveBinaryPath();
+  const paths = resolvePaths();
 
   console.log();
   console.log('  🔧  figma-swiftui-mcp setup');
   console.log('  ─────────────────────────────────────');
-  if (binaryPath) {
-    console.log(`  Binary: ${binaryPath}`);
+  console.log(`  Node:   ${paths.nodePath}`);
+  if (paths.scriptPath) {
+    console.log(`  Script: ${paths.scriptPath}`);
   } else {
-    console.log('  Binary: not found — will use npx fallback');
+    console.log('  Script: not found — will use npx fallback');
   }
   console.log();
 
-  const targets = getTargets(binaryPath);
+  const targets = getTargets(paths);
   let configured = 0;
   let skipped = 0;
   let notInstalled = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@createlex/figma-swiftui-mcp",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "CreateLex MCP runtime for Figma-to-SwiftUI generation and Xcode export",
   "bin": {
     "figma-swiftui-mcp": "bin/figma-swiftui-mcp.js"