figma-coder-mcp 0.1.0

package/dist/bin.js

@@ -0,0 +1,2154 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'module';
+const require = __createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+
+// ../packages/figma-core/dist/errors.js
+var require_errors = __commonJS({
+  "../packages/figma-core/dist/errors.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FigmaApiError = exports.FigmaInputError = void 0;
+    var FigmaInputError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.status = 400;
+        this.name = "FigmaInputError";
+      }
+    };
+    exports.FigmaInputError = FigmaInputError;
+    var FigmaApiError = class extends Error {
+      constructor(message, status, retryAfter, rateLimitType) {
+        super(message);
+        this.status = status;
+        this.retryAfter = retryAfter;
+        this.rateLimitType = rateLimitType;
+        this.name = "FigmaApiError";
+      }
+    };
+    exports.FigmaApiError = FigmaApiError;
+  }
+});
+
+// ../packages/figma-core/dist/adapters.js
+var require_adapters = __commonJS({
+  "../packages/figma-core/dist/adapters.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NoopLogger = exports.ConsoleLogger = exports.DiskCache = exports.MemoryCache = void 0;
+    var crypto_1 = __require("crypto");
+    var fs_1 = __require("fs");
+    var path3 = __importStar(__require("path"));
+    var MemoryCache = class {
+      constructor() {
+        this.mem = /* @__PURE__ */ new Map();
+      }
+      async get(key) {
+        return this.mem.get(key);
+      }
+      async set(key, value) {
+        this.mem.set(key, value);
+      }
+    };
+    exports.MemoryCache = MemoryCache;
+    var DiskCache = class {
+      constructor(dir, logger) {
+        this.logger = logger;
+        this.mem = /* @__PURE__ */ new Map();
+        this.dir = dir ?? path3.resolve(process.cwd(), ".cache");
+      }
+      file(key) {
+        const hash = (0, crypto_1.createHash)("sha1").update(key).digest("hex");
+        return path3.join(this.dir, `${hash}.json`);
+      }
+      async get(key) {
+        if (this.mem.has(key))
+          return this.mem.get(key);
+        try {
+          const raw = await fs_1.promises.readFile(this.file(key), "utf8");
+          const value = JSON.parse(raw);
+          this.mem.set(key, value);
+          return value;
+        } catch {
+          return void 0;
+        }
+      }
+      async set(key, value) {
+        this.mem.set(key, value);
+        try {
+          await fs_1.promises.mkdir(this.dir, { recursive: true });
+          await fs_1.promises.writeFile(this.file(key), JSON.stringify(value));
+        } catch (err) {
+          this.logger?.warn(`cache write failed for "${key}": ${err.message}`);
+        }
+      }
+    };
+    exports.DiskCache = DiskCache;
+    var ConsoleLogger = class {
+      constructor(prefix = "figma-core") {
+        this.prefix = prefix;
+      }
+      log(m) {
+        console.error(`[${this.prefix}] ${m}`);
+      }
+      warn(m) {
+        console.error(`[${this.prefix}] WARN ${m}`);
+      }
+      error(m) {
+        console.error(`[${this.prefix}] ERROR ${m}`);
+      }
+    };
+    exports.ConsoleLogger = ConsoleLogger;
+    var NoopLogger = class {
+      log() {
+      }
+      warn() {
+      }
+      error() {
+      }
+    };
+    exports.NoopLogger = NoopLogger;
+  }
+});
+
+// ../packages/figma-core/dist/figma/url.js
+var require_url = __commonJS({
+  "../packages/figma-core/dist/figma/url.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parseFigmaUrl = parseFigmaUrl;
+    exports.normalizeNodeId = normalizeNodeId;
+    exports.resolveFigmaTarget = resolveFigmaTarget;
+    function parseFigmaUrl(url) {
+      const keyMatch = url.match(/figma\.com\/(?:file|design)\/([A-Za-z0-9]+)/);
+      if (!keyMatch) {
+        throw new Error(`Could not extract fileKey from Figma URL: ${url}`);
+      }
+      const fileKey = keyMatch[1];
+      let nodeId;
+      const nodeMatch = url.match(/[?&]node-id=([^&]+)/);
+      if (nodeMatch) {
+        nodeId = normalizeNodeId(decodeURIComponent(nodeMatch[1]));
+      }
+      return { fileKey, nodeId };
+    }
+    function normalizeNodeId(nodeId) {
+      return nodeId.includes(":") ? nodeId : nodeId.replace("-", ":");
+    }
+    function resolveFigmaTarget(input) {
+      if (input.figmaUrl) {
+        const parsed = parseFigmaUrl(input.figmaUrl);
+        return {
+          fileKey: parsed.fileKey,
+          nodeId: input.nodeId ? normalizeNodeId(input.nodeId) : parsed.nodeId
+        };
+      }
+      if (input.fileKey) {
+        return {
+          fileKey: input.fileKey,
+          nodeId: input.nodeId ? normalizeNodeId(input.nodeId) : void 0
+        };
+      }
+      throw new Error("Provide either figmaUrl or fileKey");
+    }
+  }
+});
+
+// ../packages/figma-core/dist/figma/client.js
+var require_client = __commonJS({
+  "../packages/figma-core/dist/figma/client.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FigmaClient = void 0;
+    var url_1 = require_url();
+    var errors_1 = require_errors();
+    var FIGMA_API = "https://api.figma.com/v1";
+    var FigmaClient = class {
+      constructor(opts) {
+        this.cache = opts.cache;
+        this.logger = opts.logger;
+        this.fallbackToken = opts.fallbackToken;
+      }
+      resolveAuth(requestAuth) {
+        if (requestAuth?.token)
+          return requestAuth;
+        if (this.fallbackToken)
+          return { token: this.fallbackToken, bearer: false };
+        throw new errors_1.FigmaInputError("No Figma credentials. Provide a token (PAT or OAuth) or configure a fallback token.");
+      }
+      async get(path3, auth) {
+        const res = await fetch(`${FIGMA_API}${path3}`, {
+          headers: auth.bearer ? { Authorization: `Bearer ${auth.token}` } : { "X-Figma-Token": auth.token }
+        });
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          if (res.status === 429) {
+            const retryAfter = Number(res.headers.get("retry-after")) || void 0;
+            throw new errors_1.FigmaApiError(`Figma rate limit exceeded for ${path3}.` + (retryAfter ? ` Retry after ~${retryAfter}s (~${Math.round(retryAfter / 3600)}h).` : ""), 429, retryAfter, res.headers.get("x-figma-rate-limit-type") || void 0);
+          }
+          if (res.status === 403) {
+            throw new errors_1.FigmaApiError(auth.bearer ? 'Figma denied access (403). The logged-in Figma account has no access to this file, or the OAuth app is missing the "file_content:read" scope. Open a file your account can access (or duplicate the Community file into your drafts), and ensure the scope is enabled.' : "Figma denied access (403). This token cannot access the file. Check the token and that the account has access to the file.", 403);
+          }
+          throw new errors_1.FigmaApiError(`Figma API ${res.status} for ${path3}: ${body.slice(0, 300)}`, res.status);
+        }
+        return await res.json();
+      }
+      /**
+       * Fetch a single node subtree. If nodeId is omitted, fetches the whole file
+       * and returns its document root.
+       */
+      async fetchNode(fileKey, nodeId, requestAuth) {
+        const auth = this.resolveAuth(requestAuth);
+        const cacheKey = `node:${fileKey}:${nodeId ?? "ROOT"}`;
+        const cached = await this.cache.get(cacheKey);
+        if (cached) {
+          this.logger.log(`fetchNode cache hit (${cacheKey})`);
+          return cached;
+        }
+        let document;
+        if (!nodeId) {
+          const file = await this.get(`/files/${fileKey}`, auth);
+          document = file.document;
+        } else {
+          const id = (0, url_1.normalizeNodeId)(nodeId);
+          const data = await this.get(`/files/${fileKey}/nodes?ids=${encodeURIComponent(id)}`, auth);
+          const entry = data.nodes[id];
+          if (!entry?.document) {
+            throw new errors_1.FigmaInputError(`Node ${id} not found in file ${fileKey}`);
+          }
+          document = entry.document;
+        }
+        await this.cache.set(cacheKey, document);
+        return document;
+      }
+      /**
+       * Render image fills for the given node ids (used by Phase 1 asset export
+       * and Phase 4 visual verification).
+       */
+      async renderImages(fileKey, nodeIds, format = "svg", requestAuth, scale = 1) {
+        const auth = this.resolveAuth(requestAuth);
+        const ids = nodeIds.map(url_1.normalizeNodeId).join(",");
+        const data = await this.get(`/images/${fileKey}?ids=${encodeURIComponent(ids)}&format=${format}&scale=${scale}`, auth);
+        if (data.err) {
+          throw new errors_1.FigmaApiError(`Figma image render error: ${data.err}`, 502);
+        }
+        return data.images;
+      }
+      /**
+       * Fetch every image FILL URL in the file (imageRef -> CDN URL) in one call.
+       *
+       * Unlike /v1/images (server-side render — the most rate-limited, cost-based
+       * Figma endpoint), this returns the originals already uploaded to Figma's
+       * CDN. So all image fills cost a single cheap request regardless of how many
+       * nodes use them, and survive when the render endpoint is throttled.
+       */
+      async getImageFills(fileKey, requestAuth) {
+        const auth = this.resolveAuth(requestAuth);
+        const data = await this.get(`/files/${fileKey}/images`, auth);
+        return data.meta?.images ?? {};
+      }
+    };
+    exports.FigmaClient = FigmaClient;
+  }
+});
+
+// ../packages/figma-core/dist/figma/types.js
+var require_types = __commonJS({
+  "../packages/figma-core/dist/figma/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../packages/figma-core/dist/converter/color.js
+var require_color = __commonJS({
+  "../packages/figma-core/dist/converter/color.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.figmaColorToCss = figmaColorToCss;
+    exports.px = px;
+    function channel(v) {
+      return Math.round(Math.max(0, Math.min(1, v)) * 255);
+    }
+    function toHex2(n) {
+      return n.toString(16).padStart(2, "0");
+    }
+    function figmaColorToCss(color, extraOpacity = 1) {
+      const r = channel(color.r);
+      const g = channel(color.g);
+      const b = channel(color.b);
+      const a = Math.max(0, Math.min(1, (color.a ?? 1) * extraOpacity));
+      if (a >= 1) {
+        return `#${toHex2(r)}${toHex2(g)}${toHex2(b)}`;
+      }
+      return `rgba(${r}, ${g}, ${b}, ${Number(a.toFixed(3))})`;
+    }
+    function px(value) {
+      return `${Number(value.toFixed(2))}px`;
+    }
+  }
+});
+
+// ../packages/figma-core/dist/converter/style-ir.js
+var require_style_ir = __commonJS({
+  "../packages/figma-core/dist/converter/style-ir.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.StyleIr = void 0;
+    var color_1 = require_color();
+    var ALIGN_MAIN = {
+      MIN: "flex-start",
+      CENTER: "center",
+      MAX: "flex-end",
+      SPACE_BETWEEN: "space-between"
+    };
+    var ALIGN_CROSS = {
+      MIN: "flex-start",
+      CENTER: "center",
+      MAX: "flex-end",
+      BASELINE: "baseline"
+    };
+    var StyleIr = class {
+      /** Convert a Figma node subtree into the Style IR tree. */
+      convert(root) {
+        return this.walk(root, void 0);
+      }
+      walk(node, parent) {
+        const css = {};
+        const asset = this.detectAsset(node);
+        this.applyLayout(node, parent, css);
+        this.applySize(node, parent, css);
+        if (!node.isMask) {
+          this.applyFills(node, css, asset);
+          this.applyStroke(node, css);
+          this.applyRadius(node, css);
+          this.applyEffects(node, css);
+        }
+        this.applyOpacity(node, css);
+        const isText = node.type === "TEXT";
+        if (isText)
+          this.applyText(node, css);
+        const tag = isText ? "p" : "div";
+        const visibleChildren = (node.children ?? []).filter((c) => c.visible !== false);
+        const maskChild = visibleChildren.find((c) => c.isMask);
+        if (maskChild) {
+          css.overflow = "hidden";
+          if (!css.position)
+            css.position = "relative";
+          this.applyRadius(maskChild, css);
+        }
+        const children = visibleChildren.map((c) => this.walk(c, node));
+        return {
+          id: node.id,
+          name: node.name,
+          figmaType: node.type,
+          tag,
+          ...isText ? { text: node.characters ?? "" } : {},
+          css,
+          ...asset ? { asset } : {},
+          children
+        };
+      }
+      // ---- layout -------------------------------------------------------------
+      applyLayout(node, parent, css) {
+        const auto = node.layoutMode === "HORIZONTAL" || node.layoutMode === "VERTICAL";
+        if (auto) {
+          css.display = "flex";
+          css["flex-direction"] = node.layoutMode === "VERTICAL" ? "column" : "row";
+          if (node.layoutWrap === "WRAP")
+            css["flex-wrap"] = "wrap";
+          if (node.primaryAxisAlignItems && ALIGN_MAIN[node.primaryAxisAlignItems]) {
+            css["justify-content"] = ALIGN_MAIN[node.primaryAxisAlignItems];
+          }
+          if (node.counterAxisAlignItems && ALIGN_CROSS[node.counterAxisAlignItems]) {
+            css["align-items"] = ALIGN_CROSS[node.counterAxisAlignItems];
+          }
+          if (node.itemSpacing)
+            css.gap = (0, color_1.px)(node.itemSpacing);
+          const pt = node.paddingTop ?? 0;
+          const pr = node.paddingRight ?? 0;
+          const pb = node.paddingBottom ?? 0;
+          const pl = node.paddingLeft ?? 0;
+          if (pt || pr || pb || pl) {
+            css.padding = `${(0, color_1.px)(pt)} ${(0, color_1.px)(pr)} ${(0, color_1.px)(pb)} ${(0, color_1.px)(pl)}`;
+          }
+        }
+        const parentAuto = parent && (parent.layoutMode === "HORIZONTAL" || parent.layoutMode === "VERTICAL");
+        if (parent && !parentAuto && node.absoluteBoundingBox && parent.absoluteBoundingBox) {
+          css.position = "absolute";
+          css.left = (0, color_1.px)(node.absoluteBoundingBox.x - parent.absoluteBoundingBox.x);
+          css.top = (0, color_1.px)(node.absoluteBoundingBox.y - parent.absoluteBoundingBox.y);
+        }
+        const hasChildren = (node.children?.length ?? 0) > 0;
+        if (!auto && hasChildren && !css.position) {
+          css.position = "relative";
+        }
+        if (node.clipsContent)
+          css.overflow = "hidden";
+      }
+      applySize(node, parent, css) {
+        const box = node.absoluteBoundingBox;
+        if (!box)
+          return;
+        css.width = (0, color_1.px)(box.width);
+        css.height = (0, color_1.px)(box.height);
+      }
+      // ---- paints -------------------------------------------------------------
+      visiblePaints(paints) {
+        return (paints ?? []).filter((p) => p.visible !== false);
+      }
+      applyFills(node, css, asset) {
+        if (node.type === "TEXT")
+          return;
+        if (asset?.kind === "vector")
+          return;
+        const fills = this.visiblePaints(node.fills);
+        if (!fills.length)
+          return;
+        const paint = fills[fills.length - 1];
+        if (paint.type === "SOLID" && paint.color) {
+          css["background-color"] = (0, color_1.figmaColorToCss)(paint.color, paint.opacity ?? 1);
+        } else if (paint.type === "GRADIENT_LINEAR") {
+          const grad = this.linearGradient(paint);
+          if (grad)
+            css["background-image"] = grad;
+        } else if (paint.type === "IMAGE") {
+          css["background-size"] = "cover";
+          css["background-position"] = "center";
+        }
+      }
+      linearGradient(paint) {
+        const stops = paint.gradientStops ?? [];
+        if (stops.length < 2)
+          return null;
+        let angle = 180;
+        const handles = paint.gradientHandlePositions;
+        if (handles && handles.length >= 2) {
+          const dx = handles[1].x - handles[0].x;
+          const dy = handles[1].y - handles[0].y;
+          angle = Math.round(Math.atan2(dy, dx) * 180 / Math.PI + 90);
+        }
+        const stopStr = stops.map((s) => `${(0, color_1.figmaColorToCss)(s.color, paint.opacity ?? 1)} ${Math.round(s.position * 100)}%`).join(", ");
+        return `linear-gradient(${angle}deg, ${stopStr})`;
+      }
+      applyStroke(node, css) {
+        const strokes = this.visiblePaints(node.strokes);
+        if (!strokes.length || !node.strokeWeight)
+          return;
+        const paint = strokes[strokes.length - 1];
+        if (paint.type === "SOLID" && paint.color) {
+          css.border = `${(0, color_1.px)(node.strokeWeight)} solid ${(0, color_1.figmaColorToCss)(paint.color, paint.opacity ?? 1)}`;
+        }
+      }
+      applyRadius(node, css) {
+        if (node.rectangleCornerRadii) {
+          const [tl, tr, br, bl] = node.rectangleCornerRadii;
+          if (tl || tr || br || bl) {
+            css["border-radius"] = `${(0, color_1.px)(tl)} ${(0, color_1.px)(tr)} ${(0, color_1.px)(br)} ${(0, color_1.px)(bl)}`;
+          }
+        } else if (node.cornerRadius) {
+          css["border-radius"] = (0, color_1.px)(node.cornerRadius);
+        }
+      }
+      applyEffects(node, css) {
+        const effects = (node.effects ?? []).filter((e) => e.visible !== false);
+        const shadows = [];
+        for (const e of effects) {
+          shadows.push(...this.effectToCss(e, css));
+        }
+        if (shadows.length)
+          css["box-shadow"] = shadows.join(", ");
+      }
+      effectToCss(e, css) {
+        if (e.type === "DROP_SHADOW" || e.type === "INNER_SHADOW") {
+          const c = e.color ? (0, color_1.figmaColorToCss)(e.color) : "rgba(0,0,0,0.25)";
+          const x = (0, color_1.px)(e.offset?.x ?? 0);
+          const y = (0, color_1.px)(e.offset?.y ?? 0);
+          const blur = (0, color_1.px)(e.radius ?? 0);
+          const spread = (0, color_1.px)(e.spread ?? 0);
+          const inset = e.type === "INNER_SHADOW" ? "inset " : "";
+          return [`${inset}${x} ${y} ${blur} ${spread} ${c}`];
+        }
+        if (e.type === "LAYER_BLUR") {
+          css.filter = `blur(${(0, color_1.px)(e.radius ?? 0)})`;
+        }
+        if (e.type === "BACKGROUND_BLUR") {
+          css["backdrop-filter"] = `blur(${(0, color_1.px)(e.radius ?? 0)})`;
+        }
+        return [];
+      }
+      applyOpacity(node, css) {
+        if (node.opacity !== void 0 && node.opacity < 1) {
+          css.opacity = String(Number(node.opacity.toFixed(3)));
+        }
+      }
+      // ---- text ---------------------------------------------------------------
+      applyText(node, css) {
+        const s = node.style;
+        if (s) {
+          if (s.fontFamily)
+            css["font-family"] = `'${s.fontFamily}', sans-serif`;
+          if (s.fontSize)
+            css["font-size"] = (0, color_1.px)(s.fontSize);
+          if (s.fontWeight)
+            css["font-weight"] = String(s.fontWeight);
+          if (s.lineHeightPx)
+            css["line-height"] = (0, color_1.px)(s.lineHeightPx);
+          if (s.letterSpacing)
+            css["letter-spacing"] = (0, color_1.px)(s.letterSpacing);
+          if (s.italic)
+            css["font-style"] = "italic";
+          if (s.textAlignHorizontal)
+            css["text-align"] = s.textAlignHorizontal.toLowerCase();
+          if (s.textDecoration === "UNDERLINE")
+            css["text-decoration"] = "underline";
+          if (s.textDecoration === "STRIKETHROUGH")
+            css["text-decoration"] = "line-through";
+          if (s.textCase === "UPPER")
+            css["text-transform"] = "uppercase";
+          if (s.textCase === "LOWER")
+            css["text-transform"] = "lowercase";
+          if (s.textCase === "TITLE")
+            css["text-transform"] = "capitalize";
+          if (s.textAutoResize === "WIDTH_AND_HEIGHT")
+            css["white-space"] = "pre";
+          else if (s.textAutoResize === "HEIGHT")
+            css["white-space"] = "pre-wrap";
+        }
+        const fills = this.visiblePaints(node.fills);
+        const paint = fills[fills.length - 1];
+        if (paint?.type === "SOLID" && paint.color) {
+          css.color = (0, color_1.figmaColorToCss)(paint.color, paint.opacity ?? 1);
+        }
+      }
+      // ---- assets -------------------------------------------------------------
+      detectAsset(node) {
+        const vectorTypes = ["VECTOR", "STAR", "LINE", "ELLIPSE", "REGULAR_POLYGON", "BOOLEAN_OPERATION"];
+        if (vectorTypes.includes(node.type))
+          return { kind: "vector" };
+        const imagePaint = [...this.visiblePaints(node.fills)].reverse().find((p) => p.type === "IMAGE" && p.imageRef);
+        if (imagePaint)
+          return { kind: "image", imageRef: imagePaint.imageRef };
+        return void 0;
+      }
+    };
+    exports.StyleIr = StyleIr;
+  }
+});
+
+// ../packages/figma-core/dist/converter/tailwind-mapper.js
+var require_tailwind_mapper = __commonJS({
+  "../packages/figma-core/dist/converter/tailwind-mapper.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.cssToTailwind = cssToTailwind;
+    function arb(value) {
+      return value.replace(/\s+/g, "_");
+    }
+    var JUSTIFY = {
+      "flex-start": "justify-start",
+      center: "justify-center",
+      "flex-end": "justify-end",
+      "space-between": "justify-between"
+    };
+    var ITEMS = {
+      "flex-start": "items-start",
+      center: "items-center",
+      "flex-end": "items-end",
+      baseline: "items-baseline"
+    };
+    var TEXT_ALIGN = {
+      left: "text-left",
+      center: "text-center",
+      right: "text-right",
+      justify: "text-justify"
+    };
+    function cssToTailwind(css) {
+      const classes = [];
+      const leftover = {};
+      const push = (c) => {
+        if (c)
+          classes.push(c);
+      };
+      for (const [prop, value] of Object.entries(css)) {
+        switch (prop) {
+          case "display":
+            if (value === "flex")
+              push("flex");
+            else if (value === "block")
+              push("block");
+            else if (value === "none")
+              push("hidden");
+            else
+              leftover[prop] = value;
+            break;
+          case "flex-direction":
+            push(value === "column" ? "flex-col" : "flex-row");
+            break;
+          case "flex-wrap":
+            if (value === "wrap")
+              push("flex-wrap");
+            break;
+          case "justify-content":
+            JUSTIFY[value] ? push(JUSTIFY[value]) : leftover[prop] = value;
+            break;
+          case "align-items":
+            ITEMS[value] ? push(ITEMS[value]) : leftover[prop] = value;
+            break;
+          case "gap":
+            push(`gap-[${arb(value)}]`);
+            break;
+          case "padding":
+            applyPadding(value, push, leftover);
+            break;
+          case "width":
+            push(`w-[${arb(value)}]`);
+            break;
+          case "height":
+            push(`h-[${arb(value)}]`);
+            break;
+          case "position":
+            if (value === "absolute")
+              push("absolute");
+            else if (value === "relative")
+              push("relative");
+            else
+              leftover[prop] = value;
+            break;
+          case "left":
+            push(`left-[${arb(value)}]`);
+            break;
+          case "top":
+            push(`top-[${arb(value)}]`);
+            break;
+          case "overflow":
+            if (value === "hidden")
+              push("overflow-hidden");
+            else
+              leftover[prop] = value;
+            break;
+          case "background-color":
+            push(`bg-[${arb(value)}]`);
+            break;
+          case "background-image":
+            push(`bg-[${arb(value)}]`);
+            break;
+          case "background-size":
+            push(value === "cover" ? "bg-cover" : `bg-[length:${arb(value)}]`);
+            break;
+          case "background-position":
+            if (value === "center")
+              push("bg-center");
+            else
+              leftover[prop] = value;
+            break;
+          case "border":
+            applyBorder(value, push, leftover);
+            break;
+          case "border-radius":
+            value.includes(" ") ? leftover[prop] = value : push(`rounded-[${arb(value)}]`);
+            break;
+          case "box-shadow":
+            push(`shadow-[${arb(value)}]`);
+            break;
+          case "opacity":
+            push(`opacity-[${arb(value)}]`);
+            break;
+          case "filter":
+            applyBlur(value, "blur", push, leftover, prop);
+            break;
+          case "backdrop-filter":
+            applyBlur(value, "backdrop-blur", push, leftover, prop);
+            break;
+          // text
+          case "color":
+            push(`text-[${arb(value)}]`);
+            break;
+          case "font-size":
+            push(`text-[${arb(value)}]`);
+            break;
+          case "font-weight":
+            push(`font-[${arb(value)}]`);
+            break;
+          case "line-height":
+            push(`leading-[${arb(value)}]`);
+            break;
+          case "letter-spacing":
+            push(`tracking-[${arb(value)}]`);
+            break;
+          case "font-family":
+            push(`font-[${arb(value.replace(/['"]/g, ""))}]`);
+            break;
+          case "font-style":
+            if (value === "italic")
+              push("italic");
+            break;
+          case "text-align":
+            TEXT_ALIGN[value] ? push(TEXT_ALIGN[value]) : leftover[prop] = value;
+            break;
+          case "text-decoration":
+            if (value === "underline")
+              push("underline");
+            else if (value === "line-through")
+              push("line-through");
+            break;
+          case "text-transform":
+            push(value);
+            break;
+          default:
+            leftover[prop] = value;
+        }
+      }
+      return { classes, leftover };
+    }
+    function applyPadding(value, push, leftover) {
+      const parts = value.split(/\s+/);
+      if (parts.length === 4) {
+        const [t, r, b, l] = parts;
+        push(`pt-[${arb(t)}]`);
+        push(`pr-[${arb(r)}]`);
+        push(`pb-[${arb(b)}]`);
+        push(`pl-[${arb(l)}]`);
+      } else if (parts.length === 1) {
+        push(`p-[${arb(parts[0])}]`);
+      } else {
+        leftover.padding = value;
+      }
+    }
+    function applyBorder(value, push, leftover) {
+      const m = value.match(/^(\S+)\s+solid\s+(.+)$/);
+      if (m) {
+        push(`border-[${arb(m[1])}]`);
+        push("border-solid");
+        push(`border-[${arb(m[2])}]`);
+      } else {
+        leftover.border = value;
+      }
+    }
+    function applyBlur(value, prefix, push, leftover, prop) {
+      const m = value.match(/blur\((.+)\)/);
+      if (m)
+        push(`${prefix}-[${arb(m[1])}]`);
+      else
+        leftover[prop] = value;
+    }
+  }
+});
+
+// ../packages/figma-core/dist/converter/html-renderer.js
+var require_html_renderer = __commonJS({
+  "../packages/figma-core/dist/converter/html-renderer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HtmlRenderer = void 0;
+    var tailwind_mapper_1 = require_tailwind_mapper();
+    function escapeHtml(s) {
+      return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+    }
+    function styleString(css) {
+      return Object.entries(css).map(([k, v]) => `${k}: ${v}`).join("; ");
+    }
+    var HtmlRenderer = class _HtmlRenderer {
+      /** Render the Style IR tree into an HTML fragment string. */
+      renderFragment(node, opts = {}) {
+        return this.render(node, opts.mode ?? "tailwind", 0);
+      }
+      /** Render a standalone, previewable HTML document (Tailwind Play CDN). */
+      renderDocument(node, opts = {}) {
+        const body = this.render(node, opts.mode ?? "tailwind", 2);
+        return this.wrapDocument(body, node.name || "Figma Export", this.fontLinks(node));
+      }
+      /** Wrap an arbitrary HTML fragment (e.g. LLM output) into a previewable document. */
+      wrapDocument(bodyHtml, title = "Figma Export", fontLinks = "") {
+        return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${escapeHtml(title)}</title>
+${fontLinks ? fontLinks + "\n" : ""}<script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body>
+${bodyHtml}
+</body>
+</html>`;
+      }
+      /** Collect (family -> weights) used across the IR. */
+      collectFonts(node, acc = /* @__PURE__ */ new Map()) {
+        const fam = node.css["font-family"];
+        if (fam) {
+          const family = fam.split(",")[0].replace(/['"]/g, "").trim();
+          const weight = parseInt(node.css["font-weight"] ?? "400", 10) || 400;
+          if (!acc.has(family))
+            acc.set(family, /* @__PURE__ */ new Set());
+          acc.get(family).add(weight);
+        }
+        for (const child of node.children)
+          this.collectFonts(child, acc);
+        return acc;
+      }
+      /** Build Google Fonts <link> tags (one per family) for the fonts used. */
+      fontLinks(node) {
+        const fonts = this.collectFonts(node);
+        const links = [];
+        for (const [family, weights] of fonts) {
+          if (_HtmlRenderer.NON_GOOGLE.has(family.toLowerCase()))
+            continue;
+          const wght = [...weights].sort((a, b) => a - b).join(";");
+          const fam = encodeURIComponent(family).replace(/%20/g, "+");
+          links.push(`<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=${fam}:wght@${wght}&display=swap" />`);
+        }
+        return links.join("\n");
+      }
+      render(node, mode, depth) {
+        const indent = "  ".repeat(depth);
+        const isVectorAsset = node.asset?.kind === "vector" && !!node.assetSrc;
+        const isImageAsset = node.asset?.kind === "image" && !!node.assetSrc;
+        const extraStyle = {};
+        if (isImageAsset) {
+          extraStyle["background-image"] = `url(${node.assetSrc})`;
+        }
+        const attrs = [];
+        if (mode === "inline") {
+          const css = { ...node.css, ...extraStyle };
+          if (Object.keys(css).length)
+            attrs.push(`style="${escapeHtml(styleString(css))}"`);
+        } else {
+          const { classes, leftover } = (0, tailwind_mapper_1.cssToTailwind)(node.css);
+          const style = { ...leftover, ...extraStyle };
+          if (classes.length)
+            attrs.push(`class="${classes.join(" ")}"`);
+          if (Object.keys(style).length)
+            attrs.push(`style="${escapeHtml(styleString(style))}"`);
+        }
+        attrs.push(`data-figma-name="${escapeHtml(node.name)}"`);
+        const attrStr = attrs.length ? " " + attrs.join(" ") : "";
+        if (isVectorAsset) {
+          return `${indent}<img${attrStr} src="${node.assetSrc}" alt="${escapeHtml(node.name)}" />`;
+        }
+        if (node.text !== void 0) {
+          return `${indent}<${node.tag}${attrStr}>${escapeHtml(node.text)}</${node.tag}>`;
+        }
+        if (!node.children.length) {
+          return `${indent}<${node.tag}${attrStr}></${node.tag}>`;
+        }
+        const childHtml = node.children.map((c) => this.render(c, mode, depth + 1)).join("\n");
+        return `${indent}<${node.tag}${attrStr}>
+${childHtml}
+${indent}</${node.tag}>`;
+      }
+    };
+    exports.HtmlRenderer = HtmlRenderer;
+    HtmlRenderer.NON_GOOGLE = /* @__PURE__ */ new Set([
+      "arial",
+      "helvetica",
+      "helvetica neue",
+      "sans-serif",
+      "serif",
+      "monospace",
+      "times",
+      "times new roman",
+      "courier",
+      "courier new",
+      "system-ui",
+      "segoe ui",
+      "-apple-system",
+      "gilroy",
+      "gilroy-extrabold",
+      "google sans",
+      "product sans",
+      "sf pro",
+      "sf pro text",
+      "sf pro display"
+    ]);
+  }
+});
+
+// ../packages/figma-core/dist/assets/asset-resolver.js
+var require_asset_resolver = __commonJS({
+  "../packages/figma-core/dist/assets/asset-resolver.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AssetResolver = void 0;
+    var AssetResolver = class {
+      constructor(figma, cache, logger) {
+        this.figma = figma;
+        this.cache = cache;
+        this.logger = logger;
+        this.fetchConcurrency = 8;
+      }
+      async resolve(root, fileKey, auth, scale = 2) {
+        const vectors = [];
+        const images = [];
+        this.collect(root, vectors, images);
+        if (!vectors.length && !images.length) {
+          return { vectors: 0, images: 0, embedded: 0, fromCache: 0 };
+        }
+        let fromCache = 0;
+        fromCache += await this.fillFromCache(vectors, fileKey, "svg", 1);
+        fromCache += await this.fillImageFillsFromCache(images, fileKey);
+        const vMissing = vectors.filter((n) => !n.assetSrc);
+        let svgUrls = {};
+        if (vMissing.length) {
+          try {
+            svgUrls = await this.figma.renderImages(fileKey, vMissing.map((n) => n.id), "svg", auth);
+            await this.retryMissing(vMissing, svgUrls, fileKey, "svg", auth, 1);
+          } catch (err) {
+            this.logger.warn(`Vector render failed (keeping cached vectors + image fills): ${err.message}`);
+          }
+        }
+        const iMissing = images.filter((n) => !n.assetSrc && n.asset?.imageRef);
+        let embedded = 0;
+        embedded += await this.embed(vMissing, svgUrls, "image/svg+xml", fileKey, "svg", 1);
+        embedded += await this.embedImageFills(iMissing, fileKey, auth);
+        this.logger.log(`Assets: ${vectors.length} vectors, ${images.length} image fills, ${fromCache} from cache, ${embedded} newly embedded`);
+        return { vectors: vectors.length, images: images.length, embedded, fromCache };
+      }
+      assetKey(fileKey, id, format, scale) {
+        return `asset:${fileKey}:${id}:${format}:${scale}`;
+      }
+      imageFillKey(fileKey, imageRef) {
+        return `imagefill:${fileKey}:${imageRef}`;
+      }
+      /** Populate vector assetSrc from cache where available; returns the hit count. */
+      async fillFromCache(nodes, fileKey, format, scale) {
+        let hits = 0;
+        for (const node of nodes) {
+          const uri = await this.cache.get(this.assetKey(fileKey, node.id, format, scale));
+          if (uri) {
+            node.assetSrc = uri;
+            hits++;
+          }
+        }
+        return hits;
+      }
+      /** Populate image-fill assetSrc from cache (keyed by imageRef); hit count. */
+      async fillImageFillsFromCache(nodes, fileKey) {
+        let hits = 0;
+        for (const node of nodes) {
+          const ref = node.asset?.imageRef;
+          if (!ref)
+            continue;
+          const uri = await this.cache.get(this.imageFillKey(fileKey, ref));
+          if (uri) {
+            node.assetSrc = uri;
+            hits++;
+          }
+        }
+        return hits;
+      }
+      /**
+       * Resolve image fills via the cheap image-fills endpoint: one call for every
+       * fill URL in the file, then download each unique imageRef once (a single
+       * uploaded image can back many nodes) and share the data URI across them.
+       */
+      async embedImageFills(nodes, fileKey, auth) {
+        if (!nodes.length)
+          return 0;
+        const byRef = /* @__PURE__ */ new Map();
+        for (const node of nodes) {
+          const ref = node.asset.imageRef;
+          if (!byRef.has(ref))
+            byRef.set(ref, []);
+          byRef.get(ref).push(node);
+        }
+        const fillUrls = await this.figma.getImageFills(fileKey, auth);
+        let count = 0;
+        const refs = [...byRef.keys()];
+        for (let i = 0; i < refs.length; i += this.fetchConcurrency) {
+          const chunk = refs.slice(i, i + this.fetchConcurrency);
+          await Promise.all(chunk.map(async (ref) => {
+            const url = fillUrls[ref];
+            if (!url)
+              return;
+            try {
+              const dataUri = await this.toDataUri(url, "image/png");
+              await this.cache.set(this.imageFillKey(fileKey, ref), dataUri);
+              for (const node of byRef.get(ref))
+                node.assetSrc = dataUri;
+              count++;
+            } catch (err) {
+              this.logger.warn(`Image fill ${ref} embed failed: ${err.message}`);
+            }
+          }));
+        }
+        return count;
+      }
+      /**
+       * Collect asset nodes. A vector node is rendered as a single SVG and its
+       * subtree is NOT traversed further (collapses icon groups into one image).
+       * An image fill is a background, so traversal continues into its children.
+       */
+      collect(node, vectors, images) {
+        if (node.asset?.kind === "vector") {
+          vectors.push(node);
+          return;
+        }
+        if (node.asset?.kind === "image") {
+          images.push(node);
+        }
+        for (const child of node.children)
+          this.collect(child, vectors, images);
+      }
+      async retryMissing(nodes, urlMap, fileKey, format, auth, scale) {
+        const missing = nodes.filter((n) => !urlMap[n.id]).map((n) => n.id);
+        if (!missing.length)
+          return;
+        try {
+          const retry = await this.figma.renderImages(fileKey, missing, format, auth, scale);
+          for (const [id, url] of Object.entries(retry)) {
+            if (url)
+              urlMap[id] = url;
+          }
+          const stillMissing = missing.filter((id) => !urlMap[id]).length;
+          this.logger.log(`Retried ${missing.length} missing ${format} assets; ${stillMissing} still unrendered`);
+        } catch (err) {
+          this.logger.warn(`Asset retry (${format}) failed: ${err.message}`);
+        }
+      }
+      async embed(nodes, urlMap, mime, fileKey, format, scale) {
+        let count = 0;
+        for (let i = 0; i < nodes.length; i += this.fetchConcurrency) {
+          const chunk = nodes.slice(i, i + this.fetchConcurrency);
+          await Promise.all(chunk.map(async (node) => {
+            const url = urlMap[node.id];
+            if (!url)
+              return;
+            try {
+              node.assetSrc = await this.toDataUri(url, mime);
+              await this.cache.set(this.assetKey(fileKey, node.id, format, scale), node.assetSrc);
+              count++;
+            } catch (err) {
+              this.logger.warn(`Asset ${node.id} embed failed: ${err.message}`);
+            }
+          }));
+        }
+        return count;
+      }
+      async toDataUri(url, fallbackMime) {
+        const res = await fetch(url);
+        if (!res.ok)
+          throw new Error(`fetch ${res.status}`);
+        const mime = res.headers.get("content-type")?.split(";")[0]?.trim() || fallbackMime;
+        const buf = Buffer.from(await res.arrayBuffer());
+        return `data:${mime};base64,${buf.toString("base64")}`;
+      }
+    };
+    exports.AssetResolver = AssetResolver;
+  }
+});
+
+// ../packages/figma-core/dist/llm/ollama-client.js
+var require_ollama_client = __commonJS({
+  "../packages/figma-core/dist/llm/ollama-client.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OllamaClient = void 0;
+    exports.ollamaConfigFromEnv = ollamaConfigFromEnv;
+    var openai_1 = __importDefault(__require("openai"));
+    var adapters_1 = require_adapters();
+    function ollamaConfigFromEnv(logger) {
+      return {
+        baseUrl: process.env.OLLAMA_CLOUD_URL ?? "https://ollama.com/v1",
+        apiKey: process.env.OLLAMA_API_KEY ?? "ollama",
+        models: (process.env.OLLAMA_CLOUD_MODELS ?? process.env.OLLAMA_CLOUD_MODEL ?? "").split(",").map((m) => m.trim()).filter(Boolean),
+        logger
+      };
+    }
+    function stripJsonCodeFence(content) {
+      const trimmed = content.trim();
+      const fenced = trimmed.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?```\s*$/i);
+      return fenced ? fenced[1].trim() : trimmed;
+    }
+    var OllamaClient = class {
+      constructor(config = {}) {
+        const baseUrl = (config.baseUrl ?? "https://ollama.com/v1").replace(/\/+$/, "");
+        const apiKey = config.apiKey ?? "ollama";
+        this.logger = config.logger ?? new adapters_1.NoopLogger();
+        this.client = new openai_1.default({ apiKey, baseURL: baseUrl, timeout: 3e5 });
+        this.models = (config.models ?? []).map((m) => m.trim()).filter(Boolean);
+        this.logger.log(`Ollama: ${baseUrl} | Models: ${this.models.join(", ") || "(none configured)"}`);
+      }
+      get enabled() {
+        return this.models.length > 0;
+      }
+      async chat(messages, jsonSchema) {
+        for (const model of this.models) {
+          try {
+            this.logger.log(`[Chat] model=${model}`);
+            const completion = await this.client.chat.completions.create({
+              model,
+              messages,
+              temperature: 0.7,
+              stream: false,
+              ...jsonSchema && {
+                response_format: {
+                  type: "json_schema",
+                  json_schema: { name: jsonSchema.name, schema: jsonSchema.schema, strict: true }
+                }
+              }
+            });
+            const content = completion.choices[0]?.message?.content ?? "";
+            return jsonSchema ? stripJsonCodeFence(content) : content;
+          } catch (err) {
+            this.logger.warn(`[Chat] model=${model} failed: ${err.message}`);
+          }
+        }
+        throw new Error("All Ollama models failed");
+      }
+      async chatWithTools(messages, tools) {
+        for (const model of this.models) {
+          try {
+            this.logger.log(`[ChatWithTools] model=${model}`);
+            const completion = await this.client.chat.completions.create({
+              model,
+              messages,
+              tools,
+              tool_choice: "auto",
+              stream: false,
+              temperature: 0.3
+            });
+            const msg = completion.choices[0]?.message;
+            if (!msg)
+              continue;
+            const tool_calls = msg.tool_calls?.map((tc) => ({
+              id: tc.id,
+              name: tc.function.name,
+              arguments: (() => {
+                try {
+                  return JSON.parse(tc.function.arguments);
+                } catch {
+                  return {};
+                }
+              })()
+            })) ?? null;
+            return { content: msg.content ?? null, tool_calls };
+          } catch (err) {
+            this.logger.warn(`[ChatWithTools] model=${model} failed: ${err.message}`);
+          }
+        }
+        throw new Error("All Ollama models failed");
+      }
+      /**
+       * Stream a completion, forwarding each token to `onChunk`, and return the
+       * full accumulated text. Does NOT manage any transport — the caller owns the
+       * response lifecycle (used by /convert/stream in the API).
+       */
+      async streamCompletion(messages, onChunk) {
+        for (const model of this.models) {
+          try {
+            this.logger.log(`[StreamCompletion] model=${model}`);
+            const stream = await this.client.chat.completions.create({
+              model,
+              messages,
+              temperature: 0.3,
+              stream: true
+            });
+            let full = "";
+            for await (const chunk of stream) {
+              const content = chunk.choices[0]?.delta?.content ?? "";
+              if (content) {
+                full += content;
+                onChunk?.(content);
+              }
+            }
+            return full;
+          } catch (err) {
+            this.logger.warn(`[StreamCompletion] model=${model} failed: ${err.message}`);
+          }
+        }
+        throw new Error("All Ollama models failed");
+      }
+    };
+    exports.OllamaClient = OllamaClient;
+  }
+});
+
+// ../packages/figma-core/dist/llm/strip-fence.js
+var require_strip_fence = __commonJS({
+  "../packages/figma-core/dist/llm/strip-fence.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.stripCodeFence = stripCodeFence;
+    function stripCodeFence(content) {
+      const trimmed = content.trim();
+      const fenced = trimmed.match(/^```(?:[a-zA-Z]+)?\s*\n?([\s\S]*?)\n?```\s*$/);
+      return fenced ? fenced[1].trim() : trimmed;
+    }
+  }
+});
+
+// ../packages/figma-core/dist/llm/strip-assets.js
+var require_strip_assets = __commonJS({
+  "../packages/figma-core/dist/llm/strip-assets.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.stripHeavyAssets = stripHeavyAssets;
+    function stripHeavyAssets(html) {
+      const map = /* @__PURE__ */ new Map();
+      let n = 0;
+      const placeholderFor = (original) => {
+        let ph = map.get(original);
+        if (!ph) {
+          ph = `__F2H_ASSET_${n++}__`;
+          map.set(original, ph);
+        }
+        return ph;
+      };
+      const stripped = html.replace(/(<svg\b[^>]*>)([\s\S]*?)(<\/svg>)/gi, (_m, open, inner, close) => inner.trim() ? `${open}${placeholderFor(inner)}${close}` : `${open}${inner}${close}`).replace(/data:[^"')\s>]+/gi, (uri) => placeholderFor(uri));
+      const restore = (s) => {
+        let out = s;
+        for (const [original, ph] of map)
+          out = out.split(ph).join(original);
+        return out;
+      };
+      return { stripped, restore };
+    }
+  }
+});
+
+// ../packages/figma-core/dist/llm/restructure.js
+var require_restructure = __commonJS({
+  "../packages/figma-core/dist/llm/restructure.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LlmRestructure = void 0;
+    var strip_fence_1 = require_strip_fence();
+    var strip_assets_1 = require_strip_assets();
+    var LlmRestructure = class {
+      constructor(ollama) {
+        this.ollama = ollama;
+        this.systemPrompt = [
+          "You are an expert front-end engineer. You receive an HTML fragment that was",
+          "generated deterministically from a Figma design. It uses Tailwind utility",
+          "classes with arbitrary values (e.g. w-[327px], bg-[#ff5a63]) plus occasional",
+          'inline style="" leftovers, and a data-figma-name attribute on each element.',
+          "",
+          "Your job: return a cleaner, SEMANTIC, accessible version of the SAME markup.",
+          "",
+          "STRICT RULES \u2014 fidelity must be preserved:",
+          "1. NEVER change, round, add, or remove any numeric value, color, or arbitrary",
+          "   Tailwind value (anything inside square brackets) or inline style value.",
+          "2. NEVER change visible text content.",
+          "3. When you merge a redundant wrapper into its child, COMBINE their classes",
+          "   onto the surviving element \u2014 do not drop any class.",
+          "",
+          "You MAY:",
+          "- Replace generic <div>/<p> with semantic tags where clearly appropriate",
+          "  (header, nav, main, section, footer, ul/li, button, a, h1-h6, figure, img).",
+          "- Collapse redundant single-child wrapper <div>s (merging their classes).",
+          '- Add helpful accessibility attributes (alt="", aria-label, role) using the',
+          "  data-figma-name as a hint. You may then drop data-figma-name.",
+          "",
+          "Output ONLY the resulting HTML fragment. No explanation, no markdown fence."
+        ].join("\n");
+      }
+      get enabled() {
+        return this.ollama.enabled;
+      }
+      buildMessages(deterministicHtml) {
+        return [
+          { role: "system", content: this.systemPrompt },
+          {
+            role: "user",
+            content: `Restructure this HTML fragment:
+
+${deterministicHtml}`
+          }
+        ];
+      }
+      /** Non-streaming restructure. Returns the cleaned HTML fragment. */
+      async restructure(deterministicHtml) {
+        this.assertEnabled();
+        const { stripped, restore } = (0, strip_assets_1.stripHeavyAssets)(deterministicHtml);
+        const out = await this.ollama.chat(this.buildMessages(stripped));
+        return restore((0, strip_fence_1.stripCodeFence)(out));
+      }
+      /** Streaming restructure. Forwards tokens to onChunk; returns the full cleaned HTML. */
+      async restructureStream(deterministicHtml, onChunk) {
+        this.assertEnabled();
+        const { stripped, restore } = (0, strip_assets_1.stripHeavyAssets)(deterministicHtml);
+        const full = await this.ollama.streamCompletion(this.buildMessages(stripped), onChunk);
+        return restore((0, strip_fence_1.stripCodeFence)(full));
+      }
+      assertEnabled() {
+        if (!this.enabled) {
+          throw new Error("LLM restructure unavailable: configure OLLAMA_CLOUD_MODELS / OLLAMA_CLOUD_URL.");
+        }
+      }
+    };
+    exports.LlmRestructure = LlmRestructure;
+  }
+});
+
+// ../packages/figma-core/dist/llm/refine-agent.js
+var require_refine_agent = __commonJS({
+  "../packages/figma-core/dist/llm/refine-agent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RefineAgent = void 0;
+    var strip_assets_1 = require_strip_assets();
+    var RefineAgent = class {
+      constructor() {
+        this.systemPrompt = [
+          "You are a senior front-end engineer. You receive a STATIC HTML fragment that",
+          "was generated deterministically from a Figma design. It is visually faithful",
+          'but "dumb": almost everything is an absolutely-positioned <div> or <p>, there',
+          "is no interactivity, tags are generic, and each element carries a",
+          "data-figma-name attribute.",
+          "",
+          "GOAL: refine it into clean, SEMANTIC, FUNCTIONAL, accessible HTML that a real",
+          "product would ship \u2014 using your own judgment about what each element is meant",
+          "to be. The rendered result must still LOOK the same.",
+          "",
+          "PRESERVE exactly (never change):",
+          "- Visual layout, position, size, color, typography, spacing \u2014 i.e. every",
+          '  Tailwind arbitrary value in [...] and every inline style="" value. Keep the',
+          "  positioning classes on the element you convert so it stays in place.",
+          "- The visible text / wording.",
+          "",
+          "IMPROVE using judgment (these are EXAMPLES, not a fixed checklist \u2014 find the",
+          "issues yourself):",
+          "- Use the correct semantic / interactive element for the apparent intent:",
+          '  a language label like "EN" (often beside a chevron) -> a <select> with',
+          '  <option>s; a label like "Play Demo" beside a play icon -> a <button>;',
+          "  navigation labels -> <a> inside a <nav>; the main page title -> <h1> and",
+          "  sub-headings -> <h2>-<h6>; repeated items -> <ul>/<li>; the top bar ->",
+          "  <header>, the bottom bar -> <footer>; search/email/text fields -> <input>",
+          "  with <label>; clickable cards/CTAs -> <a> or <button>.",
+          '- Add reasonable interactivity & accessibility: type="button" on buttons,',
+          '  href="#" on links, aria-label/role where useful, alt text for images',
+          "  (use data-figma-name as a hint), <option>s inside selects.",
+          "- Collapse redundant single-child wrapper <div>s, MERGING their classes onto",
+          "  the surviving element (never drop a class).",
+          "- You may drop data-figma-name once you have used it.",
+          "",
+          "DO NOT: redesign or move things, change colors/sizes/fonts/spacing, change",
+          "wording, invent new sections, or remove visible content.",
+          "",
+          "HOW TO WORK:",
+          "- The current HTML is in the conversation. Make focused changes with",
+          "  apply_edit(find, replace) where `find` is an EXACT, unique substring of the",
+          "  current HTML and `replace` is the improved markup.",
+          "- Call get_html anytime to re-read the current state (do this if an edit",
+          "  reports NOT_FOUND).",
+          "- You can issue SEVERAL apply_edit calls in one turn (they run together) \u2014",
+          "  do this to cover more of the page per step.",
+          "- Be THOROUGH: scan the WHOLE document top-to-bottom for elements that should",
+          "  be interactive (selects, buttons, links, inputs) or semantic, not just the",
+          "  first sections. Only call finish once the whole document has been covered."
+        ].join("\n");
+        this.tools = [
+          {
+            type: "function",
+            function: {
+              name: "get_html",
+              description: "Return the current working HTML so you can re-read it after edits.",
+              parameters: { type: "object", properties: {} }
+            }
+          },
+          {
+            type: "function",
+            function: {
+              name: "apply_edit",
+              description: "Replace an EXACT, unique substring of the working HTML with improved markup. Preserves all other content.",
+              parameters: {
+                type: "object",
+                properties: {
+                  find: {
+                    type: "string",
+                    description: "An exact, unique substring currently present in the working HTML."
+                  },
+                  replace: { type: "string", description: "The replacement HTML." }
+                },
+                required: ["find", "replace"]
+              }
+            }
+          },
+          {
+            type: "function",
+            function: {
+              name: "finish",
+              description: "Call when the HTML has been meaningfully refined.",
+              parameters: {
+                type: "object",
+                properties: { summary: { type: "string", description: "Short summary of changes." } }
+              }
+            }
+          }
+        ];
+      }
+      createSession(deterministicHtml) {
+        const { stripped, restore } = (0, strip_assets_1.stripHeavyAssets)(deterministicHtml);
+        const state = { html: stripped };
+        const executeTool = async (name, args) => {
+          switch (name) {
+            case "get_html":
+              return state.html;
+            case "apply_edit": {
+              const find = String(args.find ?? "");
+              const replace = String(args.replace ?? "");
+              if (!find)
+                return 'ERROR: "find" is empty.';
+              const occurrences = state.html.split(find).length - 1;
+              if (occurrences === 0)
+                return "NOT_FOUND: that exact substring is not in the current HTML. Call get_html and copy an exact, unique snippet.";
+              state.html = state.html.split(find).join(replace);
+              return `OK: replaced ${occurrences} occurrence(s).`;
+            }
+            case "finish":
+              return "OK";
+            default:
+              return `Unknown tool: ${name}`;
+          }
+        };
+        const interceptors = { finish: () => void 0 };
+        const getFinalHtml = () => restore(state.html);
+        return { userMessage: `Here is the HTML export to refine:
+
+${stripped}`, executeTool, interceptors, getFinalHtml };
+      }
+    };
+    exports.RefineAgent = RefineAgent;
+  }
+});
+
+// ../packages/figma-core/dist/llm/agent-runner.js
+var require_agent_runner = __commonJS({
+  "../packages/figma-core/dist/llm/agent-runner.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.runAgent = runAgent;
+    var adapters_1 = require_adapters();
+    async function runAgent(ollama, messages, config, emit, options = {}) {
+      const logger = options.logger ?? new adapters_1.NoopLogger();
+      const isAborted = options.isAborted ?? (() => false);
+      const systemContent = config.extraContext ? `${config.systemPrompt}
+
+${config.extraContext}` : config.systemPrompt;
+      const chatMessages = [
+        { role: "system", content: systemContent },
+        ...messages.map((m) => ({ role: m.role, content: m.content }))
+      ];
+      const maxIterations = config.maxIterations ?? 20;
+      for (let i = 0; i < maxIterations; i++) {
+        if (isAborted())
+          return;
+        let result;
+        try {
+          result = await ollama.chatWithTools(chatMessages, config.tools);
+        } catch (err) {
+          emit({ type: "error", message: err.message });
+          break;
+        }
+        if (isAborted())
+          return;
+        if (result.content)
+          emit({ type: "text", chunk: result.content });
+        if (!result.tool_calls?.length)
+          break;
+        chatMessages.push({
+          role: "assistant",
+          content: result.content ?? null,
+          tool_calls: result.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+          }))
+        });
+        const interceptedTc = result.tool_calls.find((tc) => config.interceptors?.[tc.name]);
+        if (interceptedTc) {
+          emit({ type: "tool_call", name: interceptedTc.name, args: interceptedTc.arguments });
+          config.interceptors[interceptedTc.name](interceptedTc.arguments, emit);
+          break;
+        }
+        const toolResults = await Promise.all(result.tool_calls.map(async (tc) => {
+          emit({ type: "tool_call", name: tc.name, args: tc.arguments });
+          let output = "";
+          try {
+            output = await config.executeTool(tc.name, tc.arguments);
+          } catch (err) {
+            output = `Error: ${err.message}`;
+            logger.warn(`Tool ${tc.name} failed: ${err.message}`);
+          }
+          emit({ type: "tool_result", name: tc.name, preview: output.slice(0, 300) });
+          return { id: tc.id, output };
+        }));
+        for (const { id, output } of toolResults) {
+          chatMessages.push({ role: "tool", tool_call_id: id, content: output });
+        }
+      }
+      if (isAborted())
+        return;
+      const finalEmit = config.getFinalEmit?.();
+      if (finalEmit)
+        emit(finalEmit);
+    }
+  }
+});
+
+// ../packages/figma-core/dist/convert.js
+var require_convert = __commonJS({
+  "../packages/figma-core/dist/convert.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FigmaConverter = void 0;
+    exports.countNodes = countNodes;
+    var url_1 = require_url();
+    var adapters_1 = require_adapters();
+    var FigmaConverter = class {
+      constructor(deps) {
+        this.client = deps.client;
+        this.styleIr = deps.styleIr;
+        this.renderer = deps.renderer;
+        this.assets = deps.assets;
+        this.restructure = deps.restructure;
+        this.logger = deps.logger ?? new adapters_1.NoopLogger();
+      }
+      async convert(input, auth, options = {}) {
+        const target2 = (0, url_1.resolveFigmaTarget)(input);
+        const node = await this.client.fetchNode(target2.fileKey, target2.nodeId, auth);
+        const ir = this.styleIr.convert(node);
+        let assetWarning;
+        if (options.assets !== false) {
+          try {
+            await this.assets.resolve(ir, target2.fileKey, auth, options.assetScale ?? 2);
+          } catch (err) {
+            assetWarning = `Assets not fully resolved: ${err.message}`;
+            this.logger.warn(assetWarning);
+          }
+        }
+        const mode = options.mode ?? "tailwind";
+        let fragment = this.renderer.renderFragment(ir, { mode });
+        let usedLlm = false;
+        if (options.llm && this.restructure?.enabled) {
+          fragment = await this.restructure.restructure(fragment);
+          usedLlm = true;
+        }
+        const fontLinks = this.renderer.fontLinks(ir);
+        const document = this.renderer.wrapDocument(fragment, ir.name, fontLinks);
+        const html = options.document ? document : fragment;
+        return {
+          fileKey: target2.fileKey,
+          nodeId: target2.nodeId ?? null,
+          name: ir.name,
+          mode,
+          llm: usedLlm,
+          nodeCount: countNodes(ir),
+          fragment,
+          document,
+          html,
+          ir,
+          ...assetWarning ? { assetWarning } : {}
+        };
+      }
+      /** Deterministic only: returns the Style IR tree (exact CSS), no HTML. */
+      async extractStyles(input, auth) {
+        const target2 = (0, url_1.resolveFigmaTarget)(input);
+        const node = await this.client.fetchNode(target2.fileKey, target2.nodeId, auth);
+        return this.styleIr.convert(node);
+      }
+    };
+    exports.FigmaConverter = FigmaConverter;
+    function countNodes(node) {
+      return 1 + node.children.reduce((sum, c) => sum + countNodes(c), 0);
+    }
+  }
+});
+
+// ../packages/figma-core/dist/factory.js
+var require_factory = __commonJS({
+  "../packages/figma-core/dist/factory.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createFigmaCore = createFigmaCore2;
+    var adapters_1 = require_adapters();
+    var client_1 = require_client();
+    var style_ir_1 = require_style_ir();
+    var html_renderer_1 = require_html_renderer();
+    var asset_resolver_1 = require_asset_resolver();
+    var ollama_client_1 = require_ollama_client();
+    var restructure_1 = require_restructure();
+    var refine_agent_1 = require_refine_agent();
+    var convert_1 = require_convert();
+    function createFigmaCore2(config = {}) {
+      const logger = config.logger ?? new adapters_1.ConsoleLogger();
+      const cache = config.cache ?? new adapters_1.DiskCache(config.cacheDir, logger);
+      const client = new client_1.FigmaClient({
+        cache,
+        logger,
+        fallbackToken: config.figmaToken ?? process.env.FIGMA_TOKEN
+      });
+      const styleIr = new style_ir_1.StyleIr();
+      const renderer = new html_renderer_1.HtmlRenderer();
+      const assets = new asset_resolver_1.AssetResolver(client, cache, logger);
+      const ollama = new ollama_client_1.OllamaClient(config.ollama ?? (0, ollama_client_1.ollamaConfigFromEnv)(logger));
+      const restructure = new restructure_1.LlmRestructure(ollama);
+      const refineAgent = new refine_agent_1.RefineAgent();
+      const converter = new convert_1.FigmaConverter({ client, styleIr, renderer, assets, restructure, logger });
+      return {
+        converter,
+        client,
+        styleIr,
+        renderer,
+        assets,
+        ollama,
+        restructure,
+        refineAgent,
+        cache,
+        logger,
+        convert: converter.convert.bind(converter),
+        extractStyles: converter.extractStyles.bind(converter)
+      };
+    }
+  }
+});
+
+// ../packages/figma-core/dist/index.js
+var require_dist = __commonJS({
+  "../packages/figma-core/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createFigmaCore = exports.countNodes = exports.FigmaConverter = exports.stripHeavyAssets = exports.stripCodeFence = exports.runAgent = exports.RefineAgent = exports.LlmRestructure = exports.ollamaConfigFromEnv = exports.OllamaClient = exports.AssetResolver = exports.px = exports.figmaColorToCss = exports.cssToTailwind = exports.HtmlRenderer = exports.StyleIr = exports.resolveFigmaTarget = exports.normalizeNodeId = exports.parseFigmaUrl = exports.FigmaClient = exports.NoopLogger = exports.ConsoleLogger = exports.DiskCache = exports.MemoryCache = exports.FigmaInputError = exports.FigmaApiError = void 0;
+    var errors_1 = require_errors();
+    Object.defineProperty(exports, "FigmaApiError", { enumerable: true, get: function() {
+      return errors_1.FigmaApiError;
+    } });
+    Object.defineProperty(exports, "FigmaInputError", { enumerable: true, get: function() {
+      return errors_1.FigmaInputError;
+    } });
+    var adapters_1 = require_adapters();
+    Object.defineProperty(exports, "MemoryCache", { enumerable: true, get: function() {
+      return adapters_1.MemoryCache;
+    } });
+    Object.defineProperty(exports, "DiskCache", { enumerable: true, get: function() {
+      return adapters_1.DiskCache;
+    } });
+    Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function() {
+      return adapters_1.ConsoleLogger;
+    } });
+    Object.defineProperty(exports, "NoopLogger", { enumerable: true, get: function() {
+      return adapters_1.NoopLogger;
+    } });
+    var client_1 = require_client();
+    Object.defineProperty(exports, "FigmaClient", { enumerable: true, get: function() {
+      return client_1.FigmaClient;
+    } });
+    __exportStar(require_types(), exports);
+    var url_1 = require_url();
+    Object.defineProperty(exports, "parseFigmaUrl", { enumerable: true, get: function() {
+      return url_1.parseFigmaUrl;
+    } });
+    Object.defineProperty(exports, "normalizeNodeId", { enumerable: true, get: function() {
+      return url_1.normalizeNodeId;
+    } });
+    Object.defineProperty(exports, "resolveFigmaTarget", { enumerable: true, get: function() {
+      return url_1.resolveFigmaTarget;
+    } });
+    var style_ir_1 = require_style_ir();
+    Object.defineProperty(exports, "StyleIr", { enumerable: true, get: function() {
+      return style_ir_1.StyleIr;
+    } });
+    var html_renderer_1 = require_html_renderer();
+    Object.defineProperty(exports, "HtmlRenderer", { enumerable: true, get: function() {
+      return html_renderer_1.HtmlRenderer;
+    } });
+    var tailwind_mapper_1 = require_tailwind_mapper();
+    Object.defineProperty(exports, "cssToTailwind", { enumerable: true, get: function() {
+      return tailwind_mapper_1.cssToTailwind;
+    } });
+    var color_1 = require_color();
+    Object.defineProperty(exports, "figmaColorToCss", { enumerable: true, get: function() {
+      return color_1.figmaColorToCss;
+    } });
+    Object.defineProperty(exports, "px", { enumerable: true, get: function() {
+      return color_1.px;
+    } });
+    var asset_resolver_1 = require_asset_resolver();
+    Object.defineProperty(exports, "AssetResolver", { enumerable: true, get: function() {
+      return asset_resolver_1.AssetResolver;
+    } });
+    var ollama_client_1 = require_ollama_client();
+    Object.defineProperty(exports, "OllamaClient", { enumerable: true, get: function() {
+      return ollama_client_1.OllamaClient;
+    } });
+    Object.defineProperty(exports, "ollamaConfigFromEnv", { enumerable: true, get: function() {
+      return ollama_client_1.ollamaConfigFromEnv;
+    } });
+    var restructure_1 = require_restructure();
+    Object.defineProperty(exports, "LlmRestructure", { enumerable: true, get: function() {
+      return restructure_1.LlmRestructure;
+    } });
+    var refine_agent_1 = require_refine_agent();
+    Object.defineProperty(exports, "RefineAgent", { enumerable: true, get: function() {
+      return refine_agent_1.RefineAgent;
+    } });
+    var agent_runner_1 = require_agent_runner();
+    Object.defineProperty(exports, "runAgent", { enumerable: true, get: function() {
+      return agent_runner_1.runAgent;
+    } });
+    var strip_fence_1 = require_strip_fence();
+    Object.defineProperty(exports, "stripCodeFence", { enumerable: true, get: function() {
+      return strip_fence_1.stripCodeFence;
+    } });
+    var strip_assets_1 = require_strip_assets();
+    Object.defineProperty(exports, "stripHeavyAssets", { enumerable: true, get: function() {
+      return strip_assets_1.stripHeavyAssets;
+    } });
+    var convert_1 = require_convert();
+    Object.defineProperty(exports, "FigmaConverter", { enumerable: true, get: function() {
+      return convert_1.FigmaConverter;
+    } });
+    Object.defineProperty(exports, "countNodes", { enumerable: true, get: function() {
+      return convert_1.countNodes;
+    } });
+    var factory_1 = require_factory();
+    Object.defineProperty(exports, "createFigmaCore", { enumerable: true, get: function() {
+      return factory_1.createFigmaCore;
+    } });
+  }
+});
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/tools.ts
+var import_core = __toESM(require_dist(), 1);
+import { promises as fs2 } from "fs";
+import * as path2 from "path";
+
+// src/credentials.ts
+import { promises as fs } from "fs";
+import * as os from "os";
+import * as path from "path";
+var DIR = path.join(os.homedir(), ".figma-mcp");
+var FILE = path.join(DIR, "credentials.json");
+function credentialsPath() {
+  return FILE;
+}
+async function loadCredentials() {
+  try {
+    const raw = await fs.readFile(FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function saveCredentials(patch) {
+  const current = await loadCredentials();
+  const next = { ...current, ...patch };
+  await fs.mkdir(DIR, { recursive: true });
+  await fs.writeFile(FILE, JSON.stringify(next, null, 2), { mode: 384 });
+  return next;
+}
+async function clearCredentials() {
+  try {
+    await fs.unlink(FILE);
+  } catch {
+  }
+}
+
+// src/config.ts
+async function resolveConfig(overrides = {}) {
+  const creds = await loadCredentials();
+  const mode = overrides.mode ?? process.env.FIGMA_MCP_MODE ?? "auto";
+  const pat = overrides.pat ?? process.env.FIGMA_PAT ?? process.env.FIGMA_TOKEN ?? creds.pat;
+  const apiUrl = overrides.apiUrl ?? process.env.FIGMA_MCP_API ?? creds.apiUrl;
+  const apiToken = overrides.apiToken ?? process.env.FIGMA_MCP_TOKEN ?? creds.apiToken;
+  const outDir = overrides.outDir ?? process.env.FIGMA_MCP_OUT_DIR ?? `${process.cwd()}/figma-output`;
+  let effectiveMode;
+  if (mode === "local") {
+    effectiveMode = "local";
+  } else if (mode === "remote") {
+    effectiveMode = "remote";
+  } else {
+    effectiveMode = pat ? "local" : apiUrl ? "remote" : "local";
+  }
+  return { mode, effectiveMode, pat, apiUrl, apiToken, outDir };
+}
+function describeConfig(cfg) {
+  if (cfg.effectiveMode === "local") {
+    return `mode=local (figma-core) \xB7 PAT=${cfg.pat ? "set" : "MISSING"} \xB7 out=${cfg.outDir}`;
+  }
+  return `mode=remote \xB7 api=${cfg.apiUrl ?? "MISSING"} \xB7 token=${cfg.apiToken ? "set" : "none"} \xB7 out=${cfg.outDir}`;
+}
+
+// src/api-client.ts
+function authHeaders(cfg) {
+  const headers = { "Content-Type": "application/json" };
+  if (cfg.pat) headers["X-Figma-Token"] = cfg.pat;
+  if (cfg.apiToken) headers["Authorization"] = `Bearer ${cfg.apiToken}`;
+  return headers;
+}
+async function post(cfg, route, body) {
+  if (!cfg.apiUrl) throw new Error("Remote mode requires a backend URL (FIGMA_MCP_API).");
+  const url = `${cfg.apiUrl.replace(/\/+$/, "")}${route}`;
+  const res = await fetch(url, { method: "POST", headers: authHeaders(cfg), body: JSON.stringify(body) });
+  const text = await res.text();
+  if (!res.ok) {
+    let msg = `${res.status} ${res.statusText}`;
+    try {
+      const j = JSON.parse(text);
+      if (j?.message) msg = `${res.status}: ${j.message}`;
+    } catch {
+      if (text) msg = `${res.status}: ${text.slice(0, 300)}`;
+    }
+    throw new Error(`Backend ${url} failed \u2014 ${msg}`);
+  }
+  return text ? JSON.parse(text) : {};
+}
+function remoteConvert(cfg, body) {
+  return post(cfg, "/convert", body);
+}
+function remoteExtractStyles(cfg, body) {
+  return post(cfg, "/extract-styles", body);
+}
+
+// src/tools.ts
+var INLINE_LIMIT = 1e5;
+var core;
+var corePat;
+function getCore(pat) {
+  if (!core || corePat !== pat) {
+    core = (0, import_core.createFigmaCore)({ figmaToken: pat });
+    corePat = pat;
+  }
+  return core;
+}
+function sanitize(s) {
+  return (s || "figma").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "figma";
+}
+async function writeOut(outDir, fileName, content) {
+  await fs2.mkdir(outDir, { recursive: true });
+  const full = path2.resolve(outDir, fileName);
+  await fs2.writeFile(full, content, "utf8");
+  return full;
+}
+function target(args) {
+  return { figmaUrl: args.figmaUrl, fileKey: args.fileKey, nodeId: args.nodeId };
+}
+async function convertFigmaToHtml(args, overrides = {}) {
+  const cfg = await resolveConfig(overrides);
+  let result;
+  if (cfg.effectiveMode === "local") {
+    if (!cfg.pat) throw new Error("Local mode needs a Figma PAT. Run `figma-coder-mcp set-token <PAT>` or set FIGMA_PAT.");
+    const c = getCore(cfg.pat);
+    const r = await c.convert(target(args), { token: cfg.pat, bearer: false }, {
+      mode: args.mode,
+      document: args.document ?? true,
+      assets: args.assets,
+      assetScale: args.assetScale,
+      llm: args.llm
+    });
+    result = { name: r.name, nodeCount: r.nodeCount, mode: r.mode, llm: r.llm, html: r.html };
+  } else {
+    const r = await remoteConvert(cfg, {
+      ...target(args),
+      mode: args.mode,
+      document: args.document ?? true,
+      assets: args.assets,
+      assetScale: args.assetScale,
+      llm: args.llm
+    });
+    result = { name: r.name, nodeCount: r.nodeCount, mode: r.mode, llm: r.llm, html: r.html, previewUrl: r.previewUrl };
+  }
+  const fileName = args.outFile ?? `${sanitize(result.name)}.html`;
+  const filePath = await writeOut(cfg.outDir, fileName, result.html);
+  const bytes = Buffer.byteLength(result.html, "utf8");
+  return [
+    `Converted "${result.name}" (${describeConfig(cfg)}).`,
+    `- nodes: ${result.nodeCount}`,
+    `- mode: ${result.mode}${result.llm ? " + LLM restructure" : ""}`,
+    `- output: ${filePath} (${(bytes / 1024).toFixed(1)} KB)`,
+    result.previewUrl ? `- preview: ${cfg.apiUrl}${result.previewUrl}` : void 0,
+    "",
+    "The full HTML document was written to the file above. Open or read it to use the markup."
+  ].filter(Boolean).join("\n");
+}
+async function getFigmaData(args, overrides = {}) {
+  const cfg = await resolveConfig(overrides);
+  let ir;
+  if (cfg.effectiveMode === "local") {
+    if (!cfg.pat) throw new Error("Local mode needs a Figma PAT. Run `figma-coder-mcp set-token <PAT>` or set FIGMA_PAT.");
+    const c = getCore(cfg.pat);
+    ir = await c.extractStyles(target(args), { token: cfg.pat, bearer: false });
+  } else {
+    ir = await remoteExtractStyles(cfg, target(args));
+  }
+  const json = JSON.stringify(ir, null, 2);
+  const nodeCount = countIr(ir);
+  if (json.length <= INLINE_LIMIT) {
+    return [`Style IR for "${ir.name}" (${nodeCount} nodes, ${describeConfig(cfg)}):`, "", json].join("\n");
+  }
+  const filePath = await writeOut(cfg.outDir, `${sanitize(ir.name)}.ir.json`, json);
+  return [
+    `Style IR for "${ir.name}" is large (${nodeCount} nodes, ${(json.length / 1024).toFixed(1)} KB) \u2014 written to a file.`,
+    `- file: ${filePath}`,
+    `- root: <${ir.tag}> figmaType=${ir.figmaType}, css keys=${Object.keys(ir.css || {}).length}`,
+    "",
+    "Top-level children:",
+    ...(ir.children || []).map(
+      (c, i) => `  ${i}. "${c.name}" <${c.tag}> ${c.figmaType} (${(c.children || []).length} children)`
+    ),
+    "",
+    "Read the file for the full tree (each node has exact `css`)."
+  ].join("\n");
+}
+function countIr(node) {
+  if (!node) return 0;
+  return 1 + (node.children || []).reduce((s, c) => s + countIr(c), 0);
+}
+
+// src/server.ts
+var targetShape = {
+  figmaUrl: z.string().optional().describe("Full Figma URL (file/design link, may include ?node-id=)."),
+  fileKey: z.string().optional().describe("Figma file key (alternative to figmaUrl)."),
+  nodeId: z.string().optional().describe('Node id in URL form "1-23" or REST form "1:23". Omitted with fileKey = whole file.')
+};
+function safe(handler) {
+  return async (args) => {
+    try {
+      const text = await handler(args);
+      return { content: [{ type: "text", text }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err?.message ?? String(err)}` }], isError: true };
+    }
+  };
+}
+function buildServer() {
+  const server = new McpServer({ name: "figma-coder-mcp", version: "0.1.0" });
+  server.registerTool(
+    "get_figma_data",
+    {
+      title: "Get Figma design data",
+      description: "Fetch the deterministic Style IR (exact CSS per node) for a Figma file or node, so an agent can reason about the design and generate code itself. Small trees are returned inline; large trees are written to a JSON file and summarised.",
+      inputSchema: targetShape
+    },
+    safe((a) => getFigmaData(a))
+  );
+  server.registerTool(
+    "convert_figma_to_html",
+    {
+      title: "Convert Figma to HTML + Tailwind",
+      description: "Convert a Figma file/node into finished, self-contained HTML + Tailwind (deterministic Style IR, assets inlined, optional LLM restructure). The HTML is written to a file; a compact summary + path is returned to keep context small.",
+      inputSchema: {
+        ...targetShape,
+        mode: z.enum(["tailwind", "inline"]).optional().describe("Output mode. Default 'tailwind'."),
+        document: z.boolean().optional().describe("Emit a full HTML document (default true) vs a fragment."),
+        assets: z.boolean().optional().describe("Export & inline vectors/images as data URIs. Default true."),
+        assetScale: z.number().min(1).max(4).optional().describe("Raster export scale (1-4). Default 2."),
+        llm: z.boolean().optional().describe("Run the LLM restructure pass (needs OLLAMA_* config). Default false."),
+        outFile: z.string().optional().describe("Override the output file name (within the output dir).")
+      }
+    },
+    safe((a) => convertFigmaToHtml(a))
+  );
+  return server;
+}
+async function serveStdio() {
+  const server = buildServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[figma-coder-mcp] stdio server ready");
+}
+
+// src/bin.ts
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next === void 0 || next.startsWith("--")) {
+        flags[key] = true;
+      } else {
+        flags[key] = next;
+        i++;
+      }
+    } else {
+      positionals.push(a);
+    }
+  }
+  return [positionals, flags];
+}
+function targetFrom(value, flags) {
+  const nodeId = typeof flags.node === "string" ? flags.node : void 0;
+  if (!value) throw new Error("Provide a Figma URL or fileKey.");
+  if (/figma\.com\//.test(value)) return { figmaUrl: value, nodeId };
+  return { fileKey: value, nodeId };
+}
+var HELP = `figma-coder-mcp \u2014 Figma -> HTML/Tailwind for AI agents (MCP server + CLI)
+
+Usage:
+  figma-coder-mcp [serve]                 Start the MCP server over stdio (default)
+  figma-coder-mcp convert <url|key> [..]  One-off convert to HTML (writes a file)
+  figma-coder-mcp data <url|key> [..]     One-off: print/save the Style IR
+  figma-coder-mcp set-token <PAT>         Store a Figma personal access token (local mode)
+  figma-coder-mcp set-api <URL>           Store the backend converter URL (remote mode)
+  figma-coder-mcp status                  Show how requests will be served (no secrets)
+  figma-coder-mcp logout                  Remove stored credentials
+  figma-coder-mcp help                    Show this help
+
+Common flags (convert/data):
+  --node <id>     Node id ("1-23" or "1:23")
+  --mode <m>      tailwind | inline (convert)
+  --no-assets     Skip asset inlining (convert)
+  --llm           Run LLM restructure (convert; needs OLLAMA_* env)
+  --out <file>    Output file name (convert)
+
+Config (env or stored): FIGMA_PAT, FIGMA_MCP_API, FIGMA_MCP_TOKEN, FIGMA_MCP_MODE,
+FIGMA_MCP_OUT_DIR. Auto mode prefers local (PAT) so it works even if the backend is down.`;
+async function main() {
+  const [positionals, flags] = parseArgs(process.argv.slice(2));
+  const cmd = positionals[0] ?? "serve";
+  switch (cmd) {
+    case "serve":
+      await serveStdio();
+      return;
+    // keep process alive on the transport
+    case "convert": {
+      const text = await convertFigmaToHtml({
+        ...targetFrom(positionals[1], flags),
+        mode: flags.mode === "inline" ? "inline" : flags.mode === "tailwind" ? "tailwind" : void 0,
+        assets: flags["no-assets"] ? false : void 0,
+        llm: flags.llm === true,
+        outFile: typeof flags.out === "string" ? flags.out : void 0
+      });
+      console.log(text);
+      return;
+    }
+    case "data": {
+      const text = await getFigmaData(targetFrom(positionals[1], flags));
+      console.log(text);
+      return;
+    }
+    case "set-token": {
+      const pat = positionals[1];
+      if (!pat) throw new Error("Usage: figma-coder-mcp set-token <PAT>");
+      await saveCredentials({ pat });
+      console.log(`Stored Figma PAT in ${credentialsPath()}`);
+      return;
+    }
+    case "set-api": {
+      const url = positionals[1];
+      if (!url) throw new Error("Usage: figma-coder-mcp set-api <URL>");
+      await saveCredentials({ apiUrl: url });
+      console.log(`Stored backend URL (${url}) in ${credentialsPath()}`);
+      return;
+    }
+    case "status": {
+      const cfg = await resolveConfig();
+      console.log(describeConfig(cfg));
+      console.log(`credentials: ${credentialsPath()}`);
+      return;
+    }
+    case "logout":
+      await clearCredentials();
+      console.log("Cleared stored credentials.");
+      return;
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(HELP);
+      return;
+    default:
+      console.error(`Unknown command: ${cmd}
+`);
+      console.error(HELP);
+      process.exitCode = 1;
+  }
+}
+main().catch((err) => {
+  console.error(`figma-coder-mcp: ${err?.message ?? err}`);
+  process.exitCode = 1;
+});