@createlex/figma-swiftui-mcp 1.0.0

package/companion/mcp-server.mjs

@@ -0,0 +1,788 @@
+#!/usr/bin/env node
+
+import { createRequire } from 'node:module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import WebSocket from 'ws';
+import * as z from 'zod/v4';
+
+const require = createRequire(import.meta.url);
+const {
+  GENERATED_LAYOUT_VERSION,
+  getConfigPath,
+  getSavedProjectPath,
+  inferStructName,
+  loadProjectPath,
+  resolveWritableProjectPath,
+  setSavedProjectPath,
+  writeAssetCatalogEntries,
+  writeSwiftUIScreen,
+} = require('./xcode-writer.cjs');
+const { startBridgeServer } = require('./bridge-server.cjs');
+const {
+  AUTH_FILE,
+  authorizeRuntimeStartup,
+  postAuthorizedApi,
+  validateRuntimeSession,
+} = require('./createlex-auth.cjs');
+
+const BRIDGE_HTTP_URL = process.env.FIGMA_SWIFTUI_BRIDGE_HTTP_URL || 'http://localhost:7765';
+const BRIDGE_WS_URL = process.env.FIGMA_SWIFTUI_BRIDGE_WS_URL || 'ws://localhost:7765/bridge';
+const REQUEST_TIMEOUT_MS = Number(process.env.FIGMA_SWIFTUI_BRIDGE_TIMEOUT_MS || 30000);
+const AUTH_REVALIDATION_INTERVAL_MS = Number(process.env.FIGMA_SWIFTUI_AUTH_REVALIDATION_MS || (10 * 60 * 1000));
+
+let bridgeSocket = null;
+let connectPromise = null;
+let reconnectTimer = null;
+let authValidationTimer = null;
+let bridgeRuntimeHandle = null;
+let lastBridgeStatus = {
+  protocolVersion: 1,
+  pluginConnected: false,
+  connectedAgents: 0,
+  pendingRequests: 0,
+  supportedActions: [],
+};
+let runtimeAuthState = {
+  authorized: false,
+  bypass: false,
+  apiBaseUrl: null,
+  validatedAt: null,
+  userId: null,
+  email: null,
+  tokenSource: null,
+  expiresAt: null,
+  startupEndpoint: null,
+};
+
+const pendingRequests = new Map();
+
+function readProjectPathArg(argv) {
+  const argIdx = argv.indexOf('--project');
+  if (argIdx !== -1 && argv[argIdx + 1]) {
+    return argv[argIdx + 1];
+  }
+  return null;
+}
+
+function jsonResult(data) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(data, null, 2),
+      },
+    ],
+  };
+}
+
+function getPublicAuthState() {
+  return {
+    authorized: runtimeAuthState.authorized,
+    bypass: runtimeAuthState.bypass,
+    apiBaseUrl: runtimeAuthState.apiBaseUrl,
+    validatedAt: runtimeAuthState.validatedAt,
+    userId: runtimeAuthState.userId,
+    email: runtimeAuthState.email,
+    tokenSource: runtimeAuthState.tokenSource,
+    expiresAt: runtimeAuthState.expiresAt,
+    startupEndpoint: runtimeAuthState.startupEndpoint,
+    authFile: AUTH_FILE,
+  };
+}
+
+function ensureRuntimeAuthorized() {
+  if (!runtimeAuthState.authorized) {
+    throw new Error('CreateLex authentication required. Run "npx @createlex/figma-swiftui-mcp login" and ensure your subscription is active before starting figma-swiftui MCP.');
+  }
+}
+
+async function tryHostedSemanticGeneration({ nodeIds, generationMode, includeOverflow, analyze }) {
+  if (generationMode !== 'editable') {
+    return null;
+  }
+
+  const context = await callBridge('get_design_context', {
+    nodeIds,
+    maxDepth: 4,
+    includeScreenshot: false,
+  });
+
+  const metadata = context?.metadata;
+  const isSingleRootNode = !!metadata && !Array.isArray(metadata?.nodes) ? true : Array.isArray(metadata?.nodes) && metadata.nodes.length === 1;
+  if (!isSingleRootNode) {
+    return null;
+  }
+
+  const endpoint = analyze ? '/mcp/figma-swiftui/analyze' : '/mcp/figma-swiftui/generate';
+  const { response, data } = await postAuthorizedApi(runtimeAuthState, endpoint, {
+    context,
+    generationMode,
+    includeOverflow,
+  });
+
+  if (!response.ok) {
+    throw new Error(data?.error || `Hosted figma-swiftui request failed (${response.status})`);
+  }
+
+  if (!data?.handled) {
+    return null;
+  }
+
+  const selection = Array.isArray(metadata?.nodes)
+    ? {
+        ids: metadata.nodes.map((node) => node.id),
+        names: metadata.nodes.map((node) => node.name),
+      }
+    : {
+        ids: [metadata.id],
+        names: [metadata.name],
+      };
+
+  if (!analyze) {
+    return {
+      code: data.code,
+      selection,
+      imageCount: 0,
+      imageNames: [],
+      diagnostics: data.diagnostics || [],
+      provider: data.provider || 'createlex-hosted',
+      screenType: data.screenType || null,
+      assetRequests: data.assetRequests || [],
+      hosted: true,
+    };
+  }
+
+  return {
+    selection: metadata,
+    generated: {
+      code: data.code,
+      imageCount: 0,
+      imageNames: [],
+      diagnostics: data.diagnostics || [],
+      provider: data.provider || 'createlex-hosted',
+      screenType: data.screenType || null,
+      assetRequests: data.assetRequests || [],
+      hosted: true,
+    },
+    assetExportPlan: data.contextSummary?.assetExportPlan || context?.assetExportPlan || null,
+    reusableComponents: data.contextSummary?.reusableComponents || context?.reusableComponents || null,
+    generationHints: data.contextSummary?.generationHints || context?.generationHints || null,
+    manualRefinementHints: context?.generationHints?.manualRefinementHints || [],
+    hosted: true,
+  };
+}
+
+function resolveTargetProjectPath(projectPath) {
+  const resolved = loadProjectPath({ explicitPath: projectPath });
+  if (!resolved) {
+    throw new Error('No Xcode project path is configured. Use set_project_path first or pass projectPath explicitly.');
+  }
+  return resolved;
+}
+
+function scheduleReconnect() {
+  if (reconnectTimer) {
+    return;
+  }
+
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    connectBridge().catch((error) => {
+      console.error('[figma-swiftui-mcp] Bridge reconnect failed:', error.message);
+    });
+  }, 1500);
+}
+
+function rejectPendingRequests(message) {
+  for (const [requestId, pending] of pendingRequests.entries()) {
+    clearTimeout(pending.timer);
+    pending.reject(new Error(message));
+    pendingRequests.delete(requestId);
+  }
+}
+
+function handleBridgeMessage(rawMessage) {
+  let message;
+  try {
+    message = JSON.parse(rawMessage.toString());
+  } catch (error) {
+    console.error('[figma-swiftui-mcp] Failed to parse bridge message:', error);
+    return;
+  }
+
+  if (message.type === 'hello-ack' || message.type === 'bridge-status') {
+    lastBridgeStatus = {
+      ...lastBridgeStatus,
+      ...message,
+    };
+    return;
+  }
+
+  if (message.type === 'bridge-response') {
+    const pending = pendingRequests.get(message.requestId);
+    if (!pending) {
+      return;
+    }
+
+    clearTimeout(pending.timer);
+    pendingRequests.delete(message.requestId);
+
+    if (message.ok) {
+      pending.resolve(message.data);
+    } else {
+      pending.reject(new Error(message.error || `Bridge action ${message.action} failed`));
+    }
+    return;
+  }
+
+  if (message.type === 'bridge-event') {
+    console.error(`[figma-swiftui-mcp] Bridge event ${message.event}: ${JSON.stringify(message.data)}`);
+  }
+}
+
+async function connectBridge() {
+  if (bridgeSocket && bridgeSocket.readyState === WebSocket.OPEN) {
+    return bridgeSocket;
+  }
+
+  if (connectPromise) {
+    return connectPromise;
+  }
+
+  connectPromise = new Promise((resolve, reject) => {
+    const socket = new WebSocket(BRIDGE_WS_URL);
+    let settled = false;
+
+    socket.on('open', () => {
+      bridgeSocket = socket;
+      socket.send(JSON.stringify({
+        type: 'hello',
+        role: 'agent',
+        protocolVersion: 1,
+      }));
+
+      settled = true;
+      resolve(socket);
+    });
+
+    socket.on('message', (message) => {
+      handleBridgeMessage(message);
+    });
+
+    socket.on('close', () => {
+      if (bridgeSocket === socket) {
+        bridgeSocket = null;
+      }
+      rejectPendingRequests('Bridge socket closed');
+      scheduleReconnect();
+    });
+
+    socket.on('error', (error) => {
+      if (!settled) {
+        reject(error);
+      }
+    });
+  }).finally(() => {
+    connectPromise = null;
+  });
+
+  return connectPromise;
+}
+
+async function fetchBridgeStatus() {
+  try {
+    const response = await fetch(`${BRIDGE_HTTP_URL}/bridge/info`);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    lastBridgeStatus = {
+      ...lastBridgeStatus,
+      ...data,
+    };
+    return data;
+  } catch (error) {
+    return {
+      ...lastBridgeStatus,
+      ok: false,
+      error: error instanceof Error ? error.message : 'Unable to reach bridge info endpoint',
+    };
+  }
+}
+
+async function callBridge(action, params = {}) {
+  ensureRuntimeAuthorized();
+  await connectBridge();
+  const status = await fetchBridgeStatus();
+
+  if (!status.pluginConnected) {
+    throw new Error('No active Figma plugin session is connected to the bridge');
+  }
+
+  const requestId = `mcp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pendingRequests.delete(requestId);
+      reject(new Error(`Timed out waiting for bridge action "${action}"`));
+    }, REQUEST_TIMEOUT_MS);
+
+    pendingRequests.set(requestId, {
+      resolve,
+      reject,
+      timer,
+    });
+
+    bridgeSocket.send(JSON.stringify({
+      type: 'bridge-request',
+      requestId,
+      action,
+      params,
+    }));
+  });
+}
+
+const server = new McpServer({
+  name: 'figma-swiftui-bridge',
+  version: '1.0.0',
+});
+
+server.registerTool('bridge_status', {
+  description: 'Check the local Figma SwiftUI bridge status, including whether a live plugin session is connected.',
+}, async () => {
+  const data = await fetchBridgeStatus();
+  return jsonResult({
+    ...data,
+    auth: getPublicAuthState(),
+  });
+});
+
+server.registerTool('auth_status', {
+  description: 'Check whether the local figma-swiftui MCP runtime is authorized for a paid CreateLex subscription.',
+}, async () => {
+  return jsonResult(getPublicAuthState());
+});
+
+server.registerTool('get_metadata', {
+  description: 'Inspect selection, page, or node metadata in a format similar to Figma Dev MCP.',
+  inputSchema: {
+    scope: z.enum(['selection', 'page', 'node']).default('selection').describe('Metadata scope to inspect'),
+    nodeId: z.string().optional().describe('Required when scope=node'),
+    maxDepth: z.number().int().min(0).max(8).default(3).describe('Maximum child depth to include'),
+  },
+}, async ({ scope, nodeId, maxDepth }) => {
+  const data = await callBridge('get_metadata', { scope, nodeId, maxDepth });
+  return jsonResult(data);
+});
+
+server.registerTool('get_design_context', {
+  description: 'Return node metadata, asset export candidates, and generation hints for the current selection or an explicit node.',
+  inputSchema: {
+    nodeIds: z.array(z.string()).optional().describe('Optional list of Figma node ids. If omitted, uses the current selection'),
+    nodeId: z.string().optional().describe('Optional single Figma node id'),
+    maxDepth: z.number().int().min(0).max(8).default(3).describe('Maximum child depth to include'),
+    includeScreenshot: z.boolean().default(false).describe('Include a PNG screenshot when exactly one node is targeted'),
+  },
+}, async ({ nodeIds, nodeId, maxDepth, includeScreenshot }) => {
+  const data = await callBridge('get_design_context', {
+    nodeIds,
+    nodeId,
+    maxDepth,
+    includeScreenshot,
+  });
+  return jsonResult(data);
+});
+
+server.registerTool('get_screenshot', {
+  description: 'Export a PNG screenshot for a single target node or the single current selection.',
+  inputSchema: {
+    nodeIds: z.array(z.string()).optional().describe('Optional list of Figma node ids. If omitted, uses the current selection'),
+    nodeId: z.string().optional().describe('Optional single Figma node id'),
+  },
+}, async ({ nodeIds, nodeId }) => {
+  const data = await callBridge('get_screenshot', { nodeIds, nodeId });
+  return jsonResult(data);
+});
+
+server.registerTool('export_svg', {
+  description: 'Export an exact SVG for a single vector-friendly node or the single current selection.',
+  inputSchema: {
+    nodeIds: z.array(z.string()).optional().describe('Optional list of Figma node ids. If omitted, uses the current selection'),
+    nodeId: z.string().optional().describe('Optional single Figma node id'),
+  },
+}, async ({ nodeIds, nodeId }) => {
+  const data = await callBridge('export_svg', { nodeIds, nodeId });
+  return jsonResult(data);
+});
+
+server.registerTool('write_svg_to_xcode', {
+  description: 'Export an exact SVG from Figma and write it directly into Assets.xcassets.',
+  inputSchema: {
+    nodeIds: z.array(z.string()).optional().describe('Optional list of Figma node ids. If omitted, uses the current selection'),
+    nodeId: z.string().optional().describe('Optional single Figma node id'),
+    assetName: z.string().optional().describe('Optional asset name override'),
+    projectPath: z.string().optional().describe('Optional Xcode source folder override'),
+  },
+}, async ({ nodeIds, nodeId, assetName, projectPath }) => {
+  const targetDir = resolveTargetProjectPath(projectPath);
+  const svgExport = await callBridge('export_svg', { nodeIds, nodeId });
+  const effectiveAssetName = assetName || svgExport.suggestedAssetName || 'VectorAsset';
+  const result = writeAssetCatalogEntries({
+    targetDir,
+    assets: [
+      {
+        name: effectiveAssetName,
+        format: 'svg',
+        svg: svgExport.svg,
+      },
+    ],
+  });
+
+  if (!result.ok) {
+    throw new Error(result.errors.join(' | ') || 'Failed to write SVG asset to Xcode');
+  }
+
+  return jsonResult({
+    ok: true,
+    projectPath: targetDir,
+    assetName: effectiveAssetName,
+    xcassetsDir: result.xcassetsDir,
+    files: result.files,
+    sourceNode: {
+      nodeId: svgExport.nodeId,
+      nodeName: svgExport.nodeName,
+      nodeType: svgExport.nodeType,
+    },
+  });
+});
+
+server.registerTool('get_project_path', {
+  description: 'Read the saved Xcode project source folder used for local SwiftUI writes.',
+}, async () => {
+  return jsonResult({
+    projectPath: getSavedProjectPath(),
+    configPath: getConfigPath(),
+    layoutVersion: GENERATED_LAYOUT_VERSION,
+  });
+});
+
+server.registerTool('set_project_path', {
+  description: 'Persist the Xcode project source folder used for local SwiftUI writes.',
+  inputSchema: {
+    projectPath: z.string().describe('Path to the Xcode source folder containing Swift files and Assets.xcassets'),
+  },
+}, async ({ projectPath }) => {
+  const resolved = resolveWritableProjectPath(projectPath);
+  const saved = setSavedProjectPath(resolved);
+  return jsonResult({
+    ok: true,
+    projectPath: saved,
+    configPath: getConfigPath(),
+  });
+});
+
+server.registerTool('get_document_summary', {
+  description: 'Read high-level Figma document, page, selection, and viewport metadata from the connected plugin session.',
+}, async () => {
+  const data = await callBridge('get_document_summary');
+  return jsonResult(data);
+});
+
+server.registerTool('get_viewport_context', {
+  description: 'Read the active Figma viewport center, zoom, and current page metadata.',
+}, async () => {
+  const data = await callBridge('get_viewport_context');
+  return jsonResult(data);
+});
+
+server.registerTool('get_selection_snapshot', {
+  description: 'Read a rich structural snapshot of the current Figma selection.',
+  inputSchema: {
+    maxDepth: z.number().int().min(0).max(8).default(3).describe('Maximum child depth to include in the snapshot'),
+  },
+}, async ({ maxDepth }) => {
+  const data = await callBridge('get_selection_snapshot', { maxDepth });
+  return jsonResult(data);
+});
+
+server.registerTool('get_page_snapshot', {
+  description: 'Read the current Figma page and its child hierarchy.',
+  inputSchema: {
+    maxDepth: z.number().int().min(0).max(6).default(2).describe('Maximum child depth to include for the page snapshot'),
+  },
+}, async ({ maxDepth }) => {
+  const data = await callBridge('get_page_snapshot', { maxDepth });
+  return jsonResult(data);
+});
+
+server.registerTool('get_node_snapshot', {
+  description: 'Read a rich structural snapshot for a specific Figma node id.',
+  inputSchema: {
+    nodeId: z.string().describe('Figma node id, for example "123:456"'),
+    maxDepth: z.number().int().min(0).max(8).default(3).describe('Maximum child depth to include for the node snapshot'),
+  },
+}, async ({ nodeId, maxDepth }) => {
+  const data = await callBridge('get_node_snapshot', { nodeId, maxDepth });
+  return jsonResult(data);
+});
+
+server.registerTool('find_nodes', {
+  description: 'Search the current Figma page for nodes by name substring and optional node type.',
+  inputSchema: {
+    query: z.string().default('').describe('Case-insensitive name substring to search for'),
+    type: z.string().optional().describe('Optional Figma node type to filter, for example FRAME or TEXT'),
+    limit: z.number().int().min(1).max(200).default(25).describe('Maximum number of matching nodes to return'),
+    maxDepth: z.number().int().min(0).max(2).default(0).describe('Maximum child depth to include for each match'),
+  },
+}, async ({ query, type, limit, maxDepth }) => {
+  const data = await callBridge('find_nodes', { query, type, limit, maxDepth });
+  return jsonResult(data);
+});
+
+server.registerTool('get_asset_export_plan', {
+  description: 'List vector/icon/image export candidates for the current selection or explicit node ids.',
+  inputSchema: {
+    nodeIds: z.array(z.string()).optional().describe('Optional list of Figma node ids. If omitted, uses the current selection'),
+    nodeId: z.string().optional().describe('Optional single Figma node id'),
+  },
+}, async ({ nodeIds, nodeId }) => {
+  const data = await callBridge('get_asset_export_plan', { nodeIds, nodeId });
+  return jsonResult(data);
+});
+
+server.registerTool('extract_reusable_components', {
+  description: 'Identify repeated Figma components and repeated sibling structures that should become reusable SwiftUI components.',
+  inputSchema: {
+    nodeIds: z.array(z.string()).optional().describe('Optional list of Figma node ids. If omitted, uses the current selection or current page when scope=page'),
+    nodeId: z.string().optional().describe('Optional single Figma node id'),
+    scope: z.enum(['selection', 'page']).default('selection').describe('Analyze the current selection or scan the full current page'),
+  },
+}, async ({ nodeIds, nodeId, scope }) => {
+  const data = await callBridge('extract_reusable_components', { nodeIds, nodeId, scope });
+  return jsonResult(data);
+});
+
+server.registerTool('dump_tree', {
+  description: 'Return a readable text tree for the current selection or explicit node ids.',
+  inputSchema: {
+    nodeIds: z.array(z.string()).optional().describe('Optional list of Figma node ids. If omitted, uses the current selection'),
+  },
+}, async ({ nodeIds }) => {
+  const data = await callBridge('dump_tree', { nodeIds });
+  return jsonResult(data);
+});
+
+server.registerTool('generate_swiftui', {
+  description: 'Run the same SwiftUI export path used by the plugin UI, optionally including image payloads.',
+  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'),
+    generationMode: z.enum(['editable', 'fidelity']).default('editable').describe('Editable keeps more native SwiftUI structure; fidelity rasterizes more complex layouts'),
+    includeImages: z.boolean().default(false).describe('Include base64 image payloads in the tool result'),
+  },
+}, async ({ nodeIds, includeOverflow, generationMode, includeImages }) => {
+  if (!includeImages) {
+    const hosted = await tryHostedSemanticGeneration({
+      nodeIds,
+      generationMode,
+      includeOverflow,
+      analyze: false,
+    });
+    if (hosted) {
+      return jsonResult(hosted);
+    }
+  }
+
+  const data = await callBridge('generate_swiftui', {
+    nodeIds,
+    includeOverflow,
+    generationMode,
+    includeImages,
+  });
+  return jsonResult(data);
+});
+
+server.registerTool('analyze_generation', {
+  description: 'Return the generated SwiftUI plus per-node diagnostics and rasterization reasons for the current selection or explicit node ids.',
+  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'),
+    generationMode: z.enum(['editable', 'fidelity']).default('editable').describe('Editable keeps more native SwiftUI structure; fidelity rasterizes more complex layouts'),
+    maxDepth: z.number().int().min(0).max(8).default(3).describe('Maximum child depth to include in the diagnostic node snapshot'),
+  },
+}, async ({ nodeIds, includeOverflow, generationMode, maxDepth }) => {
+  const hosted = await tryHostedSemanticGeneration({
+    nodeIds,
+    generationMode,
+    includeOverflow,
+    analyze: true,
+  });
+  if (hosted) {
+    return jsonResult(hosted);
+  }
+
+  const data = await callBridge('analyze_generation', {
+    nodeIds,
+    includeOverflow,
+    generationMode,
+    maxDepth,
+  });
+  return jsonResult(data);
+});
+
+server.registerTool('write_generated_swiftui_to_xcode', {
+  description: 'Write generated SwiftUI code and optional exported images directly into the configured Xcode project.',
+  inputSchema: {
+    code: z.string().describe('SwiftUI source code to write'),
+    structName: z.string().optional().describe('Optional Swift struct name; if omitted it will be inferred from the code'),
+    projectPath: z.string().optional().describe('Optional Xcode source folder override'),
+    images: z.array(z.object({
+      name: z.string(),
+      base64: z.string(),
+    })).default([]).describe('Optional exported image payloads'),
+    selectionNames: z.array(z.string()).default([]).describe('Optional original Figma selection names for struct inference'),
+  },
+}, async ({ code, structName, projectPath, images, selectionNames }) => {
+  const targetDir = resolveTargetProjectPath(projectPath);
+  const effectiveStructName = inferStructName({ structName, code, selectionNames });
+  const result = writeSwiftUIScreen({
+    targetDir,
+    code,
+    structName: effectiveStructName,
+    images,
+  });
+
+  if (!result.ok) {
+    throw new Error(result.results.errors.join(' | ') || 'Failed to write generated SwiftUI to Xcode');
+  }
+
+  return jsonResult({
+    ...result,
+    structName: effectiveStructName,
+  });
+});
+
+server.registerTool('write_selection_to_xcode', {
+  description: 'Generate SwiftUI from the connected Figma selection and write it directly into the configured Xcode project.',
+  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'),
+    generationMode: z.enum(['editable', 'fidelity']).default('editable').describe('Editable keeps more native SwiftUI structure; fidelity rasterizes more complex layouts'),
+    projectPath: z.string().optional().describe('Optional Xcode source folder override'),
+  },
+}, async ({ nodeIds, includeOverflow, generationMode, projectPath }) => {
+  const targetDir = resolveTargetProjectPath(projectPath);
+  const generated = await callBridge('generate_swiftui', {
+    nodeIds,
+    includeOverflow,
+    generationMode,
+    includeImages: true,
+  });
+
+  const effectiveStructName = inferStructName({
+    code: generated.code,
+    selectionNames: generated.selection?.names ?? [],
+  });
+
+  const result = writeSwiftUIScreen({
+    targetDir,
+    code: generated.code,
+    structName: effectiveStructName,
+    images: Array.isArray(generated.images) ? generated.images : [],
+  });
+
+  if (!result.ok) {
+    throw new Error(result.results.errors.join(' | ') || 'Failed to write generated selection to Xcode');
+  }
+
+  return jsonResult({
+    ...result,
+    structName: effectiveStructName,
+    selection: generated.selection ?? null,
+    diagnostics: generated.diagnostics ?? [],
+  });
+});
+
+async function shutdownBridgeAndExit(message, exitCode = 1) {
+  console.error(message);
+  if (authValidationTimer) {
+    clearInterval(authValidationTimer);
+    authValidationTimer = null;
+  }
+  if (bridgeRuntimeHandle && typeof bridgeRuntimeHandle.close === 'function' && !bridgeRuntimeHandle.alreadyRunning) {
+    try {
+      await bridgeRuntimeHandle.close();
+    } catch (error) {
+      console.error('[figma-swiftui-mcp] Failed to close bridge cleanly:', error.message);
+    }
+  }
+  process.exit(exitCode);
+}
+
+function startAuthValidationLoop() {
+  if (authValidationTimer) {
+    clearInterval(authValidationTimer);
+  }
+
+  authValidationTimer = setInterval(async () => {
+    try {
+      const validation = await validateRuntimeSession(runtimeAuthState);
+      if (!validation.valid) {
+        await shutdownBridgeAndExit(`[figma-swiftui-mcp] Authorization lost: ${validation.error}`);
+        return;
+      }
+
+      runtimeAuthState = {
+        ...runtimeAuthState,
+        ...validation.session,
+        authorized: true,
+      };
+
+      if (validation.refreshed) {
+        console.error('[figma-swiftui-mcp] Refreshed CreateLex MCP authorization');
+      }
+    } catch (error) {
+      await shutdownBridgeAndExit(`[figma-swiftui-mcp] Authorization revalidation failed: ${error.message}`);
+    }
+  }, AUTH_REVALIDATION_INTERVAL_MS);
+
+  authValidationTimer.unref?.();
+}
+
+async function main() {
+  runtimeAuthState = await authorizeRuntimeStartup();
+  console.error(
+    runtimeAuthState.bypass
+      ? '[figma-swiftui-mcp] Authorization bypass enabled'
+      : `[figma-swiftui-mcp] Authorized CreateLex user ${runtimeAuthState.email || runtimeAuthState.userId || 'unknown-user'}`
+  );
+
+  const bridgeHttpUrl = new URL(BRIDGE_HTTP_URL);
+  bridgeRuntimeHandle = await startBridgeServer({
+    host: bridgeHttpUrl.hostname,
+    port: Number(bridgeHttpUrl.port || (bridgeHttpUrl.protocol === 'https:' ? 443 : 80)),
+    projectPath: readProjectPathArg(process.argv),
+    logger: {
+      info: console.error,
+      warn: console.error,
+      error: console.error,
+    },
+  });
+
+  try {
+    await connectBridge();
+  } catch (error) {
+    console.error('[figma-swiftui-mcp] Bridge connect failed on startup:', error.message);
+  }
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  startAuthValidationLoop();
+  console.error('[figma-swiftui-mcp] MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('[figma-swiftui-mcp] Server error:', error);
+  process.exit(1);
+});