@mstrathman/figma 0.1.0

package/dist/main.js

@@ -0,0 +1,2734 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api/client.ts
+var client_exports = {};
+__export(client_exports, {
+  FigmaApiError: () => FigmaApiError,
+  FigmaClient: () => FigmaClient,
+  FigmaNetworkError: () => FigmaNetworkError
+});
+var FIGMA_API_BASE, DEFAULT_TIMEOUT_MS, MAX_RETRIES, INITIAL_RETRY_DELAY_MS, FigmaApiError, FigmaNetworkError, FigmaClient;
+var init_client = __esm({
+  "src/api/client.ts"() {
+    "use strict";
+    FIGMA_API_BASE = "https://api.figma.com/v1";
+    DEFAULT_TIMEOUT_MS = 3e4;
+    MAX_RETRIES = 3;
+    INITIAL_RETRY_DELAY_MS = 1e3;
+    FigmaApiError = class extends Error {
+      constructor(status, statusText, body) {
+        super(`Figma API error: ${status} ${statusText}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = "FigmaApiError";
+      }
+      isRateLimited() {
+        return this.status === 429;
+      }
+      isServerError() {
+        return this.status >= 500;
+      }
+    };
+    FigmaNetworkError = class extends Error {
+      constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "FigmaNetworkError";
+      }
+    };
+    FigmaClient = class {
+      token;
+      baseUrl;
+      timeout;
+      maxRetries;
+      constructor(options) {
+        if (!options.token || options.token.trim() === "") {
+          throw new Error("Figma API token is required");
+        }
+        this.token = options.token;
+        this.baseUrl = options.baseUrl ?? FIGMA_API_BASE;
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.maxRetries = options.maxRetries ?? MAX_RETRIES;
+      }
+      async request(method, path5, options = {}, retryCount = 0) {
+        const baseWithSlash = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
+        const pathWithoutLeadingSlash = path5.startsWith("/") ? path5.slice(1) : path5;
+        const url = new URL(pathWithoutLeadingSlash, baseWithSlash);
+        if (options.params) {
+          for (const [key, value] of Object.entries(options.params)) {
+            if (value !== void 0) {
+              if (Array.isArray(value)) {
+                const filtered = value.filter((v) => v !== "");
+                if (filtered.length > 0) {
+                  url.searchParams.set(key, filtered.join(","));
+                }
+              } else {
+                url.searchParams.set(key, String(value));
+              }
+            }
+          }
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        let response;
+        try {
+          response = await fetch(url.toString(), {
+            method,
+            headers: {
+              "X-Figma-Token": this.token,
+              "Content-Type": "application/json"
+            },
+            body: options.body ? JSON.stringify(options.body) : void 0,
+            signal: controller.signal
+          });
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error instanceof Error && error.name === "AbortError") {
+            throw new FigmaNetworkError(
+              `Request timed out after ${this.timeout}ms`,
+              error
+            );
+          }
+          throw new FigmaNetworkError(
+            `Network error: ${error instanceof Error ? error.message : "Unknown error"}`,
+            error instanceof Error ? error : void 0
+          );
+        } finally {
+          clearTimeout(timeoutId);
+        }
+        if (response.status === 429 && retryCount < this.maxRetries) {
+          const retryAfter = response.headers.get("Retry-After");
+          const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : INITIAL_RETRY_DELAY_MS * Math.pow(2, retryCount);
+          await this.sleep(delayMs);
+          return this.request(method, path5, options, retryCount + 1);
+        }
+        if (response.status >= 500 && retryCount < this.maxRetries) {
+          const delayMs = INITIAL_RETRY_DELAY_MS * Math.pow(2, retryCount);
+          await this.sleep(delayMs);
+          return this.request(method, path5, options, retryCount + 1);
+        }
+        if (!response.ok) {
+          let body;
+          try {
+            body = await response.json();
+          } catch {
+            try {
+              body = await response.text();
+            } catch {
+              body = null;
+            }
+          }
+          throw new FigmaApiError(response.status, response.statusText, body);
+        }
+        return response.json();
+      }
+      sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
+      // User endpoints
+      async getMe() {
+        return this.request("GET", "/me");
+      }
+      // File endpoints
+      async getFile(fileKey, options) {
+        return this.request("GET", `/files/${fileKey}`, {
+          params: options
+        });
+      }
+      async getFileNodes(fileKey, nodeIds, options) {
+        return this.request(
+          "GET",
+          `/files/${fileKey}/nodes`,
+          {
+            params: {
+              ids: nodeIds,
+              ...options
+            }
+          }
+        );
+      }
+      async getImages(fileKey, nodeIds, options) {
+        return this.request("GET", `/images/${fileKey}`, {
+          params: {
+            ids: nodeIds,
+            ...options
+          }
+        });
+      }
+      async getImageFills(fileKey) {
+        return this.request(
+          "GET",
+          `/files/${fileKey}/images`
+        );
+      }
+      // Project endpoints
+      async getTeamProjects(teamId) {
+        return this.request(
+          "GET",
+          `/teams/${teamId}/projects`
+        );
+      }
+      async getProjectFiles(projectId, options) {
+        return this.request(
+          "GET",
+          `/projects/${projectId}/files`,
+          { params: options }
+        );
+      }
+      // Component endpoints
+      async getTeamComponents(teamId, options) {
+        return this.request(
+          "GET",
+          `/teams/${teamId}/components`,
+          { params: options }
+        );
+      }
+      async getFileComponents(fileKey) {
+        return this.request(
+          "GET",
+          `/files/${fileKey}/components`
+        );
+      }
+      async getComponent(componentKey) {
+        return this.request(
+          "GET",
+          `/components/${componentKey}`
+        );
+      }
+      async getTeamComponentSets(teamId, options) {
+        return this.request(
+          "GET",
+          `/teams/${teamId}/component_sets`,
+          { params: options }
+        );
+      }
+      async getFileComponentSets(fileKey) {
+        return this.request(
+          "GET",
+          `/files/${fileKey}/component_sets`
+        );
+      }
+      // Style endpoints
+      async getTeamStyles(teamId, options) {
+        return this.request(
+          "GET",
+          `/teams/${teamId}/styles`,
+          { params: options }
+        );
+      }
+      async getFileStyles(fileKey) {
+        return this.request(
+          "GET",
+          `/files/${fileKey}/styles`
+        );
+      }
+      async getStyle(styleKey) {
+        return this.request("GET", `/styles/${styleKey}`);
+      }
+      // Variable endpoints (Enterprise)
+      async getLocalVariables(fileKey) {
+        return this.request(
+          "GET",
+          `/files/${fileKey}/variables/local`
+        );
+      }
+      async getPublishedVariables(fileKey) {
+        return this.request(
+          "GET",
+          `/files/${fileKey}/variables/published`
+        );
+      }
+      // Comments endpoints
+      async getComments(fileKey) {
+        return this.request(
+          "GET",
+          `/files/${fileKey}/comments`
+        );
+      }
+      async postComment(fileKey, message, options) {
+        return this.request(
+          "POST",
+          `/files/${fileKey}/comments`,
+          {
+            body: {
+              message,
+              ...options
+            }
+          }
+        );
+      }
+      // Webhooks endpoints
+      async getTeamWebhooks(teamId) {
+        return this.request(
+          "GET",
+          `/webhooks/team/${teamId}`
+        );
+      }
+      async getWebhook(webhookId) {
+        return this.request(
+          "GET",
+          `/webhooks/${webhookId}`
+        );
+      }
+      // Generic API method for raw access
+      async api(method, path5, options) {
+        const normalizedPath = path5.startsWith("/") ? path5 : `/${path5}`;
+        return this.request(method.toUpperCase(), normalizedPath, options);
+      }
+    };
+  }
+});
+
+// src/internal/config/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".config", "figma");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var LOCAL_CONFIG_FILE = ".figmarc";
+var ConfigManager = class {
+  config = {};
+  loaded = false;
+  constructor() {
+  }
+  load() {
+    if (this.loaded) {
+      return this.config;
+    }
+    this.config = {};
+    const userConfig = this.loadUserConfig();
+    this.config = { ...this.config, ...userConfig };
+    const localConfig = this.loadLocalConfig();
+    this.config = { ...this.config, ...localConfig };
+    this.applyEnvVars();
+    this.loaded = true;
+    return this.config;
+  }
+  loadUserConfig() {
+    try {
+      if (fs.existsSync(CONFIG_FILE)) {
+        const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {
+    }
+    return {};
+  }
+  loadLocalConfig() {
+    try {
+      if (fs.existsSync(LOCAL_CONFIG_FILE)) {
+        const content = fs.readFileSync(LOCAL_CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {
+    }
+    return {};
+  }
+  applyEnvVars() {
+    if (process.env.FIGMA_TOKEN) {
+      this.config.token = process.env.FIGMA_TOKEN;
+    }
+    if (process.env.FIGMA_TEAM_ID) {
+      this.config.teamId = process.env.FIGMA_TEAM_ID;
+    }
+  }
+  get(key) {
+    if (!this.loaded) {
+      this.load();
+    }
+    return this.config[key];
+  }
+  set(key, value) {
+    if (!this.loaded) {
+      this.load();
+    }
+    this.config[key] = value;
+    this.save();
+  }
+  getAll() {
+    if (!this.loaded) {
+      this.load();
+    }
+    return { ...this.config };
+  }
+  save() {
+    try {
+      if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      }
+      const { token: _token, ...safeConfig } = this.config;
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(safeConfig, null, 2));
+    } catch {
+    }
+  }
+  getConfigDir() {
+    return CONFIG_DIR;
+  }
+  getConfigFile() {
+    return CONFIG_FILE;
+  }
+};
+
+// src/internal/auth/keyring.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+var SERVICE_NAME = "figma";
+var ACCOUNT_NAME = "default";
+var CREDENTIALS_DIR = path2.join(os2.homedir(), ".config", "figma");
+var CREDENTIALS_FILE = path2.join(CREDENTIALS_DIR, "credentials.json");
+var KeytarAuthStore = class {
+  keytar = null;
+  async getKeytar() {
+    if (this.keytar) {
+      return this.keytar;
+    }
+    try {
+      this.keytar = await import("keytar");
+      return this.keytar;
+    } catch {
+      return null;
+    }
+  }
+  async getToken() {
+    const keytar = await this.getKeytar();
+    if (!keytar) {
+      return null;
+    }
+    try {
+      return await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
+    } catch {
+      return null;
+    }
+  }
+  async setToken(token) {
+    const keytar = await this.getKeytar();
+    if (!keytar) {
+      throw new Error("Keytar not available");
+    }
+    await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, token);
+  }
+  async deleteToken() {
+    const keytar = await this.getKeytar();
+    if (!keytar) {
+      throw new Error("Keytar not available");
+    }
+    await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
+  }
+  async isAvailable() {
+    const keytar = await this.getKeytar();
+    return keytar !== null;
+  }
+};
+var FileAuthStore = class {
+  async getToken() {
+    try {
+      if (!fs2.existsSync(CREDENTIALS_FILE)) {
+        return null;
+      }
+      const content = fs2.readFileSync(CREDENTIALS_FILE, "utf-8");
+      const credentials = JSON.parse(content);
+      return credentials.token ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async setToken(token) {
+    if (!fs2.existsSync(CREDENTIALS_DIR)) {
+      fs2.mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 448 });
+    }
+    let credentials = {};
+    try {
+      if (fs2.existsSync(CREDENTIALS_FILE)) {
+        const content = fs2.readFileSync(CREDENTIALS_FILE, "utf-8");
+        credentials = JSON.parse(content);
+      }
+    } catch {
+    }
+    credentials.token = token;
+    fs2.writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), {
+      mode: 384
+      // Only owner can read/write
+    });
+  }
+  async deleteToken() {
+    try {
+      if (fs2.existsSync(CREDENTIALS_FILE)) {
+        const content = fs2.readFileSync(CREDENTIALS_FILE, "utf-8");
+        const credentials = JSON.parse(content);
+        delete credentials.token;
+        if (Object.keys(credentials).length === 0) {
+          fs2.unlinkSync(CREDENTIALS_FILE);
+        } else {
+          fs2.writeFileSync(
+            CREDENTIALS_FILE,
+            JSON.stringify(credentials, null, 2),
+            { mode: 384 }
+          );
+        }
+      }
+    } catch {
+    }
+  }
+};
+var AuthManager = class {
+  keytarStore;
+  fileStore;
+  useKeytar = null;
+  onFallback = null;
+  fallbackWarningShown = false;
+  constructor(onFallback) {
+    this.keytarStore = new KeytarAuthStore();
+    this.fileStore = new FileAuthStore();
+    this.onFallback = onFallback ?? null;
+  }
+  async shouldUseKeytar() {
+    if (this.useKeytar !== null) {
+      return this.useKeytar;
+    }
+    this.useKeytar = await this.keytarStore.isAvailable();
+    return this.useKeytar;
+  }
+  notifyFallback(reason) {
+    if (this.onFallback && !this.fallbackWarningShown) {
+      this.fallbackWarningShown = true;
+      this.onFallback(
+        `Warning: Using file-based credential storage (${reason}). Token stored in ${CREDENTIALS_FILE}`
+      );
+    }
+  }
+  async getToken() {
+    if (await this.shouldUseKeytar()) {
+      const token = await this.keytarStore.getToken();
+      if (token) {
+        return token;
+      }
+    }
+    return this.fileStore.getToken();
+  }
+  async setToken(token) {
+    if (await this.shouldUseKeytar()) {
+      try {
+        await this.keytarStore.setToken(token);
+        return;
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : "keytar failed";
+        this.notifyFallback(reason);
+      }
+    } else {
+      this.notifyFallback("system keyring not available");
+    }
+    await this.fileStore.setToken(token);
+  }
+  async deleteToken() {
+    const useKeytar = await this.shouldUseKeytar();
+    if (useKeytar) {
+      try {
+        await this.keytarStore.deleteToken();
+      } catch {
+      }
+    }
+    await this.fileStore.deleteToken();
+  }
+  async getStorageType() {
+    if (await this.shouldUseKeytar()) {
+      const token = await this.keytarStore.getToken();
+      if (token) {
+        return "keyring";
+      }
+    }
+    return "file";
+  }
+};
+
+// src/internal/auth/oauth.ts
+import * as http from "http";
+import * as crypto from "crypto";
+import { URL as URL2 } from "url";
+var FIGMA_OAUTH_URL = "https://www.figma.com/oauth";
+var FIGMA_TOKEN_URL = "https://www.figma.com/api/oauth/token";
+var MAX_PORT = 65535;
+function generateState() {
+  return crypto.randomBytes(16).toString("hex");
+}
+function verifyState(received, expected) {
+  if (received.length !== expected.length) {
+    return false;
+  }
+  try {
+    return crypto.timingSafeEqual(
+      Buffer.from(received, "utf8"),
+      Buffer.from(expected, "utf8")
+    );
+  } catch {
+    return false;
+  }
+}
+async function findAvailablePort(startPort, maxPort = MAX_PORT) {
+  if (startPort > maxPort) {
+    throw new Error(`No available ports found between 8585 and ${maxPort}`);
+  }
+  return new Promise((resolve, reject) => {
+    const server = http.createServer();
+    server.listen(startPort, "127.0.0.1", () => {
+      const address = server.address();
+      if (address && typeof address === "object") {
+        const port = address.port;
+        server.close(() => resolve(port));
+      } else {
+        reject(new Error("Could not get server address"));
+      }
+    });
+    server.on("error", () => {
+      findAvailablePort(startPort + 1, maxPort).then(resolve).catch(reject);
+    });
+  });
+}
+async function startOAuthFlow(config, onOpenUrl) {
+  const port = await findAvailablePort(8585);
+  const redirectUri = config.redirectUri || `http://127.0.0.1:${port}/callback`;
+  const state = generateState();
+  const scopes = config.scopes || ["files:read"];
+  return new Promise((resolve, reject) => {
+    let serverClosed = false;
+    const closeServer = () => {
+      if (!serverClosed) {
+        serverClosed = true;
+        server.close();
+      }
+    };
+    const server = http.createServer(async (req, res) => {
+      const url = new URL2(req.url || "/", `http://127.0.0.1:${port}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const returnedState = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(getErrorHtml(error));
+          closeServer();
+          reject(new Error(`OAuth error: ${error}`));
+          return;
+        }
+        if (!returnedState || !verifyState(returnedState, state)) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(getErrorHtml("State mismatch - possible CSRF attack"));
+          closeServer();
+          reject(new Error("OAuth state mismatch"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(getErrorHtml("No authorization code received"));
+          closeServer();
+          reject(new Error("No authorization code"));
+          return;
+        }
+        try {
+          const tokenResponse = await fetch(FIGMA_TOKEN_URL, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+              client_id: config.clientId,
+              client_secret: config.clientSecret,
+              redirect_uri: redirectUri,
+              code,
+              grant_type: "authorization_code"
+            })
+          });
+          if (!tokenResponse.ok) {
+            const errorText = await tokenResponse.text();
+            throw new Error(`Token exchange failed: ${errorText}`);
+          }
+          const tokenData = await tokenResponse.json();
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(getSuccessHtml());
+          closeServer();
+          resolve({
+            accessToken: tokenData.access_token,
+            refreshToken: tokenData.refresh_token,
+            expiresIn: tokenData.expires_in,
+            userId: tokenData.user_id?.toString()
+          });
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "text/html" });
+          res.end(
+            getErrorHtml(err instanceof Error ? err.message : "Unknown error")
+          );
+          closeServer();
+          reject(err);
+        }
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+      const authUrl = new URL2(FIGMA_OAUTH_URL);
+      authUrl.searchParams.set("client_id", config.clientId);
+      authUrl.searchParams.set("redirect_uri", redirectUri);
+      authUrl.searchParams.set("scope", scopes.join(","));
+      authUrl.searchParams.set("state", state);
+      authUrl.searchParams.set("response_type", "code");
+      onOpenUrl(authUrl.toString());
+    });
+    setTimeout(
+      () => {
+        closeServer();
+        reject(new Error("OAuth flow timed out"));
+      },
+      5 * 60 * 1e3
+    );
+  });
+}
+function getSuccessHtml() {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Figma CLI - Authentication Successful</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    }
+    .card {
+      background: white;
+      padding: 3rem;
+      border-radius: 16px;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+      text-align: center;
+      max-width: 400px;
+    }
+    .checkmark {
+      width: 80px;
+      height: 80px;
+      background: #10b981;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0 auto 1.5rem;
+    }
+    .checkmark svg {
+      width: 40px;
+      height: 40px;
+      stroke: white;
+      stroke-width: 3;
+    }
+    h1 { color: #1f2937; margin: 0 0 0.5rem; }
+    p { color: #6b7280; margin: 0; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="checkmark">
+      <svg viewBox="0 0 24 24" fill="none">
+        <path d="M5 13l4 4L19 7" stroke-linecap="round" stroke-linejoin="round"/>
+      </svg>
+    </div>
+    <h1>Authentication Successful!</h1>
+    <p>You can close this window and return to your terminal.</p>
+  </div>
+</body>
+</html>`;
+}
+function getErrorHtml(error) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Figma CLI - Authentication Failed</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
+    }
+    .card {
+      background: white;
+      padding: 3rem;
+      border-radius: 16px;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+      text-align: center;
+      max-width: 400px;
+    }
+    .error-icon {
+      width: 80px;
+      height: 80px;
+      background: #ef4444;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0 auto 1.5rem;
+    }
+    .error-icon svg {
+      width: 40px;
+      height: 40px;
+      stroke: white;
+      stroke-width: 3;
+    }
+    h1 { color: #1f2937; margin: 0 0 0.5rem; }
+    p { color: #6b7280; margin: 0; }
+    .error-detail {
+      background: #fef2f2;
+      color: #991b1b;
+      padding: 1rem;
+      border-radius: 8px;
+      margin-top: 1rem;
+      font-size: 0.875rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="error-icon">
+      <svg viewBox="0 0 24 24" fill="none">
+        <path d="M6 18L18 6M6 6l12 12" stroke-linecap="round" stroke-linejoin="round"/>
+      </svg>
+    </div>
+    <h1>Authentication Failed</h1>
+    <p>Something went wrong during authentication.</p>
+    <div class="error-detail">${escapeHtml(error)}</div>
+  </div>
+</body>
+</html>`;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+
+// src/pkg/cmdutil/factory.ts
+init_client();
+
+// src/pkg/iostreams/iostreams.ts
+function createIOStreams() {
+  const isTTY = process.stdout.isTTY ?? false;
+  return {
+    in: process.stdin,
+    out: process.stdout,
+    err: process.stderr,
+    isInteractive: isTTY && process.env.CI !== "true",
+    isTTY
+  };
+}
+
+// src/pkg/cmdutil/factory.ts
+import chalk from "chalk";
+function createFactory() {
+  const config = new ConfigManager();
+  const io = createIOStreams();
+  const auth = new AuthManager((message) => {
+    io.err.write(chalk.yellow(`${message}
+`));
+  });
+  let clientCache = null;
+  return {
+    config,
+    auth,
+    io,
+    async getToken(tokenOption) {
+      if (tokenOption) {
+        return tokenOption;
+      }
+      config.load();
+      const envToken = config.get("token");
+      if (envToken) {
+        return envToken;
+      }
+      const storedToken = await auth.getToken();
+      if (storedToken) {
+        return storedToken;
+      }
+      throw new Error(
+        `No Figma token found. Please run ${chalk.cyan("figma auth login")} or set the ${chalk.cyan("FIGMA_TOKEN")} environment variable.`
+      );
+    },
+    async getClient() {
+      if (clientCache) {
+        return clientCache;
+      }
+      const token = await this.getToken();
+      clientCache = new FigmaClient({ token });
+      return clientCache;
+    }
+  };
+}
+
+// src/cmd/root.ts
+import { Command as Command26 } from "commander";
+
+// src/cmd/auth/index.ts
+import { Command as Command4 } from "commander";
+
+// src/cmd/auth/login.ts
+init_client();
+import { Command } from "commander";
+import chalk2 from "chalk";
+import { spawn } from "child_process";
+import { platform } from "os";
+function openBrowser(url) {
+  const plat = platform();
+  if (plat === "darwin") {
+    spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+  } else if (plat === "win32") {
+    spawn("cmd", ["/c", "start", "", url], {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+  } else {
+    spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+  }
+}
+function displayUserInfo(io, user) {
+  io.out.write(chalk2.green("\u2713 Logged in as "));
+  io.out.write(chalk2.bold(user.handle || user.email));
+  io.out.write("\n");
+}
+async function performOAuthFlow(io, auth, clientId, clientSecret, scopes) {
+  io.out.write(chalk2.cyan("Opening browser for authentication...\n"));
+  io.out.write(chalk2.dim("Waiting for authorization...\n\n"));
+  const result = await startOAuthFlow(
+    { clientId, clientSecret, scopes },
+    (url) => {
+      io.out.write(chalk2.dim(`If browser doesn't open, visit:
+${url}
+
+`));
+      openBrowser(url);
+    }
+  );
+  await auth.setToken(result.accessToken);
+  const client = new FigmaClient({ token: result.accessToken });
+  const user = await client.getMe();
+  displayUserInfo(io, user);
+}
+function createLoginCommand(factory) {
+  const cmd = new Command("login").description("Authenticate with Figma").option("-t, --token <token>", "Personal access token").option("-w, --web", "Login via browser (OAuth)").option("--client-id <id>", "OAuth client ID (or set FIGMA_CLIENT_ID)").option("--scopes <scopes>", "OAuth scopes (comma-separated)", "files:read").action(
+    async (options) => {
+      const { io, auth } = factory;
+      if (options.web) {
+        const clientId = options.clientId || process.env.FIGMA_CLIENT_ID;
+        const clientSecret = process.env.FIGMA_CLIENT_SECRET;
+        if (!clientId || !clientSecret) {
+          io.err.write(
+            chalk2.red("Error: OAuth requires client ID and secret.\n\n")
+          );
+          io.err.write(chalk2.dim("Set them via environment variables:\n"));
+          io.err.write(
+            chalk2.dim("  export FIGMA_CLIENT_ID=your_client_id\n")
+          );
+          io.err.write(
+            chalk2.dim("  export FIGMA_CLIENT_SECRET=your_client_secret\n\n")
+          );
+          io.err.write(
+            chalk2.dim("You can also pass --client-id as a flag.\n")
+          );
+          io.err.write(
+            chalk2.yellow(
+              "\nNote: Client secret must be set via FIGMA_CLIENT_SECRET env var for security.\n"
+            )
+          );
+          io.err.write(
+            chalk2.dim(
+              "\nCreate an OAuth app at: https://www.figma.com/developers/apps\n"
+            )
+          );
+          process.exit(1);
+        }
+        try {
+          await performOAuthFlow(
+            io,
+            auth,
+            clientId,
+            clientSecret,
+            options.scopes?.split(",")
+          );
+        } catch (error) {
+          io.err.write(chalk2.red("Error: OAuth authentication failed.\n"));
+          if (error instanceof Error) {
+            io.err.write(chalk2.dim(`${error.message}
+`));
+          }
+          process.exit(1);
+        }
+        return;
+      }
+      let token = options.token;
+      if (!token) {
+        if (!io.isInteractive) {
+          io.err.write(
+            chalk2.red(
+              "Error: No token provided. Use --token, --web, or run interactively.\n"
+            )
+          );
+          io.err.write(
+            chalk2.dim(
+              "\nGet a personal access token from: https://www.figma.com/developers/api#access-tokens\n"
+            )
+          );
+          process.exit(1);
+        }
+        const { default: Enquirer } = await import("enquirer");
+        const enquirer = new Enquirer();
+        const methodResponse = await enquirer.prompt({
+          type: "select",
+          name: "method",
+          message: "How would you like to authenticate?",
+          choices: [
+            { name: "token", message: "Paste a personal access token" },
+            {
+              name: "web",
+              message: "Login with browser (requires OAuth app)"
+            }
+          ]
+        });
+        if (methodResponse.method === "web") {
+          const clientIdResponse = await enquirer.prompt({
+            type: "input",
+            name: "clientId",
+            message: "OAuth Client ID:",
+            initial: process.env.FIGMA_CLIENT_ID
+          });
+          const clientSecretResponse = await enquirer.prompt({
+            type: "password",
+            name: "clientSecret",
+            message: "OAuth Client Secret:"
+          });
+          if (!clientIdResponse.clientId || !clientSecretResponse.clientSecret) {
+            io.err.write(
+              chalk2.red("Error: Client ID and secret are required.\n")
+            );
+            process.exit(1);
+          }
+          try {
+            await performOAuthFlow(
+              io,
+              auth,
+              clientIdResponse.clientId,
+              clientSecretResponse.clientSecret
+            );
+          } catch (error) {
+            io.err.write(chalk2.red("Error: OAuth authentication failed.\n"));
+            if (error instanceof Error) {
+              io.err.write(chalk2.dim(`${error.message}
+`));
+            }
+            process.exit(1);
+          }
+          return;
+        }
+        io.out.write(
+          chalk2.cyan(
+            "\nGet a personal access token from: https://www.figma.com/developers/api#access-tokens\n\n"
+          )
+        );
+        const tokenResponse = await enquirer.prompt({
+          type: "password",
+          name: "token",
+          message: "Paste your token:"
+        });
+        token = tokenResponse.token;
+      }
+      if (!token || token.trim() === "") {
+        io.err.write(chalk2.red("Error: Token cannot be empty.\n"));
+        process.exit(1);
+      }
+      io.out.write(chalk2.dim("Verifying token...\n"));
+      try {
+        const client = new FigmaClient({ token });
+        const user = await client.getMe();
+        await auth.setToken(token);
+        displayUserInfo(io, user);
+      } catch (error) {
+        io.err.write(chalk2.red("Error: Invalid token or API error.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk2.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/auth/logout.ts
+import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
+function createLogoutCommand(factory) {
+  const cmd = new Command2("logout").description("Remove stored Figma credentials").action(async () => {
+    const { io, auth } = factory;
+    const existingToken = await auth.getToken();
+    if (!existingToken) {
+      io.out.write(chalk3.yellow("No stored credentials found.\n"));
+      return;
+    }
+    await auth.deleteToken();
+    io.out.write(chalk3.green("\u2713 Logged out successfully.\n"));
+  });
+  return cmd;
+}
+
+// src/cmd/auth/status.ts
+init_client();
+import { Command as Command3 } from "commander";
+import chalk4 from "chalk";
+function createStatusCommand(factory) {
+  const cmd = new Command3("status").description("Show authentication status").action(async () => {
+    const { io, auth, config } = factory;
+    config.load();
+    const envToken = config.get("token");
+    const storedToken = await auth.getToken();
+    const token = envToken || storedToken;
+    if (!token) {
+      io.out.write(chalk4.yellow("Not logged in.\n"));
+      io.out.write(
+        chalk4.dim(`Run ${chalk4.cyan("figma auth login")} to authenticate.
+`)
+      );
+      return;
+    }
+    const source = envToken ? "environment variable" : "stored credential";
+    try {
+      const client = new FigmaClient({ token });
+      const user = await client.getMe();
+      io.out.write(chalk4.green("\u2713 Logged in to Figma\n\n"));
+      io.out.write(
+        `  ${chalk4.dim("User:")}    ${user.handle || user.email}
+`
+      );
+      io.out.write(`  ${chalk4.dim("Email:")}   ${user.email}
+`);
+      io.out.write(`  ${chalk4.dim("User ID:")} ${user.id}
+`);
+      io.out.write(`  ${chalk4.dim("Source:")}  ${source}
+`);
+      if (envToken) {
+        io.out.write(
+          chalk4.dim("\n  Token from FIGMA_TOKEN environment variable.\n")
+        );
+      } else {
+        const storageType = await auth.getStorageType();
+        io.out.write(chalk4.dim(`
+  Token stored in ${storageType}.
+`));
+      }
+    } catch (error) {
+      io.err.write(chalk4.red("Error: Token is invalid or expired.\n"));
+      if (error instanceof Error) {
+        io.err.write(chalk4.dim(`${error.message}
+`));
+      }
+      io.out.write(
+        chalk4.dim(
+          `
+Run ${chalk4.cyan("figma auth login")} to re-authenticate.
+`
+        )
+      );
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/cmd/auth/index.ts
+function createAuthCommand(factory) {
+  const cmd = new Command4("auth").description("Manage Figma authentication");
+  cmd.addCommand(createLoginCommand(factory));
+  cmd.addCommand(createLogoutCommand(factory));
+  cmd.addCommand(createStatusCommand(factory));
+  return cmd;
+}
+
+// src/cmd/file/index.ts
+import { Command as Command8 } from "commander";
+
+// src/cmd/file/get.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+
+// src/pkg/output/formatter.ts
+import Table from "cli-table3";
+function formatOutput(data, options = { format: "json" }) {
+  switch (options.format) {
+    case "json":
+      return JSON.stringify(data, null, 2);
+    case "table":
+      return formatTable(data, options.columns);
+    default:
+      return JSON.stringify(data, null, 2);
+  }
+}
+function formatTable(data, columns) {
+  if (!Array.isArray(data)) {
+    return formatKeyValueTable(data);
+  }
+  if (data.length === 0) {
+    return "No data";
+  }
+  const firstItem = data[0];
+  const headers = columns ?? Object.keys(firstItem);
+  const table = new Table({
+    head: headers,
+    style: {
+      head: ["cyan"],
+      border: ["gray"]
+    }
+  });
+  for (const item of data) {
+    const row = headers.map((col) => {
+      const value = item[col];
+      return formatValue(value);
+    });
+    table.push(row);
+  }
+  return table.toString();
+}
+function formatKeyValueTable(obj) {
+  const table = new Table({
+    style: {
+      head: ["cyan"],
+      border: ["gray"]
+    }
+  });
+  for (const [key, value] of Object.entries(obj)) {
+    table.push({ [key]: formatValue(value) });
+  }
+  return table.toString();
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+// src/cmd/file/get.ts
+function createFileGetCommand(factory) {
+  const cmd = new Command5("get").description("Get file JSON structure").argument("<key>", "File key (from Figma URL)").option("-v, --version <version>", "File version to get").option(
+    "-d, --depth <depth>",
+    "Depth of node tree to return (default: full tree)",
+    parseInt
+  ).option("-i, --ids <ids>", "Comma-separated list of node IDs to include").option("--geometry <paths>", "Include geometry data (paths)").option("-f, --format <format>", "Output format (json, table)", "json").option("-t, --token <token>", "Override authentication token").action(
+    async (fileKey, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        const client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          const overrideClient = new FigmaClient2({ token });
+          const file2 = await overrideClient.getFile(fileKey, {
+            version: options.version,
+            depth: options.depth,
+            ids: options.ids?.split(","),
+            geometry: options.geometry
+          });
+          io.out.write(
+            formatOutput(file2, { format: options.format })
+          );
+          io.out.write("\n");
+          return;
+        }
+        const file = await client.getFile(fileKey, {
+          version: options.version,
+          depth: options.depth,
+          ids: options.ids?.split(","),
+          geometry: options.geometry
+        });
+        io.out.write(
+          formatOutput(file, { format: options.format })
+        );
+        io.out.write("\n");
+      } catch (error) {
+        io.err.write(chalk5.red("Error fetching file.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk5.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/file/nodes.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+function createFileNodesCommand(factory) {
+  const cmd = new Command6("nodes").description("Get specific nodes from a file").argument("<key>", "File key (from Figma URL)").requiredOption("-i, --ids <ids>", "Comma-separated list of node IDs").option("-v, --version <version>", "File version to get").option("-d, --depth <depth>", "Depth of node tree to return", parseInt).option("--geometry <paths>", "Include geometry data (paths)").option("-f, --format <format>", "Output format (json, table)", "json").option("-t, --token <token>", "Override authentication token").action(
+    async (fileKey, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        const client = await factory.getClient();
+        const nodeIds = options.ids.split(",").map((id) => id.trim());
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          const overrideClient = new FigmaClient2({ token });
+          const nodes2 = await overrideClient.getFileNodes(fileKey, nodeIds, {
+            version: options.version,
+            depth: options.depth,
+            geometry: options.geometry
+          });
+          io.out.write(
+            formatOutput(nodes2, { format: options.format })
+          );
+          io.out.write("\n");
+          return;
+        }
+        const nodes = await client.getFileNodes(fileKey, nodeIds, {
+          version: options.version,
+          depth: options.depth,
+          geometry: options.geometry
+        });
+        io.out.write(
+          formatOutput(nodes, { format: options.format })
+        );
+        io.out.write("\n");
+      } catch (error) {
+        io.err.write(chalk6.red("Error fetching nodes.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk6.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/file/images.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+
+// src/internal/download/index.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+async function downloadFile(url, options) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(
+    () => controller.abort(),
+    options.timeoutMs ?? DEFAULT_TIMEOUT_MS2
+  );
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} ${response.statusText}`);
+    }
+    const buffer = await response.arrayBuffer();
+    const filepath = path3.join(options.outputDir, options.filename);
+    fs3.writeFileSync(filepath, Buffer.from(buffer));
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function downloadFiles(items, outputDir, options) {
+  if (!fs3.existsSync(outputDir)) {
+    fs3.mkdirSync(outputDir, { recursive: true });
+  }
+  const results = [];
+  const total = items.length;
+  let completed = 0;
+  for (const item of items) {
+    if (!item.url) {
+      results.push({
+        id: item.id,
+        name: item.name,
+        file: "",
+        status: "error",
+        error: "No URL provided"
+      });
+      completed++;
+      options?.onProgress?.(completed, total, item.name ?? item.id);
+      continue;
+    }
+    try {
+      const filepath = path3.join(outputDir, item.filename);
+      await downloadFile(item.url, {
+        outputDir,
+        filename: item.filename,
+        timeoutMs: options?.timeoutMs
+      });
+      results.push({
+        id: item.id,
+        name: item.name,
+        file: filepath,
+        status: "success"
+      });
+    } catch (err) {
+      results.push({
+        id: item.id,
+        name: item.name,
+        file: "",
+        status: "error",
+        error: err instanceof Error ? err.message : "Download failed"
+      });
+    }
+    completed++;
+    options?.onProgress?.(completed, total, item.name ?? item.id);
+  }
+  return results;
+}
+function sanitizeFilename(name) {
+  return name.replace(/[:/\\?*"<>|]/g, "-");
+}
+
+// src/cmd/file/images.ts
+function createFileImagesCommand(factory) {
+  const cmd = new Command7("images").description("Export images from a file").argument("<key>", "File key (from Figma URL)").requiredOption(
+    "-i, --ids <ids>",
+    "Comma-separated list of node IDs to export"
+  ).option("-s, --scale <scale>", "Scale factor (0.01-4)", parseFloat, 1).option("--format <format>", "Image format (jpg, png, svg, pdf)", "png").option("--svg-include-id", "Include node ID as an attribute in SVGs").option("--svg-simplify-stroke", "Simplify strokes in SVG export").option("-o, --output <dir>", "Output directory for downloaded images").option(
+    "-O, --output-format <format>",
+    "Output format (json, table)",
+    "json"
+  ).option("-t, --token <token>", "Override authentication token").action(
+    async (fileKey, options) => {
+      const { io } = factory;
+      const validFormats = ["jpg", "png", "svg", "pdf"];
+      if (!validFormats.includes(options.format)) {
+        io.err.write(
+          chalk7.red(
+            `Invalid format "${options.format}". Valid formats: ${validFormats.join(", ")}
+`
+          )
+        );
+        process.exit(1);
+      }
+      const imageFormat = options.format;
+      try {
+        const token = await factory.getToken(options.token);
+        const client = await factory.getClient();
+        const nodeIds = options.ids.split(",").map((id) => id.trim());
+        let activeClient = client;
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          activeClient = new FigmaClient2({ token });
+        }
+        const images = await activeClient.getImages(fileKey, nodeIds, {
+          scale: options.scale,
+          format: imageFormat,
+          svg_include_id: options.svgIncludeId,
+          svg_simplify_stroke: options.svgSimplifyStroke
+        });
+        if (options.output) {
+          const imageUrls = images.images || {};
+          const downloadItems = Object.entries(imageUrls).map(
+            ([nodeId, url]) => ({
+              id: nodeId,
+              url: url ?? null,
+              filename: `${sanitizeFilename(nodeId)}.${imageFormat}`
+            })
+          );
+          const results = await downloadFiles(downloadItems, options.output);
+          const downloadResults = results.map((r) => ({
+            nodeId: r.id,
+            file: r.file,
+            status: r.status === "success" ? "downloaded" : r.error ?? "error"
+          }));
+          io.out.write(
+            formatOutput(downloadResults, {
+              format: options.outputFormat
+            })
+          );
+          io.out.write("\n");
+        } else {
+          io.out.write(
+            formatOutput(images, {
+              format: options.outputFormat
+            })
+          );
+          io.out.write("\n");
+        }
+      } catch (error) {
+        io.err.write(chalk7.red("Error exporting images.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk7.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/file/index.ts
+function createFileCommand(factory) {
+  const cmd = new Command8("file").description("Work with Figma files");
+  cmd.addCommand(createFileGetCommand(factory));
+  cmd.addCommand(createFileNodesCommand(factory));
+  cmd.addCommand(createFileImagesCommand(factory));
+  return cmd;
+}
+
+// src/cmd/project/index.ts
+import { Command as Command11 } from "commander";
+
+// src/cmd/project/list.ts
+import { Command as Command9 } from "commander";
+import chalk8 from "chalk";
+function createProjectListCommand(factory) {
+  const cmd = new Command9("list").description("List team projects").requiredOption("--team <id>", "Team ID").option("-f, --format <format>", "Output format (json, table)", "json").option("-t, --token <token>", "Override authentication token").action(
+    async (options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        const projects = await client.getTeamProjects(options.team);
+        if (options.format === "table") {
+          const tableData = projects.projects.map((p) => ({
+            id: p.id,
+            name: p.name
+          }));
+          io.out.write(
+            formatOutput(tableData, {
+              format: "table",
+              columns: ["id", "name"]
+            })
+          );
+        } else {
+          io.out.write(formatOutput(projects, { format: "json" }));
+        }
+        io.out.write("\n");
+      } catch (error) {
+        io.err.write(chalk8.red("Error fetching projects.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk8.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/project/files.ts
+import { Command as Command10 } from "commander";
+import chalk9 from "chalk";
+function createProjectFilesCommand(factory) {
+  const cmd = new Command10("files").description("List files in a project").argument("<project-id>", "Project ID").option("--branch-data", "Include branch metadata").option("-f, --format <format>", "Output format (json, table)", "json").option("-t, --token <token>", "Override authentication token").action(
+    async (projectId, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        const files = await client.getProjectFiles(projectId, {
+          branch_data: options.branchData
+        });
+        if (options.format === "table") {
+          const tableData = files.files.map((f) => ({
+            key: f.key,
+            name: f.name,
+            last_modified: f.last_modified
+          }));
+          io.out.write(
+            formatOutput(tableData, {
+              format: "table",
+              columns: ["key", "name", "last_modified"]
+            })
+          );
+        } else {
+          io.out.write(formatOutput(files, { format: "json" }));
+        }
+        io.out.write("\n");
+      } catch (error) {
+        io.err.write(chalk9.red("Error fetching project files.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk9.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/project/index.ts
+function createProjectCommand(factory) {
+  const cmd = new Command11("project").description("Work with Figma projects");
+  cmd.addCommand(createProjectListCommand(factory));
+  cmd.addCommand(createProjectFilesCommand(factory));
+  return cmd;
+}
+
+// src/cmd/component/index.ts
+import { Command as Command14 } from "commander";
+
+// src/cmd/component/list.ts
+import { Command as Command12 } from "commander";
+import chalk10 from "chalk";
+function createComponentListCommand(factory) {
+  const cmd = new Command12("list").description("List components (from team or file)").option("--team <id>", "Team ID to list components from").option("--file <key>", "File key to list components from").option("--page-size <size>", "Number of results per page", parseInt).option("-f, --format <format>", "Output format (json, table)", "json").option("-t, --token <token>", "Override authentication token").action(
+    async (options) => {
+      const { io } = factory;
+      if (!options.team && !options.file) {
+        io.err.write(
+          chalk10.red("Error: Either --team or --file must be specified.\n")
+        );
+        process.exit(1);
+      }
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        if (options.team) {
+          const components = await client.getTeamComponents(options.team, {
+            page_size: options.pageSize
+          });
+          if (options.format === "table") {
+            const tableData = components.meta?.components?.map((c) => ({
+              key: c.key,
+              name: c.name,
+              description: c.description || ""
+            })) || [];
+            io.out.write(
+              formatOutput(tableData, {
+                format: "table",
+                columns: ["key", "name", "description"]
+              })
+            );
+          } else {
+            io.out.write(formatOutput(components, { format: "json" }));
+          }
+        } else if (options.file) {
+          const components = await client.getFileComponents(options.file);
+          if (options.format === "table") {
+            const tableData = components.meta?.components?.map((c) => ({
+              key: c.key,
+              name: c.name,
+              description: c.description || ""
+            })) || [];
+            io.out.write(
+              formatOutput(tableData, {
+                format: "table",
+                columns: ["key", "name", "description"]
+              })
+            );
+          } else {
+            io.out.write(formatOutput(components, { format: "json" }));
+          }
+        }
+        io.out.write("\n");
+      } catch (error) {
+        io.err.write(chalk10.red("Error fetching components.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk10.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/component/get.ts
+import { Command as Command13 } from "commander";
+import chalk11 from "chalk";
+function createComponentGetCommand(factory) {
+  const cmd = new Command13("get").description("Get component details").argument("<key>", "Component key").option("-f, --format <format>", "Output format (json, table)", "json").option("-t, --token <token>", "Override authentication token").action(
+    async (componentKey, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        const component = await client.getComponent(componentKey);
+        io.out.write(
+          formatOutput(component, {
+            format: options.format
+          })
+        );
+        io.out.write("\n");
+      } catch (error) {
+        io.err.write(chalk11.red("Error fetching component.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk11.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/component/index.ts
+function createComponentCommand(factory) {
+  const cmd = new Command14("component").description(
+    "Work with Figma components"
+  );
+  cmd.addCommand(createComponentListCommand(factory));
+  cmd.addCommand(createComponentGetCommand(factory));
+  return cmd;
+}
+
+// src/cmd/style/index.ts
+import { Command as Command17 } from "commander";
+
+// src/cmd/style/list.ts
+import { Command as Command15 } from "commander";
+import chalk12 from "chalk";
+function createStyleListCommand(factory) {
+  const cmd = new Command15("list").description("List styles (from team or file)").option("--team <id>", "Team ID to list styles from").option("--file <key>", "File key to list styles from").option("--page-size <size>", "Number of results per page", parseInt).option("-f, --format <format>", "Output format (json, table)", "json").option("-t, --token <token>", "Override authentication token").action(
+    async (options) => {
+      const { io } = factory;
+      if (!options.team && !options.file) {
+        io.err.write(
+          chalk12.red("Error: Either --team or --file must be specified.\n")
+        );
+        process.exit(1);
+      }
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        if (options.team) {
+          const styles = await client.getTeamStyles(options.team, {
+            page_size: options.pageSize
+          });
+          if (options.format === "table") {
+            const tableData = styles.meta?.styles?.map((s) => ({
+              key: s.key,
+              name: s.name,
+              style_type: s.style_type,
+              description: s.description || ""
+            })) || [];
+            io.out.write(
+              formatOutput(tableData, {
+                format: "table",
+                columns: ["key", "name", "style_type", "description"]
+              })
+            );
+          } else {
+            io.out.write(formatOutput(styles, { format: "json" }));
+          }
+        } else if (options.file) {
+          const styles = await client.getFileStyles(options.file);
+          if (options.format === "table") {
+            const tableData = styles.meta?.styles?.map((s) => ({
+              key: s.key,
+              name: s.name,
+              style_type: s.style_type,
+              description: s.description || ""
+            })) || [];
+            io.out.write(
+              formatOutput(tableData, {
+                format: "table",
+                columns: ["key", "name", "style_type", "description"]
+              })
+            );
+          } else {
+            io.out.write(formatOutput(styles, { format: "json" }));
+          }
+        }
+        io.out.write("\n");
+      } catch (error) {
+        io.err.write(chalk12.red("Error fetching styles.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk12.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/style/get.ts
+import { Command as Command16 } from "commander";
+import chalk13 from "chalk";
+function createStyleGetCommand(factory) {
+  const cmd = new Command16("get").description("Get style details").argument("<key>", "Style key").option("-f, --format <format>", "Output format (json, table)", "json").option("-t, --token <token>", "Override authentication token").action(
+    async (styleKey, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        const style = await client.getStyle(styleKey);
+        io.out.write(
+          formatOutput(style, {
+            format: options.format
+          })
+        );
+        io.out.write("\n");
+      } catch (error) {
+        io.err.write(chalk13.red("Error fetching style.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk13.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/style/index.ts
+function createStyleCommand(factory) {
+  const cmd = new Command17("style").description("Work with Figma styles");
+  cmd.addCommand(createStyleListCommand(factory));
+  cmd.addCommand(createStyleGetCommand(factory));
+  return cmd;
+}
+
+// src/cmd/variable/index.ts
+import { Command as Command20 } from "commander";
+
+// src/cmd/variable/list.ts
+import { Command as Command18 } from "commander";
+import chalk14 from "chalk";
+function createVariableListCommand(factory) {
+  const cmd = new Command18("list").description("List variables from a file (Enterprise)").argument("<file-key>", "File key").option("--published", "List published variables only").option("-f, --format <format>", "Output format (json, table)", "json").option("-t, --token <token>", "Override authentication token").action(
+    async (fileKey, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        const variables = options.published ? await client.getPublishedVariables(fileKey) : await client.getLocalVariables(fileKey);
+        if (options.format === "table") {
+          const variableMap = "meta" in variables ? variables.meta?.variables : {};
+          const tableData = Object.entries(variableMap || {}).map(
+            ([id, v]) => ({
+              id,
+              name: v.name || "",
+              resolvedType: v.resolvedType || ""
+            })
+          );
+          io.out.write(
+            formatOutput(tableData, {
+              format: "table",
+              columns: ["id", "name", "resolvedType"]
+            })
+          );
+        } else {
+          io.out.write(formatOutput(variables, { format: "json" }));
+        }
+        io.out.write("\n");
+      } catch (error) {
+        io.err.write(chalk14.red("Error fetching variables.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk14.dim(`${error.message}
+`));
+        }
+        io.err.write(
+          chalk14.dim("\nNote: Variables API requires Figma Enterprise plan.\n")
+        );
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/variable/export.ts
+import { Command as Command19 } from "commander";
+import chalk15 from "chalk";
+import * as fs4 from "fs";
+function createVariableExportCommand(factory) {
+  const cmd = new Command19("export").description("Export variables as design tokens (Enterprise)").argument("<file-key>", "File key").option(
+    "--format <format>",
+    "Output format (json, css, scss, style-dictionary)",
+    "json"
+  ).option("--mode <mode>", "Specific mode to export").option("-o, --output <file>", "Output file path").option("-t, --token <token>", "Override authentication token").action(
+    async (fileKey, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        const response = await client.getLocalVariables(fileKey);
+        const meta = response.meta;
+        if (!meta) {
+          io.err.write(chalk15.red("No variables found in file.\n"));
+          process.exit(1);
+        }
+        const variables = meta.variables;
+        const collections = meta.variableCollections;
+        let targetModeId;
+        if (options.mode) {
+          for (const collection of Object.values(collections)) {
+            const mode = collection.modes.find(
+              (m) => m.name.toLowerCase() === options.mode?.toLowerCase()
+            );
+            if (mode) {
+              targetModeId = mode.modeId;
+              break;
+            }
+          }
+          if (!targetModeId) {
+            io.err.write(chalk15.red(`Mode "${options.mode}" not found.
+`));
+            const allModes = Object.values(collections).flatMap(
+              (c) => c.modes.map((m) => m.name)
+            );
+            io.err.write(
+              chalk15.dim(`Available modes: ${allModes.join(", ")}
+`)
+            );
+            process.exit(1);
+          }
+        }
+        let output;
+        switch (options.format) {
+          case "css":
+            output = exportToCss(variables, collections, targetModeId);
+            break;
+          case "scss":
+            output = exportToScss(variables, collections, targetModeId);
+            break;
+          case "style-dictionary":
+            output = exportToStyleDictionary(
+              variables,
+              collections,
+              targetModeId
+            );
+            break;
+          default:
+            output = JSON.stringify({ variables, collections }, null, 2);
+        }
+        if (options.output) {
+          fs4.writeFileSync(options.output, output);
+          io.out.write(chalk15.green(`\u2713 Exported to ${options.output}
+`));
+        } else {
+          io.out.write(output);
+          io.out.write("\n");
+        }
+      } catch (error) {
+        io.err.write(chalk15.red("Error exporting variables.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk15.dim(`${error.message}
+`));
+        }
+        io.err.write(
+          chalk15.dim("\nNote: Variables API requires Figma Enterprise plan.\n")
+        );
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+function toKebabCase(str) {
+  return str.replace(/\s+/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").toLowerCase();
+}
+function resolveValue(value, variables, _modeId) {
+  if (typeof value === "object" && value !== null) {
+    if ("r" in value && "g" in value && "b" in value) {
+      const rgba = value;
+      const r = Math.round(rgba.r * 255);
+      const g = Math.round(rgba.g * 255);
+      const b = Math.round(rgba.b * 255);
+      const a = rgba.a ?? 1;
+      if (a === 1) {
+        return `rgb(${r}, ${g}, ${b})`;
+      }
+      return `rgba(${r}, ${g}, ${b}, ${a})`;
+    }
+    if ("type" in value && value.type === "VARIABLE_ALIAS") {
+      const aliasId = value.id;
+      const aliasVar = variables[aliasId];
+      if (aliasVar) {
+        return `var(--${toKebabCase(aliasVar.name)})`;
+      }
+    }
+  }
+  if (typeof value === "number") {
+    return `${value}px`;
+  }
+  return String(value);
+}
+function exportToCss(variables, collections, modeId) {
+  const lines = [":root {"];
+  for (const variable of Object.values(variables)) {
+    const collection = collections[variable.variableCollectionId];
+    const targetMode = modeId || collection?.defaultModeId;
+    const value = variable.valuesByMode[targetMode];
+    if (value !== void 0) {
+      const cssName = toKebabCase(variable.name);
+      const cssValue = resolveValue(value, variables, targetMode);
+      lines.push(`  --${cssName}: ${cssValue};`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function exportToScss(variables, collections, modeId) {
+  const lines = [];
+  for (const variable of Object.values(variables)) {
+    const collection = collections[variable.variableCollectionId];
+    const targetMode = modeId || collection?.defaultModeId;
+    const value = variable.valuesByMode[targetMode];
+    if (value !== void 0) {
+      const scssName = toKebabCase(variable.name);
+      const scssValue = resolveValue(value, variables, targetMode).replace(
+        /var\(--([^)]+)\)/g,
+        "$$$1"
+      );
+      lines.push(`$${scssName}: ${scssValue};`);
+    }
+  }
+  return lines.join("\n");
+}
+function exportToStyleDictionary(variables, collections, modeId) {
+  const tokens = {};
+  for (const variable of Object.values(variables)) {
+    const collection = collections[variable.variableCollectionId];
+    const targetMode = modeId || collection?.defaultModeId;
+    const value = variable.valuesByMode[targetMode];
+    if (value === void 0) continue;
+    const pathParts = variable.name.split("/").map((p) => p.trim());
+    let current = tokens;
+    for (let i = 0; i < pathParts.length - 1; i++) {
+      const part = pathParts[i];
+      if (!current[part]) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    const finalKey = pathParts[pathParts.length - 1];
+    current[finalKey] = {
+      value: resolveValueForStyleDictionary(value, variables, targetMode),
+      type: mapTypeToStyleDictionary(variable.resolvedType),
+      description: variable.description || void 0
+    };
+  }
+  return JSON.stringify(tokens, null, 2);
+}
+function resolveValueForStyleDictionary(value, variables, _modeId) {
+  if (typeof value === "object" && value !== null) {
+    if ("r" in value && "g" in value && "b" in value) {
+      const rgba = value;
+      const r = Math.round(rgba.r * 255).toString(16).padStart(2, "0");
+      const g = Math.round(rgba.g * 255).toString(16).padStart(2, "0");
+      const b = Math.round(rgba.b * 255).toString(16).padStart(2, "0");
+      const a = rgba.a ?? 1;
+      if (a === 1) {
+        return `#${r}${g}${b}`;
+      }
+      const aHex = Math.round(a * 255).toString(16).padStart(2, "0");
+      return `#${r}${g}${b}${aHex}`;
+    }
+    if ("type" in value && value.type === "VARIABLE_ALIAS") {
+      const aliasId = value.id;
+      const aliasVar = variables[aliasId];
+      if (aliasVar) {
+        return `{${aliasVar.name.replace(/\//g, ".")}}`;
+      }
+    }
+  }
+  return value;
+}
+function mapTypeToStyleDictionary(figmaType) {
+  switch (figmaType) {
+    case "COLOR":
+      return "color";
+    case "FLOAT":
+      return "dimension";
+    case "STRING":
+      return "string";
+    case "BOOLEAN":
+      return "boolean";
+    default:
+      return figmaType.toLowerCase();
+  }
+}
+
+// src/cmd/variable/index.ts
+function createVariableCommand(factory) {
+  const cmd = new Command20("variable").description(
+    "Work with Figma variables (Enterprise)"
+  );
+  cmd.addCommand(createVariableListCommand(factory));
+  cmd.addCommand(createVariableExportCommand(factory));
+  return cmd;
+}
+
+// src/cmd/export/index.ts
+import { Command as Command24 } from "commander";
+
+// src/cmd/export/tokens.ts
+import { Command as Command21 } from "commander";
+import chalk16 from "chalk";
+import * as fs5 from "fs";
+
+// src/internal/transform/tokens.ts
+function figmaColorToCss(color) {
+  const r = Math.round(color.r * 255);
+  const g = Math.round(color.g * 255);
+  const b = Math.round(color.b * 255);
+  const a = color.a ?? 1;
+  if (a === 1) {
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  }
+  return `rgba(${r}, ${g}, ${b}, ${a.toFixed(2)})`;
+}
+function toKebabCase2(str) {
+  return str.replace(/\s+/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").toLowerCase();
+}
+function extractStylesFromFile(file, styleMetadata) {
+  const tokens = {
+    colors: {},
+    typography: {},
+    spacing: {},
+    effects: {}
+  };
+  const styleNodeMap = /* @__PURE__ */ new Map();
+  for (const style of styleMetadata) {
+    const nodeId = style.node_id;
+    if (nodeId) {
+      styleNodeMap.set(nodeId, style);
+    }
+  }
+  function traverseNode(node) {
+    const nodeWithStyles = node;
+    if ("styles" in nodeWithStyles && nodeWithStyles.styles) {
+      const styles = nodeWithStyles.styles;
+      if (styles.fill && "fills" in nodeWithStyles) {
+        const fills = nodeWithStyles.fills;
+        if (fills && fills.length > 0 && fills[0].type === "SOLID") {
+          const fill = fills[0];
+          if (fill.color) {
+            const styleInfo = styleNodeMap.get(node.id);
+            const styleName = styleInfo?.name || node.name;
+            const tokenName = toKebabCase2(styleName);
+            tokens.colors[tokenName] = {
+              name: styleName,
+              type: "color",
+              value: figmaColorToCss(fill.color),
+              description: styleInfo?.description
+            };
+          }
+        }
+      }
+      if (styles.text && "style" in nodeWithStyles && nodeWithStyles.style) {
+        const textStyle = nodeWithStyles.style;
+        const styleInfo = styleNodeMap.get(node.id);
+        const styleName = styleInfo?.name || node.name;
+        const tokenName = toKebabCase2(styleName);
+        tokens.typography[tokenName] = {
+          name: styleName,
+          type: "typography",
+          value: {
+            fontFamily: textStyle.fontFamily || "sans-serif",
+            fontSize: `${textStyle.fontSize || 16}px`,
+            fontWeight: textStyle.fontWeight || 400,
+            lineHeight: textStyle.lineHeightPx !== void 0 ? `${textStyle.lineHeightPx}px` : "normal",
+            letterSpacing: textStyle.letterSpacing !== void 0 ? `${textStyle.letterSpacing}px` : "normal"
+          },
+          description: styleInfo?.description
+        };
+      }
+    }
+    if ("children" in node) {
+      const parent = node;
+      for (const child of parent.children || []) {
+        traverseNode(child);
+      }
+    }
+  }
+  if (file.document) {
+    traverseNode(file.document);
+  }
+  return tokens;
+}
+function tokensToCss(tokens) {
+  const lines = [":root {"];
+  if (tokens.colors) {
+    lines.push("  /* Colors */");
+    for (const [name, token] of Object.entries(tokens.colors)) {
+      lines.push(`  --color-${name}: ${token.value};`);
+    }
+    lines.push("");
+  }
+  if (tokens.typography) {
+    lines.push("  /* Typography */");
+    for (const [name, token] of Object.entries(tokens.typography)) {
+      const value = token.value;
+      lines.push(`  --font-${name}-family: ${value.fontFamily};`);
+      lines.push(`  --font-${name}-size: ${value.fontSize};`);
+      lines.push(`  --font-${name}-weight: ${value.fontWeight};`);
+      lines.push(`  --font-${name}-line-height: ${value.lineHeight};`);
+      lines.push(`  --font-${name}-letter-spacing: ${value.letterSpacing};`);
+    }
+    lines.push("");
+  }
+  if (tokens.spacing) {
+    lines.push("  /* Spacing */");
+    for (const [name, token] of Object.entries(tokens.spacing)) {
+      lines.push(`  --spacing-${name}: ${token.value};`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function tokensToScss(tokens) {
+  const lines = [];
+  if (tokens.colors) {
+    lines.push("// Colors");
+    for (const [name, token] of Object.entries(tokens.colors)) {
+      lines.push(`$color-${name}: ${token.value};`);
+    }
+    lines.push("");
+  }
+  if (tokens.typography) {
+    lines.push("// Typography");
+    for (const [name, token] of Object.entries(tokens.typography)) {
+      const value = token.value;
+      lines.push(`$font-${name}-family: ${value.fontFamily};`);
+      lines.push(`$font-${name}-size: ${value.fontSize};`);
+      lines.push(`$font-${name}-weight: ${value.fontWeight};`);
+      lines.push(`$font-${name}-line-height: ${value.lineHeight};`);
+      lines.push(`$font-${name}-letter-spacing: ${value.letterSpacing};`);
+    }
+    lines.push("");
+  }
+  if (tokens.spacing) {
+    lines.push("// Spacing");
+    for (const [name, token] of Object.entries(tokens.spacing)) {
+      lines.push(`$spacing-${name}: ${token.value};`);
+    }
+  }
+  return lines.join("\n");
+}
+function tokensToStyleDictionary(tokens) {
+  const output = {};
+  if (tokens.colors && Object.keys(tokens.colors).length > 0) {
+    output.color = {};
+    for (const [name, token] of Object.entries(tokens.colors)) {
+      output.color[name] = {
+        value: token.value,
+        type: "color",
+        description: token.description
+      };
+    }
+  }
+  if (tokens.typography && Object.keys(tokens.typography).length > 0) {
+    output.typography = {};
+    for (const [name, token] of Object.entries(tokens.typography)) {
+      output.typography[name] = {
+        value: token.value,
+        type: "typography",
+        description: token.description
+      };
+    }
+  }
+  if (tokens.spacing && Object.keys(tokens.spacing).length > 0) {
+    output.spacing = {};
+    for (const [name, token] of Object.entries(tokens.spacing)) {
+      output.spacing[name] = {
+        value: token.value,
+        type: "dimension",
+        description: token.description
+      };
+    }
+  }
+  return JSON.stringify(output, null, 2);
+}
+function tokensToTailwind(tokens) {
+  const config = {
+    theme: {
+      extend: {}
+    }
+  };
+  if (tokens.colors && Object.keys(tokens.colors).length > 0) {
+    config.theme.extend.colors = {};
+    for (const [name, token] of Object.entries(tokens.colors)) {
+      config.theme.extend.colors[name] = token.value;
+    }
+  }
+  if (tokens.typography && Object.keys(tokens.typography).length > 0) {
+    config.theme.extend.fontFamily = {};
+    config.theme.extend.fontSize = {};
+    for (const [name, token] of Object.entries(tokens.typography)) {
+      const value = token.value;
+      config.theme.extend.fontFamily[name] = [value.fontFamily];
+      config.theme.extend.fontSize[name] = value.fontSize;
+    }
+  }
+  if (tokens.spacing && Object.keys(tokens.spacing).length > 0) {
+    config.theme.extend.spacing = {};
+    for (const [name, token] of Object.entries(tokens.spacing)) {
+      config.theme.extend.spacing[name] = token.value;
+    }
+  }
+  return `/** @type {import('tailwindcss').Config} */
+module.exports = ${JSON.stringify(config, null, 2)};`;
+}
+
+// src/cmd/export/tokens.ts
+function createExportTokensCommand(factory) {
+  const cmd = new Command21("tokens").description("Export design tokens from a Figma file").argument("<file-key>", "File key").option(
+    "--format <format>",
+    "Output format (json, css, scss, style-dictionary, tailwind)",
+    "json"
+  ).option("-o, --output <file>", "Output file path").option("-t, --token <token>", "Override authentication token").action(
+    async (fileKey, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        io.err.write(chalk16.dim("Fetching file styles...\n"));
+        const stylesResponse = await client.getFileStyles(fileKey);
+        const styles = stylesResponse.meta?.styles || [];
+        if (styles.length === 0) {
+          io.err.write(
+            chalk16.yellow("No styles found in file. Trying variables...\n")
+          );
+          try {
+            const variablesResponse = await client.getLocalVariables(fileKey);
+            if (variablesResponse.meta?.variables) {
+              io.err.write(
+                chalk16.dim(
+                  "Found variables. Use 'figma variable export' for variable-based tokens.\n"
+                )
+              );
+            }
+          } catch {
+          }
+          process.exit(0);
+        }
+        io.err.write(chalk16.dim("Extracting token values...\n"));
+        const file = await client.getFile(fileKey);
+        const tokens = extractStylesFromFile(file, styles);
+        let output;
+        switch (options.format) {
+          case "css":
+            output = tokensToCss(tokens);
+            break;
+          case "scss":
+            output = tokensToScss(tokens);
+            break;
+          case "style-dictionary":
+            output = tokensToStyleDictionary(tokens);
+            break;
+          case "tailwind":
+            output = tokensToTailwind(tokens);
+            break;
+          default:
+            output = JSON.stringify(tokens, null, 2);
+        }
+        if (options.output) {
+          fs5.writeFileSync(options.output, output);
+          io.out.write(chalk16.green(`\u2713 Exported to ${options.output}
+`));
+        } else {
+          io.out.write(output);
+          io.out.write("\n");
+        }
+      } catch (error) {
+        io.err.write(chalk16.red("Error exporting tokens.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk16.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/export/icons.ts
+import { Command as Command22 } from "commander";
+import chalk17 from "chalk";
+function createExportIconsCommand(factory) {
+  const cmd = new Command22("icons").description("Export icons from a Figma file").argument("<file-key>", "File key").option(
+    "--frame <name>",
+    "Name of frame/page containing icons (searches all pages if not specified)"
+  ).option("--format <format>", "Export format (svg, png)", "svg").option("-s, --scale <scale>", "Scale factor for PNG export", parseFloat, 1).option("-o, --output <dir>", "Output directory", "./icons").option("--prefix <prefix>", "Prefix for icon filenames", "icon-").option("-t, --token <token>", "Override authentication token").action(
+    async (fileKey, options) => {
+      const { io } = factory;
+      const validFormats = ["svg", "png"];
+      if (!validFormats.includes(options.format)) {
+        io.err.write(
+          chalk17.red(
+            `Invalid format "${options.format}". Valid formats: ${validFormats.join(", ")}
+`
+          )
+        );
+        process.exit(1);
+      }
+      const imageFormat = options.format;
+      try {
+        let findIcons2 = function(node, inTargetFrame) {
+          if (options.frame) {
+            if (node.name.toLowerCase() === options.frame.toLowerCase() && (node.type === "FRAME" || node.type === "CANVAS" || node.type === "COMPONENT")) {
+              inTargetFrame = true;
+            }
+          } else {
+            inTargetFrame = true;
+          }
+          if (inTargetFrame) {
+            if (node.type === "COMPONENT" || node.type === "INSTANCE" || node.type === "FRAME" && !("children" in node && hasDeepChildren2(node))) {
+              iconNodes.push({ id: node.id, name: node.name });
+            }
+          }
+          if ("children" in node) {
+            const parent = node;
+            for (const child of parent.children || []) {
+              findIcons2(child, inTargetFrame);
+            }
+          }
+        }, hasDeepChildren2 = function(node) {
+          if (!("children" in node)) return false;
+          const parent = node;
+          return (parent.children || []).some(
+            (child) => child.type === "FRAME" || child.type === "COMPONENT" || child.type === "GROUP"
+          );
+        };
+        var findIcons = findIcons2, hasDeepChildren = hasDeepChildren2;
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        io.err.write(chalk17.dim("Fetching file structure...\n"));
+        const file = await client.getFile(fileKey, { depth: 2 });
+        const iconNodes = [];
+        if (file.document) {
+          findIcons2(file.document, false);
+        }
+        if (iconNodes.length === 0) {
+          io.err.write(chalk17.yellow("No icons found in file.\n"));
+          if (options.frame) {
+            io.err.write(
+              chalk17.dim(`Looking for frame: "${options.frame}"
+`)
+            );
+          }
+          process.exit(0);
+        }
+        io.err.write(
+          chalk17.dim(`Found ${iconNodes.length} icons. Exporting...
+`)
+        );
+        const nodeIds = iconNodes.map((n) => n.id);
+        const imagesResponse = await client.getImages(fileKey, nodeIds, {
+          format: imageFormat,
+          scale: options.scale,
+          svg_include_id: false,
+          svg_simplify_stroke: true
+        });
+        const imageUrls = imagesResponse.images || {};
+        const downloadItems = iconNodes.map((node) => ({
+          id: node.id,
+          name: node.name,
+          url: imageUrls[node.id] ?? null,
+          filename: `${options.prefix}${toKebabCase2(node.name)}.${imageFormat}`
+        }));
+        const results = await downloadFiles(downloadItems, options.output);
+        const successCount = results.filter(
+          (r) => r.status === "success"
+        ).length;
+        const failures = results.filter((r) => r.status === "error");
+        for (const failure of failures) {
+          io.err.write(
+            chalk17.yellow(
+              `Warning: Failed to download "${failure.name ?? failure.id}": ${failure.error}
+`
+            )
+          );
+        }
+        io.err.write(
+          chalk17.green(`Exported ${successCount} icons to ${options.output}
+`)
+        );
+        if (failures.length > 0) {
+          io.err.write(chalk17.yellow(`${failures.length} icons failed
+`));
+          process.exit(1);
+        }
+      } catch (error) {
+        io.err.write(chalk17.red("Error exporting icons.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk17.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/export/theme.ts
+import { Command as Command23 } from "commander";
+import chalk18 from "chalk";
+import * as fs6 from "fs";
+import * as path4 from "path";
+function createExportThemeCommand(factory) {
+  const cmd = new Command23("theme").description("Export complete theme package from a Figma file").argument("<file-key>", "File key").option("-o, --output <dir>", "Output directory", "./theme").option(
+    "--formats <formats>",
+    "Comma-separated list of formats (json, css, scss, style-dictionary, tailwind)",
+    "json,css"
+  ).option("-t, --token <token>", "Override authentication token").action(
+    async (fileKey, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        let client = await factory.getClient();
+        if (options.token) {
+          const { FigmaClient: FigmaClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+          client = new FigmaClient2({ token });
+        }
+        io.err.write(chalk18.dim("Fetching file styles...\n"));
+        const stylesResponse = await client.getFileStyles(fileKey);
+        const styles = stylesResponse.meta?.styles || [];
+        io.err.write(chalk18.dim("Extracting token values...\n"));
+        const file = await client.getFile(fileKey);
+        const tokens = extractStylesFromFile(file, styles);
+        if (!fs6.existsSync(options.output)) {
+          fs6.mkdirSync(options.output, { recursive: true });
+        }
+        const formats = options.formats.split(",").map((f) => f.trim());
+        const outputs = [];
+        for (const format of formats) {
+          let output;
+          let filename;
+          switch (format) {
+            case "css":
+              output = tokensToCss(tokens);
+              filename = "tokens.css";
+              break;
+            case "scss":
+              output = tokensToScss(tokens);
+              filename = "_tokens.scss";
+              break;
+            case "style-dictionary":
+              output = tokensToStyleDictionary(tokens);
+              filename = "tokens.style-dictionary.json";
+              break;
+            case "tailwind":
+              output = tokensToTailwind(tokens);
+              filename = "tailwind.tokens.js";
+              break;
+            case "json":
+            default:
+              output = JSON.stringify(tokens, null, 2);
+              filename = "tokens.json";
+          }
+          const filepath = path4.join(options.output, filename);
+          fs6.writeFileSync(filepath, output);
+          outputs.push(filename);
+        }
+        const metadata = {
+          name: file.name,
+          lastModified: file.lastModified,
+          version: file.version,
+          exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          formats
+        };
+        fs6.writeFileSync(
+          path4.join(options.output, "metadata.json"),
+          JSON.stringify(metadata, null, 2)
+        );
+        io.out.write(chalk18.green(`\u2713 Theme exported to ${options.output}
+`));
+        io.out.write(chalk18.dim("  Files:\n"));
+        for (const filename of outputs) {
+          io.out.write(chalk18.dim(`    - ${filename}
+`));
+        }
+        io.out.write(chalk18.dim("    - metadata.json\n"));
+      } catch (error) {
+        io.err.write(chalk18.red("Error exporting theme.\n"));
+        if (error instanceof Error) {
+          io.err.write(chalk18.dim(`${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/cmd/export/index.ts
+function createExportCommand(factory) {
+  const cmd = new Command24("export").description(
+    "Design-to-code export commands"
+  );
+  cmd.addCommand(createExportTokensCommand(factory));
+  cmd.addCommand(createExportIconsCommand(factory));
+  cmd.addCommand(createExportThemeCommand(factory));
+  return cmd;
+}
+
+// src/cmd/api/index.ts
+init_client();
+import { Command as Command25 } from "commander";
+import chalk19 from "chalk";
+function createApiCommand(factory) {
+  const cmd = new Command25("api").description("Make direct API requests to Figma").argument("<path>", "API path (e.g., /v1/files/:key)").option("-X, --method <method>", "HTTP method", "GET").option("-d, --data <json>", "Request body as JSON").option("-q, --query <params>", "Query parameters (key=value,key2=value2)").option("-t, --token <token>", "Override authentication token").option("--raw", "Output raw response without formatting").action(
+    async (apiPath, options) => {
+      const { io } = factory;
+      try {
+        const token = await factory.getToken(options.token);
+        const client = new FigmaClient({
+          token,
+          baseUrl: "https://api.figma.com"
+        });
+        let params;
+        if (options.query) {
+          params = {};
+          const pairs = options.query.split(",");
+          for (const pair of pairs) {
+            const [key, value] = pair.split("=");
+            if (key && value !== void 0) {
+              params[key.trim()] = value.trim();
+            }
+          }
+        }
+        let body;
+        if (options.data) {
+          try {
+            body = JSON.parse(options.data);
+          } catch {
+            io.err.write(chalk19.red("Error: Invalid JSON in --data\n"));
+            process.exit(1);
+          }
+        }
+        const response = await client.api(options.method, apiPath, {
+          params,
+          body
+        });
+        if (options.raw) {
+          io.out.write(JSON.stringify(response));
+        } else {
+          io.out.write(JSON.stringify(response, null, 2));
+        }
+        io.out.write("\n");
+      } catch (error) {
+        if (error instanceof FigmaApiError) {
+          io.err.write(
+            chalk19.red(`API Error: ${error.status} ${error.statusText}
+`)
+          );
+          if (error.body) {
+            io.err.write(chalk19.dim(JSON.stringify(error.body, null, 2)));
+            io.err.write("\n");
+          }
+        } else if (error instanceof Error) {
+          io.err.write(chalk19.red(`Error: ${error.message}
+`));
+        }
+        process.exit(1);
+      }
+    }
+  );
+  cmd.addHelpText(
+    "after",
+    `
+Examples:
+  $ figma api /v1/me
+  $ figma api /v1/files/abc123
+  $ figma api /v1/teams/12345/projects
+  $ figma api /v1/files/abc123/comments -X POST -d '{"message":"Hello"}'
+  $ figma api /v1/files/abc123/images -q "ids=1:2,format=svg"
+`
+  );
+  return cmd;
+}
+
+// src/cmd/root.ts
+function createRootCommand(factory) {
+  const program = new Command26();
+  program.name("figma").description("CLI for the Figma API").version("1.0.0").configureHelp({
+    sortSubcommands: true,
+    sortOptions: true
+  });
+  program.addCommand(createAuthCommand(factory));
+  program.addCommand(createFileCommand(factory));
+  program.addCommand(createProjectCommand(factory));
+  program.addCommand(createComponentCommand(factory));
+  program.addCommand(createStyleCommand(factory));
+  program.addCommand(createVariableCommand(factory));
+  program.addCommand(createExportCommand(factory));
+  program.addCommand(createApiCommand(factory));
+  return program;
+}
+
+// src/main.ts
+async function main() {
+  const factory = createFactory();
+  const program = createRootCommand(factory);
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=main.js.map