@createlex/figma-swiftui-mcp 1.0.6 → 1.0.8

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}`);
+    }
   }
 }
 
@@ -664,7 +672,7 @@ server.registerTool('write_generated_swiftui_to_xcode', {
 });
 
 server.registerTool('write_selection_to_xcode', {
-  description: 'Generate SwiftUI from the connected Figma selection and write it directly into the configured Xcode project.',
+  description: 'Generate SwiftUI from the connected Figma selection, write it into the configured Xcode project, and return refinement hints. After writing, the AI assistant SHOULD automatically apply the returned refinementInstructions to make the generated code adaptive and interactive — replacing raster placeholders with native SwiftUI controls, adding GeometryReader for adaptive layout, and wiring basic interactions.',
   inputSchema: {
     nodeIds: z.array(z.string()).optional().describe('Optional list of Figma node ids. If omitted, uses the current selection'),
     includeOverflow: z.boolean().default(false).describe('Ignore Figma clipping when generating layout'),
@@ -673,6 +681,29 @@ server.registerTool('write_selection_to_xcode', {
   },
 }, async ({ nodeIds, includeOverflow, generationMode, projectPath }) => {
   const targetDir = resolveTargetProjectPath(projectPath);
+
+  // Try hosted analysis first to get refinement hints alongside code
+  let analysisHints = null;
+  try {
+    const analysis = await tryHostedSemanticGeneration({
+      nodeIds,
+      generationMode,
+      includeOverflow,
+      analyze: true,
+    });
+    if (analysis) {
+      analysisHints = {
+        generationHints: analysis.generationHints,
+        manualRefinementHints: analysis.manualRefinementHints,
+        reusableComponents: analysis.reusableComponents,
+        assetExportPlan: analysis.assetExportPlan,
+      };
+    }
+  } catch (err) {
+    // Non-fatal — continue with generation even if analysis fails
+    console.error('[figma-swiftui-mcp] Hosted analysis failed (non-fatal):', err?.message ?? err);
+  }
+
   const generated = await callBridge('generate_swiftui', {
     nodeIds,
     includeOverflow,
@@ -696,14 +727,83 @@ server.registerTool('write_selection_to_xcode', {
     throw new Error(result.results.errors.join(' | ') || 'Failed to write generated selection to Xcode');
   }
 
+  // Build refinement instructions from diagnostics and hints
+  const rasterNodes = (generated.diagnostics ?? []).filter(
+    (d) => d.rasterized || d.reason?.toLowerCase().includes('raster')
+  );
+  const refinementInstructions = buildRefinementInstructions({
+    diagnostics: generated.diagnostics ?? [],
+    rasterNodes,
+    analysisHints,
+    structName: effectiveStructName,
+    filePath: result.results?.swiftFile ?? null,
+  });
+
   return jsonResult({
     ...result,
     structName: effectiveStructName,
     selection: generated.selection ?? null,
     diagnostics: generated.diagnostics ?? [],
+    refinementInstructions,
+    ...(analysisHints ? { analysisHints } : {}),
   });
 });
 
+function buildRefinementInstructions({ diagnostics, rasterNodes, analysisHints, structName, filePath }) {
+  const instructions = [];
+
+  // Adaptive layout
+  instructions.push(
+    `Make ${structName} adaptive: replace any fixed .frame(width:height:) on the root body with GeometryReader or .frame(maxWidth: .infinity, maxHeight: .infinity) so the screen fills any device.`
+  );
+
+  // Raster replacements
+  if (rasterNodes.length > 0) {
+    instructions.push(
+      `${rasterNodes.length} element(s) were exported as raster images because Figma could not map them to native SwiftUI. Review these and replace obvious UI controls (buttons, text fields, toggles, tab bars) with native SwiftUI equivalents. Keep actual images/illustrations as Image assets.`
+    );
+  }
+
+  // Hosted analysis hints
+  if (analysisHints?.manualRefinementHints?.length) {
+    for (const hint of analysisHints.manualRefinementHints) {
+      const text = typeof hint === 'string' ? hint : hint.description || hint.message || hint.text || hint.title || null;
+      if (text) {
+        instructions.push(text);
+      }
+    }
+  }
+
+  if (analysisHints?.generationHints?.interactiveElements?.length) {
+    const names = analysisHints.generationHints.interactiveElements
+      .map((e) => e.name || e.nodeId || e.id || '(unnamed)')
+      .filter(Boolean)
+      .join(', ');
+    if (names) {
+      instructions.push(`These elements likely need interaction: ${names}`);
+    }
+  }
+
+  // Reusable components
+  if (analysisHints?.reusableComponents?.length) {
+    const names = analysisHints.reusableComponents
+      .map((c) => c.name || c.componentName || c.id || '(unnamed)')
+      .filter(Boolean)
+      .join(', ');
+    if (names) {
+      instructions.push(
+        `Consider extracting ${analysisHints.reusableComponents.length} reusable component(s): ${names}`
+      );
+    }
+  }
+
+  return {
+    summary: `After writing ${structName}.swift, apply these refinements to make it production-ready:`,
+    steps: instructions,
+    filePath,
+  };
+}
+
 async function shutdownBridgeAndExit(message, exitCode = 1) {
   console.error(message);
   if (authValidationTimer) {

package/package.json

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