@createlex/figgen 1.4.2

package/companion/local-llm-generator.cjs

@@ -0,0 +1,437 @@
+'use strict';
+
+/**
+ * local-llm-generator.cjs
+ *
+ * BYOK (Bring Your Own Key) SwiftUI generation.
+ * Uses ANTHROPIC_API_KEY, OPENAI_API_KEY, or an OpenAI-compatible
+ * base URL (e.g. Ollama, LM Studio) to generate SwiftUI without
+ * touching the CreateLex hosted backend.
+ *
+ * Required env vars (at least one):
+ *   ANTHROPIC_API_KEY  — use Claude (recommended)
+ *   OPENAI_API_KEY     — use OpenAI or compatible API
+ *
+ * Optional:
+ *   OPENAI_MODEL       — model name (default: gpt-4o)
+ *   OPENAI_BASE_URL    — custom base URL for Ollama / LM Studio etc.
+ */
+
+// ---------------------------------------------------------------------------
+// Prompt constants
+// ---------------------------------------------------------------------------
+
+const SWIFTUI_SYSTEM_PROMPT = `You are an expert SwiftUI engineer generating production-ready iOS code from Figma design context JSON.
+
+RULES:
+1. Output ONLY valid Swift code inside <file name="StructName.swift"> XML tags — one tag per file.
+2. Always import SwiftUI. Never import UIKit or use UIViewRepresentable.
+3. Map Figma layoutMode: HORIZONTAL→HStack, VERTICAL→VStack, NONE→ZStack/overlay.
+4. Use the struct name supplied in OUTPUT_STRUCT_NAME for the primary view.
+5. Responsive sizing: follow every _responsiveHint annotation in the node tree.
+6. For colors: use Color extension token names when a styleName is present; otherwise Color(red:green:blue:).
+7. Generate @State vars for every interactive element (TextField, Toggle, Button, Picker).
+8. Add .accessibilityLabel() and .accessibilityHint() derived from node name and text content.
+9. End every file with a #Preview { StructName() } block.
+10. Emit best-effort code for anything complex — never emit TODO comments or placeholder stubs.
+11. If reusableComponents are present, output each as a separate <file name="ComponentName.swift"> tag.
+12. FONTS: Always use .font(.system(size: X, weight: .bold)) — NEVER reference custom font names like "Inter-Bold", "Roboto", or any fontName from Figma. Custom fonts are not bundled in the Xcode project and will cause runtime errors. System font only.
+13. IMAGES: Every node listed in assetExportPlan MUST be referenced as Image("assetName").resizable().scaledToFill() — NEVER replace with Rectangle(), Color, or shapes. These PNGs are pre-exported to Assets.xcassets.
+14. BLEND MODES: If an assetExportPlan candidate has a non-null blendModeSwiftUI value, you MUST append that modifier to the Image() call, e.g.: Image("Mockup_GroupView2").resizable().scaledToFit().frame(...).blendMode(.multiply). Without this, the image background will not blend with the dark frame background and will show as an opaque rectangle. Map: MULTIPLY→.multiply, SCREEN→.screen, OVERLAY→.overlay, DARKEN→.darken, LIGHTEN→.lighten, COLOR_DODGE→.colorDodge, COLOR_BURN→.colorBurn, HARD_LIGHT→.hardLight, SOFT_LIGHT→.softLight, DIFFERENCE→.difference, EXCLUSION→.exclusion.
+
+RESPONSIVE LAYOUT RULES:
+- Root frame with FILL sizing → .frame(maxWidth: .infinity)
+- Font sizes → @ScaledMetric var: e.g. @ScaledMetric var titleSize: CGFloat = 34
+- Horizontal scrolling children → ScrollView(.horizontal, showsIndicators: false)
+- Vertical root scroll behavior → wrap body in ScrollView
+- ViewThatFits for HStack→VStack fallback on narrow devices when content may wrap
+- VStack(spacing:) / HStack(spacing:) from Figma itemSpacing — not fixed .padding() for inter-item spacing
+- .ignoresSafeArea() only for background color/image layers, never for foreground content
+- Hardcoded values are acceptable only for: cornerRadius, icon sizes ≤24pt, stroke widths
+
+DESIGN TOKENS:
+If designTokens.colors or designTokens.fonts are non-empty, output a <file name="DesignTokens.swift"> containing:
+  extension Color { static let tokenName = Color(red: ..., green: ..., blue: ...) }
+  extension Font { static let tokenName = .system(size: ..., weight: ...) }
+Then use these token names everywhere in the main view code.
+
+REUSABLE COMPONENTS:
+For each item in reusableComponents:
+- Output a separate <file name="ComponentName.swift">
+- Promote repeated values (text, colors, image names) into View parameters
+- In the parent view, replace inline rendering with ComponentName(param: value)`;
+
+// ---------------------------------------------------------------------------
+// Context helpers
+// ---------------------------------------------------------------------------
+
+function cleanText(value) {
+  return typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+}
+
+function sanitizeName(value) {
+  const words = cleanText(value)
+    .replace(/[^a-zA-Z0-9]+/g, ' ')
+    .split(' ')
+    .filter(Boolean);
+  if (words.length === 0) return 'GeneratedView';
+  return words.map((w) => w[0].toUpperCase() + w.slice(1)).join('');
+}
+
+function getRootNode(metadata) {
+  if (!metadata || typeof metadata !== 'object') return null;
+  if (Array.isArray(metadata.nodes)) {
+    return metadata.nodes.length === 1 ? metadata.nodes[0] : null;
+  }
+  return metadata.type ? metadata : null;
+}
+
+function flattenNodes(node, limit = 200) {
+  const results = [];
+  const visit = (current) => {
+    if (!current || typeof current !== 'object' || results.length >= limit) return;
+    results.push(current);
+    if (Array.isArray(current.children)) {
+      current.children.forEach(visit);
+    }
+  };
+  visit(node);
+  return results;
+}
+
+function annotateResponsiveHints(node, rootWidth) {
+  if (!node || !rootWidth) return node;
+  const width = node?.geometry?.width;
+  if (typeof width === 'number' && width > 0) {
+    const frac = width / rootWidth;
+    if (frac > 0.5 && frac < 1.0) {
+      node._responsiveHint = `width is ~${Math.round(frac * 100)}% of root canvas — use .frame(maxWidth: .infinity) with horizontal padding`;
+    }
+  }
+  if (Array.isArray(node.children)) {
+    node.children.forEach((child) => annotateResponsiveHints(child, rootWidth));
+  }
+  return node;
+}
+
+function pruneNodeTree(root, maxNodes) {
+  const all = flattenNodes(root, maxNodes);
+  const ids = new Set(all.map((n) => n.id));
+
+  function prune(node) {
+    if (!node) return node;
+    const pruned = { ...node };
+    if (Array.isArray(pruned.children)) {
+      pruned.children = pruned.children
+        .filter((c) => ids.has(c?.id))
+        .map(prune);
+    }
+    return pruned;
+  }
+
+  return prune(root);
+}
+
+function extractDesignTokens(rootNode) {
+  const colors = new Map();
+  const fonts = new Map();
+  const radiusCounts = new Map();
+
+  function toSwiftTokenName(styleName) {
+    return styleName
+      .replace(/[^a-zA-Z0-9/]+/g, ' ')
+      .split(/[\s/]+/)
+      .filter(Boolean)
+      .map((w, i) => i === 0 ? w[0].toLowerCase() + w.slice(1) : w[0].toUpperCase() + w.slice(1))
+      .join('');
+  }
+
+  flattenNodes(rootNode, 500).forEach((node) => {
+    const style = node.style;
+    if (!style) return;
+
+    if (style.styleName && Array.isArray(style.fills)) {
+      const fill = style.fills.find((f) => f && f.visible !== false && f.type === 'SOLID' && f.color);
+      if (fill) colors.set(toSwiftTokenName(style.styleName), fill.color);
+    }
+
+    if (node.type === 'TEXT' && style.styleName && node.text?.fontSize) {
+      fonts.set(toSwiftTokenName(style.styleName), {
+        size: node.text.fontSize,
+        weight: node.text.fontName?.style,
+      });
+    }
+
+    if (typeof style.cornerRadius === 'number' && style.cornerRadius > 0) {
+      radiusCounts.set(style.cornerRadius, (radiusCounts.get(style.cornerRadius) ?? 0) + 1);
+    }
+  });
+
+  return {
+    colors: [...colors.entries()].map(([name, color]) => ({ name, color })),
+    fonts: [...fonts.entries()].map(([name, font]) => ({ name, ...font })),
+    commonRadii: [...radiusCounts.entries()].filter(([, count]) => count >= 3).map(([r]) => r),
+  };
+}
+
+function buildPromptContext(context) {
+  const root = getRootNode(context?.metadata);
+  if (!root) return null;
+
+  const rootWidth = root?.geometry?.width ?? 390;
+  const prunedRoot = pruneNodeTree(root, 200);
+  annotateResponsiveHints(prunedRoot, rootWidth);
+
+  const designTokens = extractDesignTokens(root);
+  const structName = sanitizeName(root.name || 'GeneratedView');
+
+  return {
+    structName,
+    canvasWidth: rootWidth,
+    canvasHeight: root?.geometry?.height ?? 844,
+    nodeTree: prunedRoot,
+    designTokens,
+    reusableComponents: (context?.reusableComponents?.candidates ?? []).slice(0, 10),
+    assetRequests: (context?.assetExportPlan?.candidates ?? []).slice(0, 10),
+    generationHints: context?.generationHints ?? null,
+  };
+}
+
+function buildUserMessage(context, generationMode) {
+  const promptCtx = buildPromptContext(context);
+  if (!promptCtx) {
+    throw new Error('Could not extract root node from design context');
+  }
+
+  return `Generate SwiftUI code for this Figma design.
+
+OUTPUT_STRUCT_NAME: ${promptCtx.structName}
+CANVAS_WIDTH: ${promptCtx.canvasWidth}
+GENERATION_MODE: ${generationMode}
+
+DESIGN CONTEXT:
+${JSON.stringify(promptCtx, null, 2)}
+
+Output all Swift files using <file name="StructName.swift"> tags.`;
+}
+
+// ---------------------------------------------------------------------------
+// Response parser
+// ---------------------------------------------------------------------------
+
+function parseClaudeResponse(text) {
+  const fileRegex = /<file name="([^"]+\.swift)">([\s\S]*?)<\/file>/g;
+  const files = [];
+  let match;
+  while ((match = fileRegex.exec(text)) !== null) {
+    files.push({ name: match[1], code: match[2].trim() });
+  }
+
+  if (files.length === 0) {
+    // Fallback: treat entire response as primary file code
+    return { code: text.trim(), designTokensCode: null, componentFiles: [] };
+  }
+
+  const tokensFile = files.find((f) => f.name === 'DesignTokens.swift');
+  const primaryName = buildPromptContext !== null
+    ? files.find((f) => f.name !== 'DesignTokens.swift' && !f.name.startsWith('Component') && !f.name.endsWith('Row.swift') && !f.name.endsWith('Card.swift') && !f.name.endsWith('Cell.swift'))
+    : null;
+  const primary = primaryName ?? files.find((f) => f !== tokensFile);
+  const componentFiles = files.filter((f) => f !== primary && f !== tokensFile);
+
+  return {
+    code: primary?.code ?? '',
+    designTokensCode: tokensFile?.code ?? null,
+    componentFiles,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Anthropic generation
+// ---------------------------------------------------------------------------
+
+async function generateWithAnthropic(context, generationMode, apiKey) {
+  let Anthropic;
+  try {
+    ({ Anthropic } = require('@anthropic-ai/sdk'));
+  } catch {
+    throw new Error('ANTHROPIC_API_KEY is set but @anthropic-ai/sdk is not installed. Run: npm install @anthropic-ai/sdk');
+  }
+
+  const client = new Anthropic({ apiKey });
+  const userMessage = buildUserMessage(context, generationMode);
+
+  const response = await client.messages.create({
+    model: process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-6',
+    max_tokens: 8192,
+    system: SWIFTUI_SYSTEM_PROMPT,
+    messages: [{ role: 'user', content: userMessage }],
+  });
+
+  const text = response.content
+    .filter((b) => b.type === 'text')
+    .map((b) => b.text)
+    .join('');
+
+  return parseClaudeResponse(text);
+}
+
+// ---------------------------------------------------------------------------
+// OpenAI-compatible generation (OpenAI, Ollama, LM Studio, etc.)
+// ---------------------------------------------------------------------------
+
+async function generateWithOpenAI(context, generationMode, apiKey) {
+  let OpenAI;
+  try {
+    ({ OpenAI } = require('openai'));
+  } catch {
+    throw new Error('OPENAI_API_KEY is set but the openai package is not installed. Run: npm install openai');
+  }
+
+  const client = new OpenAI({
+    apiKey,
+    baseURL: process.env.OPENAI_BASE_URL || undefined,
+  });
+
+  const model = process.env.OPENAI_MODEL || 'gpt-4o';
+  const userMessage = buildUserMessage(context, generationMode);
+
+  const response = await client.chat.completions.create({
+    model,
+    max_tokens: 8192,
+    messages: [
+      { role: 'system', content: SWIFTUI_SYSTEM_PROMPT },
+      { role: 'user', content: userMessage },
+    ],
+  });
+
+  const text = response.choices[0]?.message?.content ?? '';
+  return parseClaudeResponse(text);
+}
+
+// ---------------------------------------------------------------------------
+// Hugging Face Inference API
+//
+// Uses HF's OpenAI-compatible endpoint: https://api-inference.huggingface.co/v1
+//
+// Best models for SwiftUI generation (set HF_MODEL to override):
+//   Qwen/Qwen2.5-Coder-32B-Instruct  — default, best open-source code model
+//   meta-llama/Llama-3.3-70B-Instruct — strong reasoning + code
+//   deepseek-ai/DeepSeek-Coder-V2-Instruct — excellent complex code
+//   Qwen/Qwen2.5-Coder-7B-Instruct   — faster/cheaper for simpler screens
+//
+// Env vars:
+//   HF_API_TOKEN  — required
+//   HF_MODEL      — optional, defaults to Qwen2.5-Coder-32B-Instruct
+// ---------------------------------------------------------------------------
+
+const HF_INFERENCE_BASE_URL = 'https://api-inference.huggingface.co/v1';
+const HF_DEFAULT_MODEL = 'Qwen/Qwen2.5-Coder-32B-Instruct';
+
+async function generateWithHuggingFace(context, generationMode, apiKey) {
+  let OpenAI;
+  try {
+    ({ OpenAI } = require('openai'));
+  } catch {
+    throw new Error('HF_API_TOKEN is set but the openai package is not installed. Run: npm install openai');
+  }
+
+  const model = process.env.HF_MODEL || HF_DEFAULT_MODEL;
+  const client = new OpenAI({
+    apiKey,
+    baseURL: HF_INFERENCE_BASE_URL,
+  });
+
+  const userMessage = buildUserMessage(context, generationMode);
+
+  const response = await client.chat.completions.create({
+    model,
+    max_tokens: 8192,
+    messages: [
+      { role: 'system', content: SWIFTUI_SYSTEM_PROMPT },
+      { role: 'user', content: userMessage },
+    ],
+  });
+
+  const text = response.choices[0]?.message?.content ?? '';
+  return parseClaudeResponse(text);
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the SwiftUI system prompt and a formatted user message for AI-native
+ * generation. AI tools (Claude Code, Cursor, Windsurf, etc.) call this to get a
+ * ready-to-use prompt, then generate code with their own model and call
+ * write_generated_swiftui_to_xcode — burning zero CreateLex tokens.
+ */
+function buildGenerationPrompt(context) {
+  const promptCtx = buildPromptContext(context);
+  if (!promptCtx) return null;
+
+  return {
+    systemPrompt: SWIFTUI_SYSTEM_PROMPT,
+    userMessage: buildUserMessage(context, 'editable'),
+    outputStructName: promptCtx.structName,
+    assetRequests: promptCtx.assetRequests,
+    canvasWidth: promptCtx.canvasWidth,
+  };
+}
+
+/**
+ * Generate SwiftUI using the user's own API key (BYOK).
+ *
+ * Priority order:
+ *   1. ANTHROPIC_API_KEY  → Claude (best quality, recommended)
+ *   2. HF_API_TOKEN       → Hugging Face (Qwen2.5-Coder-32B by default — best open-source)
+ *   3. OPENAI_API_KEY     → OpenAI or any OpenAI-compatible endpoint (Ollama, LM Studio)
+ *
+ * Returns: { handled, provider, code, designTokensCode, componentFiles, diagnostics }
+ */
+async function generateWithLocalKey(context, generationMode = 'editable') {
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  const hfKey = process.env.HF_API_TOKEN;
+  const openaiKey = process.env.OPENAI_API_KEY;
+
+  if (!anthropicKey && !hfKey && !openaiKey) {
+    return null; // No BYOK configured — caller should try next tier
+  }
+
+  let parsed;
+  let provider;
+
+  if (anthropicKey) {
+    parsed = await generateWithAnthropic(context, generationMode, anthropicKey);
+    provider = `local-anthropic:${process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-6'}`;
+  } else if (hfKey) {
+    const model = process.env.HF_MODEL || HF_DEFAULT_MODEL;
+    parsed = await generateWithHuggingFace(context, generationMode, hfKey);
+    provider = `huggingface:${model}`;
+  } else {
+    parsed = await generateWithOpenAI(context, generationMode, openaiKey);
+    const baseUrl = process.env.OPENAI_BASE_URL;
+    const model = process.env.OPENAI_MODEL || 'gpt-4o';
+    provider = baseUrl ? `local-openai-compatible:${model}` : `local-openai:${model}`;
+  }
+
+  return {
+    handled: true,
+    provider,
+    screenType: 'llm-generated',
+    code: parsed.code,
+    designTokensCode: parsed.designTokensCode,
+    componentFiles: parsed.componentFiles,
+    assetRequests: [],
+    diagnostics: [],
+  };
+}
+
+module.exports = {
+  generateWithLocalKey,
+  buildGenerationPrompt,
+  parseClaudeResponse,
+  buildPromptContext,
+  SWIFTUI_SYSTEM_PROMPT,
+};

package/companion/login.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+import http from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const {
+  AUTH_FILE,
+  ensureApiBaseUrl,
+  saveAuth,
+  validateTokenFormat,
+} = require('./createlex-auth.cjs');
+
+function getLoginBaseUrl() {
+  const explicit = process.env.CREATELEX_LOGIN_BASE_URL?.trim();
+  if (explicit) {
+    return explicit.replace(/\/+$/, '');
+  }
+  return ensureApiBaseUrl(process.env.CREATELEX_API_BASE_URL);
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  if (platform === 'darwin') {
+    spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
+    return;
+  }
+  if (platform === 'win32') {
+    spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' }).unref();
+    return;
+  }
+  spawn('xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+}
+
+function sendHtml(res, statusCode, title, body) {
+  res.writeHead(statusCode, { 'Content-Type': 'text/html; charset=utf-8' });
+  res.end(`<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>${title}</title>
+    <style>
+      body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #0f172a; color: #e2e8f0; display: flex; min-height: 100vh; align-items: center; justify-content: center; margin: 0; }
+      .card { max-width: 560px; padding: 32px; border-radius: 16px; background: #111827; box-shadow: 0 10px 40px rgba(0,0,0,0.35); text-align: center; }
+      h1 { margin-top: 0; font-size: 28px; }
+      p { line-height: 1.5; color: #cbd5e1; }
+      code { background: #1f2937; padding: 2px 6px; border-radius: 6px; }
+    </style>
+  </head>
+  <body>
+    <div class="card">
+      <h1>${title}</h1>
+      ${body}
+    </div>
+  </body>
+</html>`);
+}
+
+async function main() {
+  const args = new Set(process.argv.slice(2));
+  if (args.has('--help') || args.has('-h')) {
+    console.log(`CreateLex figma-swiftui login
+
+Usage:
+  npx @createlex/figma-swiftui-mcp login
+
+Options:
+  --no-open   Print the CreateLex login URL instead of opening a browser
+  --help      Show this help message
+`);
+    return;
+  }
+
+  const noOpen = args.has('--no-open');
+  const state = randomBytes(16).toString('hex');
+  const apiBaseUrl = ensureApiBaseUrl(process.env.CREATELEX_API_BASE_URL);
+  const loginBaseUrl = getLoginBaseUrl();
+
+  let server;
+  const completion = new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Timed out waiting for CreateLex login callback.'));
+    }, 5 * 60 * 1000);
+
+    server = http.createServer((req, res) => {
+      const url = new URL(req.url || '/', 'http://127.0.0.1');
+      if (url.pathname !== '/callback') {
+        sendHtml(res, 404, 'Not Found', '<p>This callback path is reserved for the CreateLex figma-swiftui login flow.</p>');
+        return;
+      }
+
+      const token = url.searchParams.get('token') || '';
+      const refreshToken = url.searchParams.get('refresh_token') || '';
+      const userId = url.searchParams.get('user_id') || '';
+      const email = url.searchParams.get('email') || '';
+      const hasSubscription = url.searchParams.get('has_subscription') === 'true';
+      const returnedState = url.searchParams.get('state') || '';
+      const error = url.searchParams.get('error') || '';
+
+      if (returnedState !== state) {
+        sendHtml(res, 400, 'Login Failed', '<p>The login callback state did not match. Close this window and run <code>npx @createlex/figma-swiftui-mcp login</code> again.</p>');
+        clearTimeout(timeout);
+        reject(new Error('Login callback state mismatch.'));
+        return;
+      }
+
+      if (error) {
+        sendHtml(res, 400, 'Login Failed', `<p>${error}</p><p>Close this window and run <code>npx @createlex/figma-swiftui-mcp login</code> again.</p>`);
+        clearTimeout(timeout);
+        reject(new Error(error));
+        return;
+      }
+
+      if (!hasSubscription) {
+        sendHtml(res, 403, 'Subscription Required', '<p>Your CreateLex account does not have an active subscription for figma-swiftui.</p>');
+        clearTimeout(timeout);
+        reject(new Error('Active CreateLex subscription required for figma-swiftui.'));
+        return;
+      }
+
+      const validation = validateTokenFormat(token);
+      if (!validation.valid) {
+        sendHtml(res, 400, 'Login Failed', '<p>The returned CreateLex token was invalid.</p>');
+        clearTimeout(timeout);
+        reject(new Error(`Returned token invalid: ${validation.reason}`));
+        return;
+      }
+
+      saveAuth({
+        token,
+        refreshToken,
+        refresh_token: refreshToken,
+        userId,
+        email,
+        apiBaseUrl,
+        savedAt: new Date().toISOString(),
+      });
+
+      sendHtml(
+        res,
+        200,
+        'Login Successful',
+        `<p>You are now signed in to CreateLex for <code>figma-swiftui</code>.</p>
+         <p>Auth file written to <code>${AUTH_FILE}</code>.</p>
+         <p>You can close this window and return to Terminal.</p>`
+      );
+
+      clearTimeout(timeout);
+      resolve({ userId, email });
+    });
+
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      if (!address || typeof address === 'string') {
+        clearTimeout(timeout);
+        reject(new Error('Failed to determine local login callback port.'));
+        return;
+      }
+
+      const callbackUrl = `http://127.0.0.1:${address.port}/callback`;
+      const loginUrl = `${loginBaseUrl}/mcp/figma-swiftui/login?callback_url=${encodeURIComponent(callbackUrl)}&state=${encodeURIComponent(state)}`;
+
+      console.log(noOpen ? 'CreateLex login URL:' : 'Opening CreateLex login in your browser...');
+      console.log(`If the browser does not open, visit:\n${loginUrl}\n`);
+      if (!noOpen) {
+        try {
+          openBrowser(loginUrl);
+        } catch (error) {
+          console.warn(`Could not open browser automatically: ${error.message}`);
+        }
+      }
+    });
+  });
+
+  try {
+    const result = await completion;
+    console.log(`CreateLex login saved for ${result.email || result.userId || 'unknown-user'}.`);
+    console.log(`Auth file: ${AUTH_FILE}`);
+  } finally {
+    await new Promise((resolve) => server?.close(() => resolve()));
+  }
+}
+
+main().catch((error) => {
+  console.error(`CreateLex login failed: ${error.message}`);
+  process.exit(1);
+});