@animaapp/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,1167 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/create.ts
+import { Command } from "commander";
+
+// src/auth/store.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".config", "anima");
+var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+function readCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) return null;
+    const content = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed.token) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeCredentials(credentials) {
+  const existing = readCredentials() ?? {};
+  const merged = { ...existing, ...credentials };
+  for (const key of Object.keys(merged)) {
+    if (merged[key] === void 0) delete merged[key];
+  }
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(
+    CREDENTIALS_FILE,
+    JSON.stringify(merged, null, 2) + "\n",
+    { mode: 384 }
+  );
+}
+function deleteCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+      fs.unlinkSync(CREDENTIALS_FILE);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function getCredentialsPath() {
+  return CREDENTIALS_FILE;
+}
+function extractTeamIdFromJWT(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return void 0;
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    return payload.defaultTeamId ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/api/errors.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  API_ERROR: 1,
+  AUTH_ERROR: 2,
+  VALIDATION_ERROR: 3,
+  TIMEOUT: 4
+};
+var CliError = class extends Error {
+  code;
+  exitCode;
+  detail;
+  constructor(code, message, exitCode, detail) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.exitCode = exitCode;
+    this.detail = detail;
+  }
+};
+function authError(message) {
+  return new CliError("AUTH_REQUIRED", message, EXIT_CODES.AUTH_ERROR);
+}
+function validationError(message, detail) {
+  return new CliError(
+    "VALIDATION_ERROR",
+    message,
+    EXIT_CODES.VALIDATION_ERROR,
+    detail
+  );
+}
+function apiError(message, detail) {
+  return new CliError("API_ERROR", message, EXIT_CODES.API_ERROR, detail);
+}
+function streamError(message) {
+  return new CliError("STREAM_ERROR", message, EXIT_CODES.API_ERROR);
+}
+function timeoutError() {
+  return new CliError(
+    "TIMEOUT",
+    "Request timed out. Generation can take 3-7 minutes. Try increasing --timeout.",
+    EXIT_CODES.TIMEOUT
+  );
+}
+
+// src/auth/token.ts
+function resolveAuth() {
+  const creds = readCredentials();
+  const envToken = process.env.ANIMA_API_TOKEN;
+  if (envToken) {
+    return {
+      token: envToken,
+      teamId: process.env.ANIMA_TEAM_ID,
+      figmaToken: process.env.FIGMA_TOKEN || creds?.figmaToken,
+      source: "env"
+    };
+  }
+  if (creds) {
+    return {
+      token: creds.token,
+      teamId: creds.teamId,
+      figmaToken: process.env.FIGMA_TOKEN || creds.figmaToken,
+      source: "file"
+    };
+  }
+  throw authError(
+    "No API token found. Set ANIMA_API_TOKEN env var or run: anima auth --token <token>\nGet your token at: https://dev.animaapp.com > Settings > API Keys"
+  );
+}
+
+// src/api/client.ts
+async function streamGeneration(url, body, headers, callbacks = {}, timeoutMs = 6e5, signal) {
+  const controller = new AbortController();
+  const combinedSignal = signal ?? controller.signal;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...headers,
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify(body),
+      signal: combinedSignal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      let detail;
+      try {
+        detail = JSON.parse(errorText);
+      } catch {
+        detail = errorText;
+      }
+      throw apiError(
+        `API returned ${response.status}: ${response.statusText}`,
+        detail
+      );
+    }
+    if (!response.body) {
+      throw streamError("Response body is null");
+    }
+    return await parseSSEStream(
+      response.body,
+      (data, result) => {
+        switch (data.type) {
+          case "queueing":
+            callbacks.onQueueing?.(data.payload.sessionId);
+            break;
+          case "start":
+            result.sessionId = data.sessionId;
+            callbacks.onStart?.(data.sessionId);
+            break;
+          case "progress_messages_updated":
+            callbacks.onProgress?.(data.payload.progressMessages);
+            break;
+          case "generating_code":
+            if (data.payload.status === "success") {
+              result.files = data.payload.files;
+            }
+            callbacks.onGeneratingCode?.(data.payload.progress);
+            break;
+          case "assets_list":
+            result.assets = data.payload.assets;
+            break;
+          case "codegen_completed":
+          case "generation_completed":
+            callbacks.onCompleted?.();
+            break;
+          case "error":
+            throw apiError(
+              `${data.payload.errorName}: ${data.payload.reason}`,
+              data.payload
+            );
+          case "done":
+            result.tokenUsage = data.payload.tokenUsage;
+            result.sessionId = data.payload.sessionId;
+            return true;
+        }
+        return false;
+      },
+      { sessionId: "", files: {}, tokenUsage: 0 }
+    );
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw timeoutError();
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function parseSSEStream(body, handler, initial) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const result = { ...initial };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim() || line.startsWith(":")) continue;
+        if (line.startsWith("data: ")) {
+          let data;
+          try {
+            data = JSON.parse(line.slice(6));
+          } catch {
+            continue;
+          }
+          const isDone = handler(data, result);
+          if (isDone) return result;
+        }
+      }
+    }
+  } finally {
+    reader.cancel();
+  }
+  throw streamError("Connection closed before receiving 'done' message");
+}
+function buildHeaders(token, teamId) {
+  const headers = {
+    Authorization: `Bearer ${token}`
+  };
+  if (teamId) {
+    headers["X-Team-Id"] = teamId;
+  }
+  return headers;
+}
+
+// src/output/formatter.ts
+function detectOutputMode(flags) {
+  if (flags.json !== void 0) {
+    return flags.json ? "json" : "pretty";
+  }
+  return process.stdout.isTTY ? "pretty" : "json";
+}
+function outputResult(mode, data) {
+  if (mode === "json") {
+    process.stdout.write(JSON.stringify(data) + "\n");
+  }
+}
+function outputError(mode, error) {
+  if (mode === "json") {
+    process.stdout.write(
+      JSON.stringify({ success: false, error }) + "\n"
+    );
+  }
+}
+
+// src/output/progress.ts
+import ora from "ora";
+var ProgressReporter = class {
+  #spinner = null;
+  #mode;
+  #startTime = 0;
+  #verbose;
+  constructor(mode, verbose = false) {
+    this.#mode = mode;
+    this.#verbose = verbose;
+  }
+  start(message) {
+    this.#startTime = Date.now();
+    if (this.#mode === "pretty") {
+      this.#spinner = ora(message).start();
+    } else if (this.#verbose) {
+      process.stderr.write(JSON.stringify({ status: "started", message }) + "\n");
+    }
+  }
+  update(message) {
+    if (this.#mode === "pretty" && this.#spinner) {
+      const elapsed = this.#elapsed();
+      this.#spinner.text = `${message} ${elapsed}`;
+    } else if (this.#verbose) {
+      process.stderr.write(JSON.stringify({ status: "progress", message }) + "\n");
+    }
+  }
+  succeed(message) {
+    if (this.#mode === "pretty" && this.#spinner) {
+      const elapsed = this.#elapsed();
+      this.#spinner.succeed(`${message} ${elapsed}`);
+    } else if (this.#verbose) {
+      process.stderr.write(JSON.stringify({ status: "done", message }) + "\n");
+    }
+    this.#spinner = null;
+  }
+  fail(message) {
+    if (this.#mode === "pretty" && this.#spinner) {
+      this.#spinner.fail(message);
+    } else if (this.#verbose) {
+      process.stderr.write(JSON.stringify({ status: "error", message }) + "\n");
+    }
+    this.#spinner = null;
+  }
+  #elapsed() {
+    const ms = Date.now() - this.#startTime;
+    const seconds = Math.floor(ms / 1e3);
+    if (seconds < 60) return `(${seconds}s)`;
+    const minutes = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `(${minutes}m ${secs}s)`;
+  }
+};
+
+// src/output/pretty.ts
+import chalk from "chalk";
+function printSuccess(message) {
+  console.log(chalk.green("\u2713") + " " + message);
+}
+function printError(message) {
+  console.error(chalk.red("\u2717") + " " + message);
+}
+function printInfo(message) {
+  console.log(chalk.blue("\u2139") + " " + message);
+}
+function printKeyValue(key, value) {
+  console.log(`  ${chalk.gray(key + ":")} ${value}`);
+}
+function printSessionResult(result) {
+  console.log();
+  printSuccess("Playground created successfully!");
+  printKeyValue("Session ID", result.sessionId);
+  if (result.playgroundUrl) {
+    printKeyValue("Playground", chalk.cyan.underline(result.playgroundUrl));
+  }
+  if (result.tokenUsage) {
+    printKeyValue("Token usage", result.tokenUsage.toLocaleString());
+  }
+  console.log();
+}
+function printDeployResult(result) {
+  console.log();
+  printSuccess("Published successfully!");
+  if (result.url) {
+    printKeyValue("Live URL", chalk.cyan.underline(result.url));
+  }
+  if (result.packageName) {
+    printKeyValue("Package", result.packageName);
+    printKeyValue("Version", result.packageVersion ?? "");
+    if (result.packageUrl) {
+      printKeyValue("URL", chalk.cyan.underline(result.packageUrl));
+    }
+  }
+  console.log();
+}
+function printFilesWritten(outputDir, count) {
+  console.log();
+  printSuccess(`${count} files written to ${chalk.cyan(outputDir)}`);
+  console.log();
+}
+
+// src/utils/figma.ts
+function parseFigmaUrl(input) {
+  if (!input.includes("figma.com")) {
+    return { fileKey: input };
+  }
+  try {
+    const url = new URL(input);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    const typeIndex = pathParts.findIndex(
+      (p) => p === "file" || p === "design"
+    );
+    if (typeIndex === -1 || typeIndex + 1 >= pathParts.length) {
+      throw new Error("Could not find file key in Figma URL");
+    }
+    const fileKey = pathParts[typeIndex + 1];
+    const nodeIdParam = url.searchParams.get("node-id");
+    let nodeId;
+    if (nodeIdParam) {
+      nodeId = nodeIdParam.replace(/-/g, ":");
+    }
+    return { fileKey, nodeId };
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("file key")) {
+      throw err;
+    }
+    throw new Error(`Invalid Figma URL: ${input}`);
+  }
+}
+function normalizeNodeId(nodeId) {
+  return nodeId.replace(/-/g, ":");
+}
+
+// src/commands/create.ts
+var DEFAULT_API_URL = "https://public-api.animaapp.com";
+var PLAYGROUND_BASE = "https://dev.animaapp.com/chat";
+var createCommand = new Command("create").description("Create app from prompt, URL, or Figma design (3-7 min)").requiredOption("-t, --type <type>", "Generation type: p2c, l2c, or f2c").option("-p, --prompt <prompt>", "Text prompt (p2c)").option("-u, --url <url>", "Website URL (l2c)").option("--file-key <key>", "Figma file key or URL (f2c)").option("--nodes <nodes>", "Figma node IDs, comma-separated (f2c)").option("--figma-token <token>", "Figma personal access token (f2c)").option("--framework <fw>", "react | html", "react").option("--styling <style>", "tailwind | css | plain_css | css_modules | inline_styles", "tailwind").option("--language <lang>", "typescript | javascript").option("--ui-library <lib>", "mui | antd | shadcn | clean_react").option("--guidelines <text>", "Additional constraints (p2c only)").option("--json", "Output as JSON").option("--timeout <ms>", "Timeout in milliseconds", "600000").option("--verbose", "Show progress on stderr").option("--api-url <url>", "API base URL", DEFAULT_API_URL).action(async (opts) => {
+  const mode = detectOutputMode(opts);
+  const progress = new ProgressReporter(mode, opts.verbose);
+  try {
+    const type = opts.type;
+    validateCreateOptions(type, opts);
+    const auth = resolveAuth();
+    const headers = buildHeaders(auth.token, auth.teamId);
+    const { endpoint, body } = buildCreateRequest(type, opts, auth.figmaToken);
+    progress.start(`Creating ${type.toUpperCase()} playground...`);
+    const result = await streamGeneration(
+      `${opts.apiUrl}${endpoint}`,
+      body,
+      headers,
+      {
+        onQueueing: () => progress.update("Queued, waiting..."),
+        onStart: (sid) => progress.update(`Started (${sid.slice(0, 8)}...)...`),
+        onProgress: (msgs) => {
+          const running = msgs.find((m) => m.status === "running");
+          if (running) progress.update(running.title);
+        },
+        onGeneratingCode: (pct) => progress.update(`Generating code (${pct}%)...`),
+        onCompleted: () => progress.update("Finalizing...")
+      },
+      parseInt(opts.timeout, 10)
+    );
+    const playgroundUrl = `${PLAYGROUND_BASE}/${result.sessionId}`;
+    progress.succeed("Playground created!");
+    if (mode === "pretty") {
+      printSessionResult({
+        sessionId: result.sessionId,
+        playgroundUrl,
+        tokenUsage: result.tokenUsage
+      });
+    } else {
+      outputResult(mode, {
+        success: true,
+        sessionId: result.sessionId,
+        playgroundUrl,
+        tokenUsage: result.tokenUsage
+      });
+    }
+  } catch (err) {
+    progress.fail("Failed");
+    if (err instanceof CliError) {
+      if (mode === "pretty") {
+        console.error(err.message);
+      } else {
+        outputError(mode, { code: err.code, message: err.message });
+      }
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+});
+function validateCreateOptions(type, opts) {
+  if (!["p2c", "l2c", "f2c"].includes(type)) {
+    throw validationError(`Invalid type "${type}". Must be p2c, l2c, or f2c.`);
+  }
+  if (type === "p2c" && !opts.prompt) {
+    throw validationError("--prompt is required for p2c type");
+  }
+  if (type === "l2c" && !opts.url) {
+    throw validationError("--url is required for l2c type");
+  }
+  if (type === "f2c" && !opts.fileKey) {
+    throw validationError("--file-key is required for f2c type");
+  }
+}
+function buildCreateRequest(type, opts, storedFigmaToken) {
+  const language = opts.language ?? (opts.framework === "react" ? "typescript" : void 0);
+  const conventions = {
+    framework: opts.framework,
+    language,
+    styling: opts.styling,
+    uiLibrary: opts.uiLibrary
+  };
+  Object.keys(conventions).forEach((key) => {
+    if (conventions[key] === void 0) {
+      delete conventions[key];
+    }
+  });
+  switch (type) {
+    case "p2c":
+      return {
+        endpoint: "/v1/p2c",
+        body: {
+          params: {
+            prompt: opts.prompt,
+            conventions,
+            ...opts.guidelines ? { guidelines: opts.guidelines } : {}
+          }
+        }
+      };
+    case "l2c":
+      return {
+        endpoint: "/v1/l2c",
+        body: {
+          params: {
+            input: { type: "url", url: opts.url },
+            conventions,
+            assetsStorage: { type: "bundled" }
+          }
+        }
+      };
+    case "f2c": {
+      const { fileKey, nodeId: parsedNodeId } = parseFigmaUrl(opts.fileKey);
+      let nodesId = [];
+      if (opts.nodes) {
+        nodesId = opts.nodes.split(",").map((n) => normalizeNodeId(n.trim()));
+      } else if (parsedNodeId) {
+        nodesId = [parsedNodeId];
+      }
+      const figmaToken = opts.figmaToken || process.env.FIGMA_TOKEN || storedFigmaToken;
+      if (!figmaToken) {
+        throw validationError(
+          "Figma token required for f2c. Use --figma-token, set FIGMA_TOKEN env var, or run: anima auth --figma-token <token>\nGet one at: https://www.figma.com > Settings > Personal access tokens"
+        );
+      }
+      return {
+        endpoint: "/v1/codegen",
+        body: {
+          fileKey,
+          nodesId,
+          figmaToken,
+          framework: conventions.framework,
+          language: conventions.language,
+          styling: conventions.styling,
+          uiLibrary: conventions.uiLibrary
+        }
+      };
+    }
+  }
+}
+
+// src/commands/publish.ts
+import { Command as Command2 } from "commander";
+
+// src/api/mcp-client.ts
+async function callMCPTool(apiBaseUrl, token, teamId, toolName, args) {
+  const request = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: {
+      name: toolName,
+      arguments: args
+    }
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json, text/event-stream",
+    Authorization: `Bearer ${token}`
+  };
+  if (teamId) {
+    headers["X-Team-Id"] = teamId;
+  }
+  const response = await fetch(`${apiBaseUrl}/v1/mcp`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw apiError(`MCP request failed (${response.status}): ${errorText}`);
+  }
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("text/event-stream")) {
+    return parseMCPSSEResponse(response);
+  }
+  const data = await response.json();
+  return extractMCPResult(data);
+}
+async function parseMCPSSEResponse(response) {
+  if (!response.body) {
+    throw streamError("Response body is null");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let lastData = null;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim() || line.startsWith(":")) continue;
+        if (line.startsWith("data: ")) {
+          try {
+            const parsed = JSON.parse(line.slice(6));
+            if (parsed.jsonrpc === "2.0") {
+              lastData = parsed;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } finally {
+    reader.cancel();
+  }
+  if (!lastData) {
+    throw apiError("MCP SSE stream ended without a JSON-RPC response");
+  }
+  return extractMCPResult(lastData);
+}
+function extractMCPResult(data) {
+  if (data.error) {
+    throw apiError(`MCP tool error: ${data.error.message}`);
+  }
+  if (!data.result?.content?.length) {
+    throw apiError("MCP tool returned empty result");
+  }
+  const textContent = data.result.content.find((c) => c.type === "text");
+  if (!textContent) {
+    throw apiError("MCP tool returned no text content");
+  }
+  try {
+    return JSON.parse(textContent.text);
+  } catch {
+    return textContent.text;
+  }
+}
+
+// src/commands/publish.ts
+var publishCommand = new Command2("publish").description("Deploy playground to live URL or npm package (1-3 min)").argument("<sessionId>", "Session ID from create command").option("--mode <mode>", "webapp | designSystem", "webapp").option("--package-name <name>", "NPM package name (designSystem mode)").option("--package-version <version>", "NPM package version (designSystem mode)").option("--json", "Output as JSON").option("--verbose", "Show progress on stderr").option("--api-url <url>", "API base URL", "https://public-api.animaapp.com").action(async (sessionId, opts) => {
+  const mode = detectOutputMode(opts);
+  const progress = new ProgressReporter(mode, opts.verbose);
+  try {
+    if (!["webapp", "designSystem"].includes(opts.mode)) {
+      throw validationError(
+        `Invalid mode "${opts.mode}". Must be webapp or designSystem.`
+      );
+    }
+    if (opts.mode === "designSystem" && !opts.packageName) {
+      throw validationError("--package-name is required for designSystem mode");
+    }
+    const auth = resolveAuth();
+    const args = {
+      sessionId,
+      mode: opts.mode
+    };
+    if (opts.packageName) args.packageName = opts.packageName;
+    if (opts.packageVersion) args.packageVersion = opts.packageVersion;
+    progress.start(`Publishing as ${opts.mode}...`);
+    const result = await callMCPTool(
+      opts.apiUrl,
+      auth.token,
+      auth.teamId,
+      "playground-publish",
+      args
+    );
+    if (!result.success) {
+      throw new CliError(
+        "API_ERROR",
+        result.error || result.reason || "Publish failed",
+        1,
+        result
+      );
+    }
+    progress.succeed("Published!");
+    if (mode === "pretty") {
+      printDeployResult({
+        url: result.liveUrl,
+        packageUrl: result.packageUrl,
+        packageName: result.packageName,
+        packageVersion: result.packageVersion
+      });
+    } else {
+      outputResult(mode, {
+        success: true,
+        sessionId,
+        ...result.liveUrl ? { liveUrl: result.liveUrl, subdomain: result.subdomain } : {},
+        ...result.packageName ? {
+          packageName: result.packageName,
+          packageVersion: result.packageVersion,
+          packageUrl: result.packageUrl
+        } : {}
+      });
+    }
+  } catch (err) {
+    progress.fail("Failed");
+    if (err instanceof CliError) {
+      if (mode === "pretty") {
+        console.error(err.message);
+      } else {
+        outputError(mode, { code: err.code, message: err.message });
+      }
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+});
+
+// src/commands/codegen.ts
+import { Command as Command3 } from "commander";
+
+// src/utils/files.ts
+import fs2 from "fs";
+import path2 from "path";
+function writeFilesToDisk(files, outputDir) {
+  fs2.mkdirSync(outputDir, { recursive: true });
+  let count = 0;
+  for (const [filePath, fileContent] of Object.entries(files)) {
+    const fullPath = path2.join(outputDir, filePath);
+    const dirPath = path2.dirname(fullPath);
+    fs2.mkdirSync(dirPath, { recursive: true });
+    if (fileContent.isBinary) {
+      const buffer = Buffer.from(fileContent.content, "base64");
+      fs2.writeFileSync(fullPath, buffer);
+    } else {
+      fs2.writeFileSync(fullPath, fileContent.content, "utf-8");
+    }
+    count++;
+  }
+  return count;
+}
+
+// src/commands/codegen.ts
+var DEFAULT_API_URL2 = "https://public-api.animaapp.com";
+var codegenCommand = new Command3("codegen").description("Convert Figma design to code files (no playground)").requiredOption("--file-key <key>", "Figma file key or URL").option("--nodes <nodes>", "Figma node IDs, comma-separated").option("--figma-token <token>", "Figma personal access token (or set FIGMA_TOKEN env var)").option("-o, --output <dir>", "Output directory", "./generated").option("--framework <fw>", "react | html", "react").option("--styling <style>", "tailwind | css | plain_css | css_modules | inline_styles", "tailwind").option("--language <lang>", "typescript | javascript").option("--ui-library <lib>", "mui | antd | shadcn | clean_react").option("--json", "Output as JSON").option("--timeout <ms>", "Timeout in milliseconds", "600000").option("--verbose", "Show progress on stderr").option("--api-url <url>", "API base URL", DEFAULT_API_URL2).action(async (opts) => {
+  const mode = detectOutputMode(opts);
+  const progress = new ProgressReporter(mode, opts.verbose);
+  try {
+    const { fileKey, nodeId: parsedNodeId } = parseFigmaUrl(opts.fileKey);
+    let nodesId = [];
+    if (opts.nodes) {
+      nodesId = opts.nodes.split(",").map((n) => normalizeNodeId(n.trim()));
+    } else if (parsedNodeId) {
+      nodesId = [parsedNodeId];
+    }
+    if (nodesId.length === 0) {
+      throw validationError(
+        "No node IDs provided. Use --nodes or include node-id in the Figma URL."
+      );
+    }
+    const auth = resolveAuth();
+    const figmaToken = opts.figmaToken || auth.figmaToken;
+    if (!figmaToken) {
+      throw validationError(
+        "Figma token required. Use --figma-token, set FIGMA_TOKEN env var, or run: anima auth --figma-token <token>\nGet one at: https://www.figma.com > Settings > Personal access tokens"
+      );
+    }
+    const headers = buildHeaders(auth.token, auth.teamId);
+    const language = opts.language ?? (opts.framework === "react" ? "typescript" : void 0);
+    const requestBody = {
+      fileKey,
+      nodesId,
+      figmaToken,
+      framework: opts.framework,
+      language,
+      styling: opts.styling,
+      uiLibrary: opts.uiLibrary
+    };
+    progress.start("Generating code from Figma...");
+    const result = await streamGeneration(
+      `${opts.apiUrl}/v1/codegen`,
+      requestBody,
+      headers,
+      {
+        onQueueing: () => progress.update("Queued, waiting..."),
+        onStart: (sid) => progress.update(`Started (${sid.slice(0, 8)}...)...`),
+        onProgress: (msgs) => {
+          const running = msgs.find((m) => m.status === "running");
+          if (running) progress.update(running.title);
+        },
+        onGeneratingCode: (pct) => progress.update(`Generating code (${pct}%)...`),
+        onCompleted: () => progress.update("Writing files...")
+      },
+      parseInt(opts.timeout, 10)
+    );
+    const count = writeFilesToDisk(result.files, opts.output);
+    progress.succeed(`Generated ${count} files`);
+    if (mode === "pretty") {
+      printFilesWritten(opts.output, count);
+    } else {
+      outputResult(mode, {
+        success: true,
+        output: opts.output,
+        fileCount: count,
+        sessionId: result.sessionId,
+        tokenUsage: result.tokenUsage
+      });
+    }
+  } catch (err) {
+    progress.fail("Failed");
+    if (err instanceof CliError) {
+      if (mode === "pretty") {
+        console.error(err.message);
+      } else {
+        outputError(mode, { code: err.code, message: err.message });
+      }
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+});
+
+// src/commands/download.ts
+import { Command as Command4 } from "commander";
+import fs4 from "fs";
+import path4 from "path";
+import { pipeline as pipeline2 } from "stream/promises";
+import { createWriteStream } from "fs";
+import { Readable as Readable2 } from "stream";
+
+// src/utils/download.ts
+import fs3 from "fs";
+import path3 from "path";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+function parsePlaygroundUrl(input) {
+  if (!input.includes("/")) {
+    return input;
+  }
+  try {
+    const url = new URL(input);
+    const parts = url.pathname.split("/").filter(Boolean);
+    const chatIndex = parts.indexOf("chat");
+    if (chatIndex !== -1 && chatIndex + 1 < parts.length) {
+      return parts[chatIndex + 1];
+    }
+    return parts[parts.length - 1];
+  } catch {
+    return input;
+  }
+}
+
+// src/commands/download.ts
+var DEFAULT_API_URL3 = "https://public-api.animaapp.com";
+var downloadCommand = new Command4("download").description("Download project from an Anima playground").argument("<playgroundUrl>", "Playground URL or session ID").option("-o, --output <dir>", "Output directory", "./downloaded").option("--json", "Output as JSON").option("--verbose", "Show progress on stderr").option("--api-url <url>", "API base URL", DEFAULT_API_URL3).action(async (playgroundUrl, opts) => {
+  const mode = detectOutputMode(opts);
+  const progress = new ProgressReporter(mode, opts.verbose);
+  try {
+    const sessionId = parsePlaygroundUrl(playgroundUrl);
+    const auth = resolveAuth();
+    progress.start("Requesting download...");
+    const result = await callMCPTool(
+      opts.apiUrl,
+      auth.token,
+      auth.teamId,
+      "project-download_from_playground",
+      { playgroundUrl: `https://dev.animaapp.com/chat/${sessionId}` }
+    );
+    if (!result.success) {
+      throw apiError(
+        result.error || "Download failed",
+        result
+      );
+    }
+    const downloadUrl = result.downloadUrl;
+    const fileCount = result.fileCount;
+    if (!downloadUrl) {
+      throw apiError("No download URL returned");
+    }
+    progress.update(`Downloading zip (${fileCount} files)...`);
+    const zipPath = path4.join(opts.output, "__download.zip");
+    fs4.mkdirSync(opts.output, { recursive: true });
+    const zipResponse = await fetch(downloadUrl);
+    if (!zipResponse.ok || !zipResponse.body) {
+      throw apiError(`Failed to download zip: ${zipResponse.status}`);
+    }
+    await pipeline2(
+      Readable2.fromWeb(zipResponse.body),
+      createWriteStream(zipPath)
+    );
+    progress.update("Extracting...");
+    const { execSync } = await import("child_process");
+    try {
+      execSync(`unzip -o -q "${zipPath}" -d "${opts.output}"`, {
+        stdio: "pipe"
+      });
+    } catch {
+      execSync(`tar -xf "${zipPath}" -C "${opts.output}"`, {
+        stdio: "pipe"
+      });
+    }
+    fs4.unlinkSync(zipPath);
+    const count = countFiles(opts.output);
+    progress.succeed(`Downloaded ${count} files`);
+    if (mode === "pretty") {
+      printFilesWritten(opts.output, count);
+    } else {
+      outputResult(mode, {
+        success: true,
+        output: opts.output,
+        fileCount: count,
+        sessionId
+      });
+    }
+  } catch (err) {
+    progress.fail("Failed");
+    if (err instanceof CliError) {
+      if (mode === "pretty") {
+        console.error(err.message);
+      } else {
+        outputError(mode, { code: err.code, message: err.message });
+      }
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+});
+function countFiles(dir) {
+  let count = 0;
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      count += countFiles(path4.join(dir, entry.name));
+    } else {
+      count++;
+    }
+  }
+  return count;
+}
+
+// src/commands/auth.ts
+import { Command as Command5 } from "commander";
+import chalk2 from "chalk";
+
+// src/auth/oauth.ts
+import http from "http";
+import open from "open";
+var OAUTH_PORT = 19284;
+var OAUTH_BASE = "https://dev.animaapp.com";
+async function loginWithBrowser() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${OAUTH_PORT}`);
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        const teamId = url.searchParams.get("teamId") ?? void 0;
+        if (!token) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(
+            "<html><body><h1>Error</h1><p>No token received. Please try again.</p></body></html>"
+          );
+          server.close();
+          reject(new Error("No token received from OAuth flow"));
+          return;
+        }
+        writeCredentials({ token, teamId });
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h1>Authenticated!</h1><p>You can close this window and return to the terminal.</p></body></html>"
+        );
+        server.close();
+        resolve({ token, teamId });
+      }
+    });
+    server.listen(OAUTH_PORT, () => {
+      const authUrl = `${OAUTH_BASE}/cli-auth?redirect=http://localhost:${OAUTH_PORT}/callback`;
+      open(authUrl);
+    });
+    server.on("error", (err) => {
+      reject(
+        new Error(`Failed to start OAuth callback server: ${err.message}`)
+      );
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("OAuth login timed out after 5 minutes"));
+    }, 3e5);
+  });
+}
+
+// src/commands/auth.ts
+var DEFAULT_API_URL4 = "https://public-api.animaapp.com";
+var authCommand = new Command5("auth").description("Manage authentication").option("--token <token>", "Store Anima API token").option("--figma-token <token>", "Store Figma personal access token").option("--team-id <teamId>", "Team ID to associate with token").option("--login", "Login via browser OAuth flow").option("--status", "Show current auth status").option("--logout", "Clear stored credentials").option("--json", "Output as JSON").option("--api-url <url>", "API base URL", DEFAULT_API_URL4).action(async (opts) => {
+  const mode = detectOutputMode(opts);
+  try {
+    if (opts.token || opts.figmaToken) {
+      const toSave = {};
+      if (opts.token) {
+        toSave.token = opts.token;
+        toSave.teamId = opts.teamId ?? extractTeamIdFromJWT(opts.token) ?? "";
+      }
+      if (opts.figmaToken) {
+        toSave.figmaToken = opts.figmaToken;
+      }
+      writeCredentials(toSave);
+      if (mode === "pretty") {
+        printSuccess("Credentials saved to " + getCredentialsPath());
+        if (opts.token) {
+          printKeyValue("Anima token", "saved");
+          if (toSave.teamId) printKeyValue("Team ID", toSave.teamId);
+        }
+        if (opts.figmaToken) {
+          printKeyValue("Figma token", "saved");
+        }
+      } else {
+        outputResult(mode, {
+          success: true,
+          action: "token_saved",
+          path: getCredentialsPath(),
+          ...opts.token ? { teamId: toSave.teamId } : {},
+          ...opts.figmaToken ? { figmaToken: true } : {}
+        });
+      }
+      return;
+    }
+    if (opts.login) {
+      if (mode === "pretty") {
+        printInfo("Opening browser for authentication...");
+      }
+      const result = await loginWithBrowser();
+      if (mode === "pretty") {
+        printSuccess("Authenticated successfully!");
+        printKeyValue("Token", result.token.slice(0, 8) + "...");
+        if (result.teamId) printKeyValue("Team ID", result.teamId);
+      } else {
+        outputResult(mode, { success: true, action: "logged_in" });
+      }
+      return;
+    }
+    if (opts.logout) {
+      const deleted = deleteCredentials();
+      if (mode === "pretty") {
+        if (deleted) {
+          printSuccess("Credentials cleared");
+        } else {
+          printInfo("No stored credentials found");
+        }
+      } else {
+        outputResult(mode, { success: true, action: "logged_out", hadCredentials: deleted });
+      }
+      return;
+    }
+    if (opts.status) {
+      try {
+        const auth = resolveAuth();
+        const creds = readCredentials();
+        const sourceName = auth.source === "env" ? "ANIMA_API_TOKEN env var" : getCredentialsPath();
+        const hasFigma = !!(process.env.FIGMA_TOKEN || creds?.figmaToken);
+        if (mode === "pretty") {
+          printSuccess("Token configured");
+          printKeyValue("Source", sourceName);
+          printKeyValue("Anima token", auth.token.slice(0, 12) + "..." + auth.token.slice(-4));
+          if (auth.teamId) printKeyValue("Team ID", auth.teamId);
+          printKeyValue("Figma token", hasFigma ? "configured" : "not set (needed for codegen/f2c)");
+        } else {
+          outputResult(mode, {
+            success: true,
+            source: auth.source,
+            tokenPreview: auth.token.slice(0, 12) + "..." + auth.token.slice(-4),
+            teamId: auth.teamId,
+            figmaToken: hasFigma
+          });
+        }
+      } catch (err) {
+        if (err instanceof CliError) {
+          if (mode === "pretty") {
+            printError(err.message);
+          } else {
+            outputError(mode, { code: err.code, message: err.message });
+          }
+        } else {
+          throw err;
+        }
+      }
+      return;
+    }
+    if (mode === "pretty") {
+      console.log();
+      printInfo("Auth commands:");
+      console.log(`  ${chalk2.cyan("anima auth --token <T>")}                   Save Anima API token`);
+      console.log(`  ${chalk2.cyan("anima auth --figma-token <T>")}             Save Figma token`);
+      console.log(`  ${chalk2.cyan("anima auth --token <T> --figma-token <T>")} Save both at once`);
+      console.log(`  ${chalk2.cyan("anima auth --login")}                       Login via browser`);
+      console.log(`  ${chalk2.cyan("anima auth --status")}                      Check auth status`);
+      console.log(`  ${chalk2.cyan("anima auth --logout")}                      Clear all credentials`);
+      console.log();
+      console.log(`  Anima token: ${chalk2.cyan.underline("https://dev.animaapp.com")} > Settings > API Keys`);
+      console.log(`  Figma token: ${chalk2.cyan.underline("https://www.figma.com")} > Settings > Personal access tokens`);
+      console.log();
+    } else {
+      outputResult(mode, {
+        success: true,
+        message: "Use --token, --login, --status, or --logout"
+      });
+    }
+  } catch (err) {
+    if (err instanceof CliError) {
+      if (mode === "pretty") {
+        printError(err.message);
+      } else {
+        outputError(mode, { code: err.code, message: err.message });
+      }
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+});
+
+// src/index.ts
+var program = new Command6().name("anima").description(
+  `Anima CLI - Generate production-ready apps from prompts, URLs, or Figma designs.
+
+AUTHENTICATION:
+  Set ANIMA_API_TOKEN env var or run: npx @animaapp/cli auth --token <token>
+  Get key: https://dev.animaapp.com > Settings > API Keys
+
+TIMING (important for AI agents):
+  create   \u2192 3-7 minutes (SSE streaming, set timeout to 600000ms)
+  publish  \u2192 1-3 minutes
+  codegen  \u2192 2-5 minutes
+  download \u2192 seconds
+  The --timeout default is 600000ms (10 min). Do NOT reduce it.
+
+COMMANDS:
+  create    Create app from prompt, URL, or Figma design
+  publish   Deploy playground to live URL or npm package
+  codegen   Convert Figma design to code files (no playground)
+  download  Download project from an Anima playground
+  auth      Manage authentication (token stored in ~/.config/anima/)
+
+EXAMPLES:
+  npx @animaapp/cli auth --token <your-token>
+  npx @animaapp/cli create -t p2c -p "SaaS dashboard with sidebar and analytics"
+  npx @animaapp/cli create -t l2c -u https://stripe.com
+  npx @animaapp/cli create -t f2c --file-key abc --nodes 42:15
+  npx @animaapp/cli publish abc123xyz
+  npx @animaapp/cli codegen --file-key abc --nodes 42:15 -o ./components
+  npx @animaapp/cli download https://dev.animaapp.com/chat/abc123xyz
+
+OUTPUT: JSON to stdout when piped (for AI tools), pretty text in terminals.
+  Progress is streamed to stderr via --verbose when in JSON mode.`
+).version("0.1.0", "-v, --version");
+program.addCommand(createCommand);
+program.addCommand(publishCommand);
+program.addCommand(codegenCommand);
+program.addCommand(downloadCommand);
+program.addCommand(authCommand);
+program.parseAsync(process.argv).catch((err) => {
+  if (err instanceof CliError) {
+    if (process.stdout.isTTY) {
+      console.error(err.message);
+    } else {
+      process.stdout.write(
+        JSON.stringify({
+          success: false,
+          error: { code: err.code, message: err.message }
+        }) + "\n"
+      );
+    }
+    process.exit(err.exitCode);
+  }
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map