@createlex/figma-swiftui-mcp 1.0.0

package/companion/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "figma-swiftui-companion",
+  "version": "1.0.0",
+  "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,64 @@
+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}`);
+        if (bridgeRuntime && typeof bridgeRuntime.close === 'function' && !bridgeRuntime.alreadyRunning) {
+          await bridgeRuntime.close().catch((error) => {
+            console.error('[figma-swiftui-bridge] Failed to close bridge cleanly:', error.message);
+          });
+        }
+        process.exit(1);
+        return;
+      }
+
+      authState = validation.session;
+      if (validation.refreshed) {
+        console.log('[figma-swiftui-bridge] Refreshed CreateLex MCP authorization');
+      }
+    } catch (error) {
+      console.error(`[figma-swiftui-bridge] Authorization revalidation failed: ${error instanceof Error ? error.message : 'unknown_error'}`);
+      if (bridgeRuntime && typeof bridgeRuntime.close === 'function' && !bridgeRuntime.alreadyRunning) {
+        await bridgeRuntime.close().catch((closeError) => {
+          console.error('[figma-swiftui-bridge] Failed to close bridge cleanly:', closeError.message);
+        });
+      }
+      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/xcode-writer.cjs

@@ -0,0 +1,429 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const GENERATED_ROOT_DIRNAME = 'FigmaGenerated';
+const GENERATED_LAYOUT_VERSION = 1;
+
+function getConfigDirectory() {
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'FigmaSwiftUICompanion');
+  }
+  return path.join(os.homedir(), '.config', 'FigmaSwiftUICompanion');
+}
+
+function getConfigPath() {
+  return path.join(getConfigDirectory(), 'config.json');
+}
+
+function readConfig() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(config) {
+  const configPath = getConfigPath();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+
+function getSavedProjectPath() {
+  const config = readConfig();
+  return typeof config.projectPath === 'string' && config.projectPath.length > 0
+    ? config.projectPath
+    : null;
+}
+
+function setSavedProjectPath(projectPath) {
+  const resolved = resolveWritableProjectPath(projectPath);
+  writeConfig({
+    ...readConfig(),
+    projectPath: resolved,
+    updatedAt: new Date().toISOString(),
+  });
+  return resolved;
+}
+
+function clearSavedProjectPath() {
+  const config = readConfig();
+  delete config.projectPath;
+  config.updatedAt = new Date().toISOString();
+  writeConfig(config);
+}
+
+function loadProjectPath({ explicitPath } = {}) {
+  if (explicitPath) {
+    return resolveWritableProjectPath(explicitPath);
+  }
+
+  if (process.env.FIGMA_SWIFTUI_PROJECT_PATH) {
+    return resolveWritableProjectPath(process.env.FIGMA_SWIFTUI_PROJECT_PATH);
+  }
+
+  return getSavedProjectPath();
+}
+
+function writeSwiftUIScreen({ targetDir, code, structName, images = [] }) {
+  const resolvedTarget = resolveWritableProjectPath(targetDir);
+  const generatedDirs = ensureGeneratedLayout(resolvedTarget);
+  const results = {
+    swiftFile: null,
+    images: [],
+    manifestFiles: [],
+    generatedRoot: generatedDirs.rootDir,
+    errors: [],
+  };
+
+  if (code && structName) {
+    const swiftPath = path.join(generatedDirs.screensDir, `${structName}.swift`);
+    try {
+      fs.writeFileSync(swiftPath, code, 'utf8');
+      results.swiftFile = swiftPath;
+    } catch (error) {
+      results.errors.push(`Failed to write ${structName}.swift: ${error.message}`);
+    }
+  }
+
+  if (Array.isArray(images) && images.length > 0) {
+    const assetResult = writeAssetCatalogEntries({
+      targetDir: resolvedTarget,
+      assets: images.map((image) => ({
+        name: image.name,
+        format: image.format || 'png',
+        base64: image.base64,
+        svg: image.svg,
+      })),
+    });
+    results.images.push(...assetResult.files);
+    results.errors.push(...assetResult.errors);
+  }
+
+  if (code && structName) {
+    try {
+      const manifestFiles = writeGeneratedManifest(resolvedTarget, generatedDirs, {
+        structName,
+        code,
+        swiftFile: results.swiftFile,
+        images: Array.isArray(images) ? images : [],
+      });
+      results.manifestFiles.push(...manifestFiles);
+    } catch (error) {
+      results.errors.push(`Failed to update generated manifest: ${error.message}`);
+    }
+  }
+
+  return {
+    ok: results.errors.length === 0,
+    results,
+    projectPath: resolvedTarget,
+    generatedRoot: generatedDirs.rootDir,
+    layoutVersion: GENERATED_LAYOUT_VERSION,
+  };
+}
+
+function writeAssetCatalogEntries({ targetDir, assets = [] }) {
+  const resolvedTarget = resolveWritableProjectPath(targetDir);
+  const xcassetsDir = findOrCreateXcassets(resolvedTarget);
+  const files = [];
+  const errors = [];
+
+  for (const asset of assets) {
+    try {
+      const imagesetDir = path.join(xcassetsDir, `${asset.name}.imageset`);
+      fs.mkdirSync(imagesetDir, { recursive: true });
+
+      if (asset.format === 'svg') {
+        const svgPath = path.join(imagesetDir, `${asset.name}.svg`);
+        fs.writeFileSync(svgPath, asset.svg, 'utf8');
+        fs.writeFileSync(
+          path.join(imagesetDir, 'Contents.json'),
+          JSON.stringify({
+            images: [
+              { idiom: 'universal', filename: `${asset.name}.svg` },
+            ],
+            properties: {
+              'preserves-vector-representation': true,
+            },
+            info: { version: 1, author: 'figma-swiftui-plugin' },
+          }, null, 2),
+          'utf8'
+        );
+        files.push(svgPath);
+        continue;
+      }
+
+      const pngPath = path.join(imagesetDir, `${asset.name}.png`);
+      const pngBuffer = Buffer.from(asset.base64, 'base64');
+      fs.writeFileSync(pngPath, pngBuffer);
+      fs.writeFileSync(
+        path.join(imagesetDir, 'Contents.json'),
+        JSON.stringify({
+          images: [
+            { idiom: 'universal', scale: '1x' },
+            { idiom: 'universal', scale: '2x', filename: `${asset.name}.png` },
+            { idiom: 'universal', scale: '3x' },
+          ],
+          info: { version: 1, author: 'figma-swiftui-plugin' },
+        }, null, 2),
+        'utf8'
+      );
+      files.push(pngPath);
+    } catch (error) {
+      errors.push(`Failed to write image ${asset.name}: ${error.message}`);
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    xcassetsDir,
+    files,
+    errors,
+  };
+}
+
+function inferStructName({ structName, code, selectionNames = [] }) {
+  if (structName && typeof structName === 'string') {
+    return sanitizeName(structName) || 'GeneratedView';
+  }
+
+  if (typeof code === 'string') {
+    const match = code.match(/struct\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*View\b/);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+
+  if (selectionNames.length > 0) {
+    return sanitizeName(selectionNames[0]) || 'GeneratedView';
+  }
+
+  return 'GeneratedView';
+}
+
+function sanitizeName(name) {
+  return String(name)
+    .replace(/[^a-zA-Z0-9 ]/g, '')
+    .replace(/\s+(.)/g, (_, c) => c.toUpperCase())
+    .replace(/^\w/, c => c.toUpperCase())
+    .trim();
+}
+
+function findOrCreateXcassets(targetDir) {
+  const entries = fs.readdirSync(targetDir);
+  const existing = entries.find((entry) => entry.endsWith('.xcassets'));
+  if (existing) {
+    return path.join(targetDir, existing);
+  }
+
+  const newDir = path.join(targetDir, 'Assets.xcassets');
+  fs.mkdirSync(newDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(newDir, 'Contents.json'),
+    JSON.stringify({ info: { version: 1, author: 'xcode' } }, null, 2),
+    'utf8'
+  );
+  return newDir;
+}
+
+function ensureGeneratedLayout(targetDir) {
+  const rootDir = path.join(targetDir, GENERATED_ROOT_DIRNAME);
+  const screensDir = path.join(rootDir, 'Screens');
+  const componentsDir = path.join(rootDir, 'Components');
+  const manifestDir = path.join(rootDir, 'Manifest');
+
+  [rootDir, screensDir, componentsDir, manifestDir].forEach((dirPath) => {
+    fs.mkdirSync(dirPath, { recursive: true });
+  });
+
+  return { rootDir, screensDir, componentsDir, manifestDir };
+}
+
+function writeGeneratedManifest(targetDir, generatedDirs, payload) {
+  const { structName, code, swiftFile, images } = payload;
+  const generatedAt = new Date().toISOString();
+  const codeHash = crypto.createHash('sha256').update(code, 'utf8').digest('hex');
+  const screenManifestPath = path.join(generatedDirs.manifestDir, `${structName}.json`);
+  const indexManifestPath = path.join(generatedDirs.manifestDir, 'index.json');
+  const xcassetsDir = findOrCreateXcassets(targetDir);
+
+  const screenManifest = {
+    schemaVersion: GENERATED_LAYOUT_VERSION,
+    generatedAt,
+    structName,
+    codeHash,
+    screenFile: swiftFile ? toProjectRelativePath(targetDir, swiftFile) : null,
+    componentFiles: [],
+    assetCatalog: toProjectRelativePath(targetDir, xcassetsDir),
+    assets: images.map((image) => ({
+      name: image.name,
+      imageset: `Assets.xcassets/${image.name}.imageset`,
+    })),
+  };
+
+  fs.writeFileSync(screenManifestPath, JSON.stringify(screenManifest, null, 2), 'utf8');
+
+  let indexManifest = {
+    schemaVersion: GENERATED_LAYOUT_VERSION,
+    updatedAt: generatedAt,
+    generatedRoot: GENERATED_ROOT_DIRNAME,
+    projectPath: targetDir,
+    screens: [],
+  };
+
+  if (fs.existsSync(indexManifestPath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(indexManifestPath, 'utf8'));
+      if (parsed && typeof parsed === 'object' && Array.isArray(parsed.screens)) {
+        indexManifest = {
+          ...indexManifest,
+          ...parsed,
+          screens: parsed.screens,
+        };
+      }
+    } catch {
+      // Ignore invalid existing manifest; it will be replaced.
+    }
+  }
+
+  indexManifest.updatedAt = generatedAt;
+  indexManifest.projectPath = targetDir;
+  indexManifest.generatedRoot = GENERATED_ROOT_DIRNAME;
+  indexManifest.screens = [
+    ...indexManifest.screens.filter((screen) => screen.structName !== structName),
+    {
+      structName,
+      generatedAt,
+      codeHash,
+      screenFile: screenManifest.screenFile,
+      manifestFile: toProjectRelativePath(targetDir, screenManifestPath),
+      assetCount: screenManifest.assets.length,
+      assets: screenManifest.assets.map((asset) => asset.name),
+    },
+  ].sort((left, right) => left.structName.localeCompare(right.structName));
+
+  fs.writeFileSync(indexManifestPath, JSON.stringify(indexManifest, null, 2), 'utf8');
+  return [screenManifestPath, indexManifestPath];
+}
+
+function toProjectRelativePath(targetDir, filePath) {
+  return path.relative(targetDir, filePath).replace(/\\/g, '/');
+}
+
+function resolveWritableProjectPath(inputPath) {
+  const resolved = path.resolve(inputPath);
+  if (!fs.existsSync(resolved)) {
+    return resolved;
+  }
+
+  const stats = fs.statSync(resolved);
+  if (!stats.isDirectory()) {
+    const parentDir = path.dirname(resolved);
+    const projectBaseName = path.basename(resolved, path.extname(resolved));
+    const matchingChild = path.join(parentDir, projectBaseName);
+    if (looksLikeSourceDirectory(matchingChild)) {
+      return matchingChild;
+    }
+    return parentDir;
+  }
+
+  const localProjectNames = getLocalProjectNames(resolved);
+  const currentScore = scoreSourceDirectory(resolved);
+
+  const childDirs = fs.readdirSync(resolved, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.name.endsWith('.xcodeproj') && !entry.name.endsWith('.xcworkspace'))
+    .map((entry) => path.join(resolved, entry.name));
+
+  const sourceCandidates = childDirs
+    .filter(looksLikeSourceDirectory)
+    .sort((left, right) => scoreSourceDirectory(right, localProjectNames) - scoreSourceDirectory(left, localProjectNames));
+
+  if (sourceCandidates.length > 0) {
+    const bestChild = sourceCandidates[0];
+    const bestChildScore = scoreSourceDirectory(bestChild, localProjectNames);
+    const childName = path.basename(bestChild);
+
+    if (
+      localProjectNames.has(childName) ||
+      bestChildScore > currentScore ||
+      !looksLikeSourceDirectory(resolved)
+    ) {
+      return bestChild;
+    }
+  }
+
+  if (looksLikeSourceDirectory(resolved)) {
+    return resolved;
+  }
+
+  return resolved;
+}
+
+function getLocalProjectNames(dirPath) {
+  const projectNames = new Set();
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    if (entry.name.endsWith('.xcodeproj') || entry.name.endsWith('.xcworkspace')) {
+      projectNames.add(path.basename(entry.name, path.extname(entry.name)));
+    }
+  }
+  return projectNames;
+}
+
+function looksLikeSourceDirectory(dirPath) {
+  if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
+    return false;
+  }
+
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  return entries.some((entry) => entry.isFile() && entry.name.endsWith('.swift'))
+    || entries.some((entry) => entry.isDirectory() && entry.name.endsWith('.xcassets'));
+}
+
+function scoreSourceDirectory(dirPath, preferredNames = new Set()) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  let score = 0;
+
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith('.swift')) {
+      score += 2;
+      if (entry.name.endsWith('App.swift')) {
+        score += 3;
+      }
+    }
+    if (entry.isDirectory() && entry.name.endsWith('.xcassets')) {
+      score += 4;
+    }
+  }
+
+  if (preferredNames.has(path.basename(dirPath))) {
+    score += 10;
+  }
+
+  return score;
+}
+
+module.exports = {
+  GENERATED_ROOT_DIRNAME,
+  GENERATED_LAYOUT_VERSION,
+  clearSavedProjectPath,
+  getConfigPath,
+  getSavedProjectPath,
+  inferStructName,
+  loadProjectPath,
+  resolveWritableProjectPath,
+  setSavedProjectPath,
+  writeAssetCatalogEntries,
+  writeSwiftUIScreen,
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@createlex/figma-swiftui-mcp",
+  "version": "1.0.0",
+  "description": "CreateLex MCP runtime for Figma-to-SwiftUI generation and Xcode export",
+  "bin": {
+    "figma-swiftui-mcp": "bin/figma-swiftui-mcp.js"
+  },
+  "files": [
+    "bin/",
+    "companion/bridge-server.cjs",
+    "companion/createlex-auth.cjs",
+    "companion/login.mjs",
+    "companion/mcp-server.mjs",
+    "companion/package.json",
+    "companion/server.js",
+    "companion/xcode-writer.cjs",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "postinstall": "npm --prefix companion install",
+    "build": "tsc",
+    "login": "node bin/figma-swiftui-mcp.js login",
+    "start": "node bin/figma-swiftui-mcp.js start",
+    "watch": "tsc --watch",
+    "test:bridge-smoke": "node ../tests/mcp/figma_plugin_swiftui_bridge_smoke.mjs",
+    "test:high-fidelity-smoke": "node ../tests/mcp/figma_plugin_swiftui_high_fidelity_smoke.mjs",
+    "start:companion:mcp": "node bin/figma-swiftui-mcp.js start"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@figma/plugin-typings": "*",
+    "typescript": "^5.4.0"
+  }
+}