@teinai/cli 1.0.0

package/index.js

@@ -0,0 +1,1943 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/colors.ts
+var isColorSupported = !process.env.NO_COLOR && (process.stdout.isTTY || process.env.FORCE_COLOR === "1" || process.env.TERM !== "dumb");
+function wrap(code, close) {
+  return (str) => isColorSupported ? `\x1B[${code}m${str}\x1B[${close}m` : String(str);
+}
+var c = {
+  bold: wrap(1, 22),
+  dim: wrap(2, 22),
+  italic: wrap(3, 23),
+  underline: wrap(4, 24),
+  inverse: wrap(7, 27),
+  black: wrap(30, 39),
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  blue: wrap(34, 39),
+  magenta: wrap(35, 39),
+  cyan: wrap(36, 39),
+  white: wrap(37, 39),
+  gray: wrap(90, 39),
+  bgBlue: wrap(44, 49),
+  bgMagenta: wrap(45, 49),
+  bgCyan: wrap(46, 49),
+  bgGreen: wrap(42, 49)
+};
+var Spinner = class {
+  constructor(initialText = "") {
+    this.frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    this.current = 0;
+    this.timer = null;
+    this.text = initialText;
+  }
+  start(text) {
+    if (text) this.text = text;
+    if (!process.stdout.isTTY) {
+      process.stdout.write(`[i] ${this.text}...
+`);
+      return this;
+    }
+    this.stop();
+    this.timer = setInterval(() => {
+      const frame = c.cyan(this.frames[this.current]);
+      process.stdout.write(`\r${frame} ${this.text} `);
+      this.current = (this.current + 1) % this.frames.length;
+    }, 80);
+    return this;
+  }
+  update(text) {
+    this.text = text;
+  }
+  succeed(text) {
+    this.stop();
+    const msg = text || this.text;
+    if (process.stdout.isTTY) {
+      process.stdout.write(`\r${c.green("\u2714")} ${msg}
+`);
+    } else {
+      process.stdout.write(`[\u2714] ${msg}
+`);
+    }
+  }
+  fail(text) {
+    this.stop();
+    const msg = text || this.text;
+    if (process.stdout.isTTY) {
+      process.stdout.write(`\r${c.red("\u2716")} ${msg}
+`);
+    } else {
+      process.stdout.write(`[\u2716] ${msg}
+`);
+    }
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+      if (process.stdout.isTTY) {
+        process.stdout.write("\r\x1B[K");
+      }
+    }
+  }
+};
+
+// src/cli/commands/run.ts
+var import_node_path3 = __toESM(require("node:path"));
+
+// src/cli/api.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_promises = require("node:stream/promises");
+var TeinApiClient = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      "User-Agent": "Tein-CLI/1.0.0"
+    };
+  }
+  async runJob(model, parameters) {
+    const url = `${this.baseUrl}/v1/run`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ model, parameters })
+    });
+    if (!res.ok) {
+      let errMsg = `HTTP ${res.status} ${res.statusText}`;
+      try {
+        const body = await res.json();
+        errMsg = body.error || body.message || errMsg;
+      } catch {
+      }
+      throw new Error(errMsg);
+    }
+    return await res.json();
+  }
+  async queueJob(model, parameters) {
+    const url = `${this.baseUrl}/v1/queue`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ model, parameters })
+    });
+    if (!res.ok) {
+      let errMsg = `HTTP ${res.status} ${res.statusText}`;
+      try {
+        const body = await res.json();
+        errMsg = body.error || body.message || errMsg;
+      } catch {
+      }
+      throw new Error(errMsg);
+    }
+    return await res.json();
+  }
+  async getStatus(requestId) {
+    const url = `${this.baseUrl}/v1/status/${requestId}`;
+    const res = await fetch(url, {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    if (!res.ok) {
+      let errMsg = `HTTP ${res.status} ${res.statusText}`;
+      try {
+        const body = await res.json();
+        errMsg = body.error || body.message || errMsg;
+      } catch {
+      }
+      throw new Error(errMsg);
+    }
+    return await res.json();
+  }
+  async downloadOutput(url, destinationPath) {
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`Failed to download output from ${url}: HTTP ${res.status}`);
+    }
+    const resolvedDir = import_node_path.default.dirname(destinationPath);
+    if (!import_node_fs.default.existsSync(resolvedDir)) {
+      import_node_fs.default.mkdirSync(resolvedDir, { recursive: true });
+    }
+    const fileStream = import_node_fs.default.createWriteStream(destinationPath);
+    await (0, import_promises.pipeline)(res.body, fileStream);
+    return destinationPath;
+  }
+};
+
+// src/cli/config.ts
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path2 = __toESM(require("node:path"));
+var CONFIG_DIR = import_node_path2.default.join(import_node_os.default.homedir(), ".tein");
+var CONFIG_FILE = import_node_path2.default.join(CONFIG_DIR, "config.json");
+function getStoredConfig() {
+  try {
+    if (import_node_fs2.default.existsSync(CONFIG_FILE)) {
+      const raw = import_node_fs2.default.readFileSync(CONFIG_FILE, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return {};
+}
+function saveStoredConfig(config) {
+  try {
+    if (!import_node_fs2.default.existsSync(CONFIG_DIR)) {
+      import_node_fs2.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const current = getStoredConfig();
+    const updated = { ...current, ...config };
+    import_node_fs2.default.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2), "utf-8");
+  } catch (err) {
+    throw new Error(`Failed to save config to ${CONFIG_FILE}: ${err}`);
+  }
+}
+function resolveApiKey(cliKey) {
+  if (cliKey && cliKey.trim()) {
+    return cliKey.trim();
+  }
+  const envKey = process.env.TEIN_API_KEY || process.env.TEIN_KEY;
+  if (envKey && envKey.trim()) {
+    return envKey.trim();
+  }
+  const stored = getStoredConfig();
+  if (stored.apiKey && stored.apiKey.trim()) {
+    return stored.apiKey.trim();
+  }
+  return "";
+}
+function resolveApiUrl(cliUrl) {
+  if (cliUrl && cliUrl.trim()) {
+    return cliUrl.trim().replace(/\/+$/, "");
+  }
+  const envUrl = process.env.TEIN_API_URL;
+  if (envUrl && envUrl.trim()) {
+    return envUrl.trim().replace(/\/+$/, "");
+  }
+  const stored = getStoredConfig();
+  if (stored.apiUrl && stored.apiUrl.trim()) {
+    return stored.apiUrl.trim().replace(/\/+$/, "");
+  }
+  return "https://api.tein.ai";
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+// src/mcp/registry.ts
+var MCP_MODELS = {
+  "seedance-2-5": {
+    slug: "seedance-2-5",
+    name: "Seedance 2.5",
+    category: "Video",
+    kind: "Text-to-Video",
+    vendor: "ByteDance",
+    description: "ByteDance's flagship video model \u2014 cinematic motion, native audio, director-level camera control.",
+    priceFormatted: "$0.1284/sec",
+    unit: "/sec",
+    primaryToolName: "generate_video",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Text prompt describing the desired video scene, actions, camera angles, lighting, and style."
+      },
+      {
+        name: "mode",
+        type: "select",
+        default: "text_to_video",
+        options: [
+          "text_to_video",
+          "first_n_last_frames",
+          "multi_reference",
+          "edit",
+          "extend",
+          "multi_frame",
+          "lipsyncing",
+          "voice_clone",
+          "ugc"
+        ],
+        description: "Generation mode for Seedance 2.5."
+      },
+      {
+        name: "duration",
+        type: "slider",
+        default: 5,
+        min: 4,
+        max: 30,
+        description: "Video length in seconds (4 to 30)."
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "720p",
+        options: ["720p", "1080p", "4k"],
+        description: "Output video resolution."
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "16:9",
+        options: ["21:9", "16:9", "4:3", "1:1", "3:4", "9:16", "adaptive"],
+        description: "Aspect ratio of the video."
+      },
+      {
+        name: "bitrate_mode",
+        type: "select",
+        default: "standard",
+        options: ["standard", "high"],
+        description: "Bitrate quality setting."
+      },
+      {
+        name: "generate_audio",
+        type: "boolean",
+        default: true,
+        description: "Whether to generate synchronized native audio and sound effects."
+      },
+      {
+        name: "images",
+        type: "string[]",
+        description: "Array of public HTTP/HTTPS URLs for reference images (up to 30)."
+      },
+      {
+        name: "videos",
+        type: "string[]",
+        description: "Array of reference video URLs (up to 10; combined duration < 30s)."
+      },
+      {
+        name: "audios",
+        type: "string[]",
+        description: "Array of reference audio URLs (up to 10; combined duration < 30s)."
+      },
+      {
+        name: "first_frame_image",
+        type: "string",
+        description: "URL of image for first frame (for image-to-video / first_n_last_frames)."
+      },
+      {
+        name: "last_frame_image",
+        type: "string",
+        description: "URL of image for last frame (for first_n_last_frames)."
+      },
+      {
+        name: "lipsyncing_audio",
+        type: "string",
+        description: "Audio URL for lipsyncing or voice clone."
+      },
+      {
+        name: "pass_faces",
+        type: "boolean",
+        default: false,
+        description: "Preserve facial likeness from reference images."
+      },
+      {
+        name: "full_access",
+        type: "boolean",
+        default: false,
+        description: "Enable when generation involves human faces."
+      },
+      {
+        name: "is_uncensored",
+        type: "boolean",
+        default: false,
+        description: "Enable for uncensored / artistic generation."
+      }
+    ]
+  },
+  "seedance-2": {
+    slug: "seedance-2",
+    name: "Seedance 2.0",
+    category: "Video",
+    kind: "Text-to-Video",
+    vendor: "ByteDance",
+    description: "Generation-two text-to-video with real-world physics and 1080p native output.",
+    priceFormatted: "$0.0768/sec",
+    unit: "/sec",
+    primaryToolName: "generate_video",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Text prompt describing the desired video."
+      },
+      {
+        name: "quality",
+        type: "select",
+        default: "standard",
+        options: ["standard", "fast", "mini"],
+        description: "Quality tier."
+      },
+      {
+        name: "mode",
+        type: "select",
+        default: "text_to_video",
+        options: [
+          "text_to_video",
+          "first_n_last_frames",
+          "multi_reference",
+          "edit",
+          "extend",
+          "multi_frame",
+          "lipsyncing",
+          "voice_clone",
+          "ugc"
+        ]
+      },
+      {
+        name: "duration",
+        type: "slider",
+        default: 5,
+        min: 4,
+        max: 15,
+        description: "Duration in seconds (4 to 15)."
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "720p",
+        options: ["720p", "1080p"]
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "16:9",
+        options: ["21:9", "16:9", "4:3", "1:1", "3:4", "9:16", "adaptive"]
+      },
+      {
+        name: "generate_audio",
+        type: "boolean",
+        default: false
+      },
+      {
+        name: "images",
+        type: "string[]",
+        description: "Reference image URLs (up to 9)."
+      },
+      {
+        name: "first_frame_image",
+        type: "string",
+        description: "Starting frame image URL."
+      },
+      {
+        name: "last_frame_image",
+        type: "string",
+        description: "End frame image URL."
+      }
+    ]
+  },
+  "seedance-2-mini": {
+    slug: "seedance-2-mini",
+    name: "Seedance 2.0 Mini",
+    category: "Video",
+    kind: "Text-to-Video",
+    vendor: "ByteDance",
+    description: "Fast, cost-efficient variant of Seedance 2.0 for rapid prototyping.",
+    priceFormatted: "$0.0384/sec",
+    unit: "/sec",
+    primaryToolName: "generate_video",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Prompt describing the video."
+      },
+      {
+        name: "duration",
+        type: "slider",
+        default: 5,
+        min: 4,
+        max: 15
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "720p",
+        options: ["720p", "1080p"]
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "16:9",
+        options: ["21:9", "16:9", "4:3", "1:1", "3:4", "9:16", "adaptive"]
+      },
+      {
+        name: "first_frame_image",
+        type: "string",
+        description: "Start frame image URL."
+      }
+    ]
+  },
+  "wan-3-0": {
+    slug: "wan-3-0",
+    name: "Wan 3.0",
+    category: "Video",
+    kind: "Text-to-Video",
+    vendor: "Alibaba",
+    description: "Alibaba's flagship open video model with exceptional text rendering and complex motion.",
+    priceFormatted: "$0.048/sec",
+    unit: "/sec",
+    primaryToolName: "generate_video",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Detailed description of the scene and motion."
+      },
+      {
+        name: "mode",
+        type: "select",
+        default: "text_to_video",
+        options: ["text_to_video", "image_to_video"]
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "16:9",
+        options: ["16:9", "9:16", "1:1", "4:3", "3:4"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "720p",
+        options: ["720p", "1080p"]
+      },
+      {
+        name: "duration",
+        type: "number",
+        default: 5,
+        description: "Video duration in seconds (5)."
+      },
+      {
+        name: "image_url",
+        type: "string",
+        description: "Image URL for image_to_video mode."
+      },
+      {
+        name: "negative_prompt",
+        type: "string",
+        description: "Elements to avoid in video."
+      },
+      {
+        name: "seed",
+        type: "number",
+        description: "Random seed for reproducible outputs."
+      }
+    ]
+  },
+  "wan-3-0-prime": {
+    slug: "wan-3-0-prime",
+    name: "Wan 3.0 Prime",
+    category: "Video",
+    kind: "Text-to-Video",
+    vendor: "Alibaba",
+    description: "Ultra high-fidelity Wan 3.0 with higher compute budget and refined textures.",
+    priceFormatted: "$0.072/sec",
+    unit: "/sec",
+    primaryToolName: "generate_video",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Detailed description of the scene and motion."
+      },
+      {
+        name: "mode",
+        type: "select",
+        default: "text_to_video",
+        options: ["text_to_video", "image_to_video"]
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "16:9",
+        options: ["16:9", "9:16", "1:1", "4:3", "3:4"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "1080p",
+        options: ["720p", "1080p"]
+      },
+      {
+        name: "image_url",
+        type: "string",
+        description: "Image URL for image_to_video mode."
+      }
+    ]
+  },
+  "happy-horse-1-1": {
+    slug: "happy-horse-1-1",
+    name: "Happy Horse 1.1",
+    category: "Video",
+    kind: "Text-to-Video",
+    vendor: "Happy Horse",
+    description: "High dynamic range video generation with ultra smooth frame transitions.",
+    priceFormatted: "$0.04/sec",
+    unit: "/sec",
+    primaryToolName: "generate_video",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Text prompt."
+      },
+      {
+        name: "mode",
+        type: "select",
+        default: "text_to_video",
+        options: ["text_to_video", "first_n_last_frames"]
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "16:9",
+        options: ["16:9", "9:16", "1:1", "4:3", "3:4"]
+      },
+      {
+        name: "duration",
+        type: "select",
+        default: "5",
+        options: ["5", "10"]
+      },
+      {
+        name: "first_frame_image",
+        type: "string",
+        description: "First frame image URL."
+      },
+      {
+        name: "last_frame_image",
+        type: "string",
+        description: "Last frame image URL."
+      }
+    ]
+  },
+  "happy-horse-1-0": {
+    slug: "happy-horse-1-0",
+    name: "Happy Horse 1.0",
+    category: "Video",
+    kind: "Text-to-Video",
+    vendor: "Happy Horse",
+    description: "Fast, high-fidelity video generation.",
+    priceFormatted: "$0.03/sec",
+    unit: "/sec",
+    primaryToolName: "generate_video",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "16:9",
+        options: ["16:9", "9:16", "1:1", "4:3", "3:4"]
+      },
+      {
+        name: "duration",
+        type: "select",
+        default: "5",
+        options: ["5", "10"]
+      },
+      {
+        name: "first_frame_image",
+        type: "string"
+      }
+    ]
+  },
+  "minimax-h3": {
+    slug: "minimax-h3",
+    name: "Hailuo H3 (MiniMax)",
+    category: "Video",
+    kind: "Text-to-Video",
+    vendor: "MiniMax",
+    description: "MiniMax Hailuo video generation with cinematic camera movement and physics.",
+    priceFormatted: "$0.06/sec",
+    unit: "/sec",
+    primaryToolName: "generate_video",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Prompt describing the video scene."
+      },
+      {
+        name: "mode",
+        type: "select",
+        default: "text_to_video",
+        options: ["text_to_video", "image_to_video"]
+      },
+      {
+        name: "image_url",
+        type: "string",
+        description: "Input image URL for image-to-video."
+      },
+      {
+        name: "duration",
+        type: "select",
+        default: "6",
+        options: ["6", "10"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "720p",
+        options: ["720p", "1080p"]
+      }
+    ]
+  },
+  // Image Models
+  "seedream-5-pro": {
+    slug: "seedream-5-pro",
+    name: "Seedream 5.0 Pro",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "ByteDance",
+    description: "ByteDance flagship photorealistic image generation, graphic design, and 3D mesh decomposition.",
+    priceFormatted: "$0.018/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Detailed description of the image to generate."
+      },
+      {
+        name: "mode",
+        type: "select",
+        default: "text_to_image",
+        options: ["text_to_image", "image_to_image", "layer_decomposition", "text_to_3d"],
+        description: "Image generation or 3D / layer mode."
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "1:1",
+        options: ["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21", "3:2", "2:3", "auto"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "2K",
+        options: ["1K", "2K", "4K"]
+      },
+      {
+        name: "quality",
+        type: "select",
+        default: "standard",
+        options: ["standard", "high"]
+      },
+      {
+        name: "images",
+        type: "string[]",
+        description: "Input image URLs for image_to_image or layer editing."
+      },
+      {
+        name: "is_uncensored",
+        type: "boolean",
+        default: false
+      }
+    ]
+  },
+  "seedream-5-lite": {
+    slug: "seedream-5-lite",
+    name: "Seedream 5.0 Lite",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "ByteDance",
+    description: "Ultra-fast, budget-friendly Seedream image generation.",
+    priceFormatted: "$0.009/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "1:1",
+        options: ["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21", "3:2", "2:3", "auto"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "1K",
+        options: ["1K", "2K"]
+      },
+      {
+        name: "images",
+        type: "string[]"
+      }
+    ]
+  },
+  "gpt-image-2": {
+    slug: "gpt-image-2",
+    name: "GPT Image 2",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "OpenAI",
+    description: "Precision image generation with accurate typography, prompt following, and multi-image editing.",
+    priceFormatted: "$0.016/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Image prompt text. Supports complex composition and text instructions."
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "1:1",
+        options: [
+          "1:1",
+          "1:2",
+          "2:1",
+          "2:3",
+          "3:2",
+          "3:4",
+          "4:3",
+          "4:5",
+          "5:4",
+          "9:16",
+          "16:9",
+          "21:9",
+          "9:21",
+          "auto"
+        ]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "1K",
+        options: ["1K", "2K"]
+      },
+      {
+        name: "quality",
+        type: "select",
+        default: "auto",
+        options: ["auto", "low", "medium", "high"]
+      },
+      {
+        name: "input_images",
+        type: "string[]",
+        description: "Image URLs to modify or use as reference."
+      },
+      {
+        name: "is_uncensored",
+        type: "boolean",
+        default: false
+      }
+    ]
+  },
+  "gpt-image-2.5-flare": {
+    slug: "gpt-image-2.5-flare",
+    name: "GPT Image 2.5 Flare",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "OpenAI",
+    description: "Enhanced color vibrancy, lens effects, and studio lighting control.",
+    priceFormatted: "$0.022/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "16:9",
+        options: ["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "auto"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "2K",
+        options: ["1K", "2K"]
+      }
+    ]
+  },
+  "gpt-image-2.5-sunburst": {
+    slug: "gpt-image-2.5-sunburst",
+    name: "GPT Image 2.5 Sunburst",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "OpenAI",
+    description: "High-contrast cinematic photography and art render engine.",
+    priceFormatted: "$0.024/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "16:9",
+        options: ["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "auto"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "2K",
+        options: ["1K", "2K"]
+      }
+    ]
+  },
+  "grok-imagine-2": {
+    slug: "grok-imagine-2",
+    name: "Grok Imagine 2",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "xAI",
+    description: "xAI's fast, uncensored creative image generation engine.",
+    priceFormatted: "$0.012/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Text prompt."
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "1:1",
+        options: ["1:1", "16:9", "9:16", "4:3", "3:4", "2:3", "3:2"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "1K",
+        options: ["1K", "2K"]
+      },
+      {
+        name: "is_uncensored",
+        type: "boolean",
+        default: false
+      }
+    ]
+  },
+  "nano-banana-2": {
+    slug: "nano-banana-2",
+    name: "Nano Banana 2",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "Nano",
+    description: "Compact high-speed image generator tuned for product shots and digital art.",
+    priceFormatted: "$0.008/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "1:1",
+        options: ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "21:9"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "1K",
+        options: ["1K", "2K"]
+      }
+    ]
+  },
+  "nano-banana-2-lite": {
+    slug: "nano-banana-2-lite",
+    name: "Nano Banana 2 Lite",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "Nano",
+    description: "Ultra fast sub-second image rendering for thumbnails and concepts.",
+    priceFormatted: "$0.004/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "1:1",
+        options: ["1:1", "16:9", "9:16", "4:3", "3:4"]
+      }
+    ]
+  },
+  "nano-banana-pro": {
+    slug: "nano-banana-pro",
+    name: "Nano Banana Pro",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "Nano",
+    description: "High-res studio rendering with granular lighting controls.",
+    priceFormatted: "$0.014/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "1:1",
+        options: ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "21:9"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "2K",
+        options: ["1K", "2K"]
+      }
+    ]
+  },
+  "seed-2-1-turbo": {
+    slug: "seed-2-1-turbo",
+    name: "Seed 2.1 Turbo",
+    category: "Image",
+    kind: "Text-to-Image",
+    vendor: "ByteDance",
+    description: "High-speed image generation with low latency and rich detail.",
+    priceFormatted: "$0.006/img",
+    unit: "/img",
+    primaryToolName: "generate_image",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "aspect_ratio",
+        type: "select",
+        default: "1:1",
+        options: ["1:1", "16:9", "9:16", "4:3", "3:4"]
+      },
+      {
+        name: "resolution",
+        type: "select",
+        default: "1K",
+        options: ["1K", "2K"]
+      }
+    ]
+  },
+  // LLM / Reasoning
+  "gpt-6-astra": {
+    slug: "gpt-6-astra",
+    name: "GPT-6 Astra",
+    category: "Text",
+    kind: "Reasoning (LLM)",
+    vendor: "Tein / Frontier",
+    description: "Frontier reasoning model with deep step-by-step logic, code synthesis, and analytical capabilities.",
+    priceFormatted: "$0.40/M in \xB7 $1.60/M out",
+    unit: "/M tokens",
+    primaryToolName: "run_task",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "The user query, instruction, or reasoning task."
+      },
+      {
+        name: "system_prompt",
+        type: "string",
+        description: "Optional system instructions/persona."
+      },
+      {
+        name: "temperature",
+        type: "slider",
+        default: 0.7,
+        min: 0,
+        max: 2,
+        description: "Sampling temperature."
+      },
+      {
+        name: "max_tokens",
+        type: "number",
+        default: 4096,
+        min: 1,
+        max: 65536,
+        description: "Maximum tokens to generate."
+      }
+    ]
+  },
+  "gemini-3-8-flash": {
+    slug: "gemini-3-8-flash",
+    name: "Gemini 3.8 Flash",
+    category: "Text",
+    kind: "Reasoning (LLM)",
+    vendor: "Google",
+    description: "Google's ultra-fast multimodal reasoning model with massive context capabilities.",
+    priceFormatted: "$0.08/M in \xB7 $0.32/M out",
+    unit: "/M tokens",
+    primaryToolName: "run_task",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "system_prompt",
+        type: "string"
+      },
+      {
+        name: "temperature",
+        type: "slider",
+        default: 0.7,
+        min: 0,
+        max: 2
+      },
+      {
+        name: "max_tokens",
+        type: "number",
+        default: 4096
+      }
+    ]
+  },
+  "gemini-3-7-flash": {
+    slug: "gemini-3-7-flash",
+    name: "Gemini 3.7 Flash",
+    category: "Text",
+    kind: "Reasoning (LLM)",
+    vendor: "Google",
+    description: "Hybrid reasoning and instant response model with native tool calling.",
+    priceFormatted: "$0.07/M in \xB7 $0.28/M out",
+    unit: "/M tokens",
+    primaryToolName: "run_task",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "system_prompt",
+        type: "string"
+      },
+      {
+        name: "temperature",
+        type: "slider",
+        default: 0.7,
+        min: 0,
+        max: 2
+      }
+    ]
+  },
+  "gemini-3-1-pro-preview": {
+    slug: "gemini-3-1-pro-preview",
+    name: "Gemini 3.1 Pro Preview",
+    category: "Text",
+    kind: "Reasoning (LLM)",
+    vendor: "Google",
+    description: "Frontier code and logic reasoning preview model.",
+    priceFormatted: "$0.30/M in \xB7 $1.20/M out",
+    unit: "/M tokens",
+    primaryToolName: "run_task",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "system_prompt",
+        type: "string"
+      }
+    ]
+  },
+  "qwen-3": {
+    slug: "qwen-3",
+    name: "Qwen 3",
+    category: "Text",
+    kind: "Reasoning (LLM)",
+    vendor: "Alibaba",
+    description: "High-capability multilingual reasoning and agent model.",
+    priceFormatted: "$0.15/M in \xB7 $0.60/M out",
+    unit: "/M tokens",
+    primaryToolName: "run_task",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "system_prompt",
+        type: "string"
+      }
+    ]
+  },
+  "qwen-3-pro": {
+    slug: "qwen-3-pro",
+    name: "Qwen 3 Pro",
+    category: "Text",
+    kind: "Reasoning (LLM)",
+    vendor: "Alibaba",
+    description: "Deep reasoning and complex coding model with mathematical rigor.",
+    priceFormatted: "$0.35/M in \xB7 $1.40/M out",
+    unit: "/M tokens",
+    primaryToolName: "run_task",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true
+      },
+      {
+        name: "system_prompt",
+        type: "string"
+      }
+    ]
+  },
+  // Audio / TTS
+  "seed-audio-1-0": {
+    slug: "seed-audio-1-0",
+    name: "Seed Audio 1.0",
+    category: "Audio",
+    kind: "Text-to-Audio",
+    vendor: "ByteDance",
+    description: "Natural emotive voice cloning, studio TTS, and multi-speaker speech synthesis.",
+    priceFormatted: "$0.002/sec",
+    unit: "/sec",
+    primaryToolName: "generate_audio",
+    parameters: [
+      {
+        name: "prompt",
+        type: "string",
+        required: true,
+        description: "Text script to speak or audio sound effect description."
+      },
+      {
+        name: "speaker",
+        type: "select",
+        default: "en_female_warm",
+        options: [
+          "en_female_warm",
+          "en_male_deep",
+          "en_female_energetic",
+          "en_male_narrator",
+          "zh_female_natural",
+          "zh_male_news"
+        ],
+        description: "Voice persona / speaker ID."
+      },
+      {
+        name: "format",
+        type: "select",
+        default: "wav",
+        options: ["wav", "mp3", "pcm", "ogg_opus"],
+        description: "Output audio format."
+      },
+      {
+        name: "sample_rate",
+        type: "select",
+        default: "24000",
+        options: ["8000", "16000", "24000", "32000", "44100", "48000"]
+      },
+      {
+        name: "speech_rate",
+        type: "slider",
+        default: 0,
+        min: -50,
+        max: 100,
+        description: "Speech speed (-50 is 0.5x, 100 is 2.0x)."
+      },
+      {
+        name: "loudness_rate",
+        type: "slider",
+        default: 0,
+        min: -50,
+        max: 100,
+        description: "Loudness/volume (-50 to 100)."
+      },
+      {
+        name: "pitch_rate",
+        type: "slider",
+        default: 0,
+        min: -12,
+        max: 12,
+        description: "Voice pitch offset (-12 to 12)."
+      },
+      {
+        name: "enable_subtitle",
+        type: "boolean",
+        default: false,
+        description: "Return word-level timestamps."
+      }
+    ]
+  }
+};
+function getMcpModel(slug) {
+  return MCP_MODELS[slug] ?? null;
+}
+function listMcpModels() {
+  return Object.values(MCP_MODELS);
+}
+
+// src/cli/commands/run.ts
+function parseCliArgs(args) {
+  const options = {};
+  const flags = /* @__PURE__ */ new Set();
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (key.includes("=")) {
+        const [k, v] = key.split("=", 2);
+        options[k.replace(/-/g, "_")] = v;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        const val = args[i + 1];
+        if (val === "true") options[key.replace(/-/g, "_")] = true;
+        else if (val === "false") options[key.replace(/-/g, "_")] = false;
+        else if (/^-?\d+(\.\d+)?$/.test(val)) options[key.replace(/-/g, "_")] = Number(val);
+        else options[key.replace(/-/g, "_")] = val;
+        i++;
+      } else {
+        options[key.replace(/-/g, "_")] = true;
+        flags.add(key);
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const shortKey = arg[1];
+      const map = {
+        p: "prompt",
+        o: "output",
+        d: "duration",
+        r: "resolution",
+        q: "quality",
+        s: "speaker",
+        j: "json",
+        h: "help",
+        v: "version"
+      };
+      const longKey = map[shortKey] || shortKey;
+      if (shortKey === "j" || shortKey === "h" || shortKey === "v") {
+        options[longKey] = true;
+        flags.add(longKey);
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        options[longKey] = args[i + 1];
+        i++;
+      } else {
+        options[longKey] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return {
+    command: positional[0] || "",
+    subcommand: positional[1],
+    modelSlug: positional[1] || positional[0],
+    options,
+    flags
+  };
+}
+async function runCommand(modelSlug, options) {
+  const apiKey = resolveApiKey(typeof options.api_key === "string" ? options.api_key : void 0);
+  const apiUrl = resolveApiUrl(typeof options.api_url === "string" ? options.api_url : void 0);
+  if (!apiKey) {
+    process.stderr.write(`${c.red("Error:")} Authentication required.
+`);
+    process.stderr.write(`Please run ${c.cyan("tein auth login")} or set ${c.cyan("TEIN_API_KEY")} environment variable.
+`);
+    process.exit(1);
+  }
+  if (!modelSlug) {
+    process.stderr.write(`${c.red("Error:")} Missing model slug.
+`);
+    process.stderr.write(`Usage: ${c.cyan('tein run <model-slug> --prompt "..."')}
+`);
+    process.stderr.write(`Run ${c.cyan("tein models")} to list all available models.
+`);
+    process.exit(1);
+  }
+  const modelMeta = getMcpModel(modelSlug);
+  const isJson = Boolean(options.json);
+  const isAsync = Boolean(options.async || options.no_wait);
+  const outputFile = typeof options.output === "string" ? options.output : void 0;
+  const parameters = { ...options };
+  delete parameters.json;
+  delete parameters.async;
+  delete parameters.no_wait;
+  delete parameters.output;
+  delete parameters.api_key;
+  delete parameters.api_url;
+  if (modelMeta?.parameters) {
+    for (const param of modelMeta.parameters) {
+      if (param.default !== void 0 && parameters[param.name] === void 0) {
+        parameters[param.name] = param.default;
+      }
+    }
+  }
+  if (typeof parameters.images === "string") {
+    parameters.images = [parameters.images];
+  }
+  if (typeof parameters.image === "string" && !parameters.images) {
+    parameters.images = [parameters.image];
+    delete parameters.image;
+  }
+  if (parameters.image_url && !parameters.first_frame_image && (modelSlug.startsWith("seedance") || modelSlug.startsWith("happy-horse"))) {
+    parameters.first_frame_image = parameters.image_url;
+  }
+  const client = new TeinApiClient(apiKey, apiUrl);
+  const spinner = new Spinner(`Submitting task for ${c.bold(modelSlug)}...`);
+  if (!isJson) {
+    spinner.start();
+  }
+  let job;
+  try {
+    job = await client.runJob(modelSlug, parameters);
+  } catch (err) {
+    if (!isJson) spinner.fail(`Failed to start generation: ${err instanceof Error ? err.message : err}`);
+    else process.stdout.write(JSON.stringify({ error: String(err) }, null, 2) + "\n");
+    process.exit(1);
+  }
+  if (isAsync) {
+    if (!isJson) {
+      spinner.succeed(`Queued successfully! Request ID: ${c.bold(job.request_id)}`);
+      process.stdout.write(`Check status anytime with: ${c.cyan(`tein status ${job.request_id}`)}
+`);
+    } else {
+      process.stdout.write(JSON.stringify(job, null, 2) + "\n");
+    }
+    return;
+  }
+  const startTime = Date.now();
+  let pollInterval = 1500;
+  while (job.status === "processing") {
+    const elapsed = Math.round((Date.now() - startTime) / 1e3);
+    if (!isJson) {
+      spinner.update(`Rendering ${c.bold(modelSlug)} (${elapsed}s elapsed)... [ID: ${job.request_id}]`);
+    }
+    await new Promise((r) => setTimeout(r, pollInterval));
+    try {
+      job = await client.getStatus(job.request_id);
+    } catch (err) {
+    }
+  }
+  if (job.status === "failed") {
+    if (!isJson) spinner.fail(`Generation failed: ${job.error || "Unknown error"}`);
+    else process.stdout.write(JSON.stringify(job, null, 2) + "\n");
+    process.exit(1);
+  }
+  if (!isJson) {
+    spinner.succeed(`Generation completed for ${c.bold(modelMeta?.name || modelSlug)}!`);
+  }
+  if (isJson) {
+    process.stdout.write(JSON.stringify(job, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write("\n");
+  process.stdout.write(`  ${c.bold("Status:")}     ${c.green("Succeeded")}
+`);
+  process.stdout.write(`  ${c.bold("Request ID:")} ${job.request_id}
+`);
+  if (job.usage?.cost !== void 0) {
+    process.stdout.write(`  ${c.bold("Cost:")}       ${job.usage.cost.toFixed(4)} credits
+`);
+  }
+  if (job.output && job.output.length > 0) {
+    process.stdout.write(`
+${c.bold("Outputs:")}
+`);
+    for (let idx = 0; idx < job.output.length; idx++) {
+      const item = job.output[idx];
+      if (item.url) {
+        process.stdout.write(`  [${item.type.toUpperCase()}] ${c.cyan(c.underline(item.url))}
+`);
+        if (outputFile) {
+          const dlSpinner = new Spinner(`Downloading output to ${outputFile}...`).start();
+          try {
+            await client.downloadOutput(item.url, import_node_path3.default.resolve(process.cwd(), outputFile));
+            dlSpinner.succeed(`Saved to ${c.bold(outputFile)}`);
+          } catch (dlErr) {
+            dlSpinner.fail(`Failed to download: ${dlErr instanceof Error ? dlErr.message : dlErr}`);
+          }
+        }
+      } else if (item.text) {
+        process.stdout.write(`
+${item.text}
+`);
+      }
+    }
+  }
+  process.stdout.write("\n");
+}
+
+// src/cli/commands/auth.ts
+var import_node_readline = __toESM(require("node:readline"));
+function promptLine(promptText) {
+  const rl = import_node_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(promptText, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function authCommand(subcommand, argValue) {
+  switch (subcommand) {
+    case "login":
+    case "set-key": {
+      let key = argValue?.trim() || "";
+      if (!key) {
+        process.stdout.write(`
+${c.bold("Tein AI Authentication")}
+`);
+        process.stdout.write(`Get your API key at: ${c.cyan("https://tein.ai/dashboard/keys")}
+
+`);
+        key = await promptLine("Enter your Tein API Key (sk_live_...): ");
+      }
+      if (!key.startsWith("sk_live_") && !key.startsWith("sk_test_")) {
+        process.stderr.write(
+          `${c.red("Error:")} Invalid key format. Tein API keys start with 'sk_live_' or 'sk_test_'.
+`
+        );
+        process.exit(1);
+      }
+      saveStoredConfig({ apiKey: key });
+      process.stdout.write(`
+${c.green("\u2714")} API key saved to ${c.dim(getConfigPath())}
+`);
+      process.stdout.write(`You can now run models directly using: ${c.cyan('tein run <model-slug> --prompt "..."')}
+
+`);
+      break;
+    }
+    case "logout": {
+      saveStoredConfig({ apiKey: "" });
+      process.stdout.write(`${c.green("\u2714")} Logged out. Stored API key has been cleared.
+`);
+      break;
+    }
+    case "status":
+    case "whoami":
+    default: {
+      const apiKey = resolveApiKey();
+      const apiUrl = resolveApiUrl();
+      const config = getStoredConfig();
+      process.stdout.write(`
+${c.bold("Tein AI CLI Configuration")}
+`);
+      process.stdout.write(`  Config file: ${c.dim(getConfigPath())}
+`);
+      process.stdout.write(`  API URL:     ${c.cyan(apiUrl)}
+`);
+      if (!apiKey) {
+        process.stdout.write(`  API Key:     ${c.red("Not configured")}
+
+`);
+        process.stdout.write(`Run ${c.cyan("tein auth login")} or set ${c.cyan("TEIN_API_KEY")} environment variable.
+
+`);
+      } else {
+        const masked = `${apiKey.slice(0, 10)}...${apiKey.slice(-4)}`;
+        process.stdout.write(`  API Key:     ${c.green(masked)} (${apiKey.startsWith("sk_live_") ? "Live Key" : "Test Key"})
+
+`);
+      }
+      break;
+    }
+  }
+}
+
+// src/cli/commands/models.ts
+function listModelsCommand(categoryFilter) {
+  let models = listMcpModels();
+  if (categoryFilter) {
+    const filterLower = categoryFilter.toLowerCase();
+    models = models.filter(
+      (m) => m.category.toLowerCase() === filterLower || m.kind.toLowerCase().includes(filterLower) || m.slug.toLowerCase().includes(filterLower)
+    );
+  }
+  process.stdout.write(`
+${c.bold("Tein AI Models Catalog")} (${models.length} available)
+`);
+  process.stdout.write(`${c.dim("Run `tein info <model-slug>` to see detailed parameters and options.")}
+
+`);
+  const categoryGroups = {};
+  for (const model of models) {
+    const cat = model.category;
+    if (!categoryGroups[cat]) categoryGroups[cat] = [];
+    categoryGroups[cat].push(model);
+  }
+  const categoryOrder = ["Video", "Image", "Text", "Audio", "3D"];
+  for (const cat of categoryOrder) {
+    const list = categoryGroups[cat];
+    if (!list || list.length === 0) continue;
+    process.stdout.write(`${c.bold(c.cyan(`\u2500\u2500 ${cat} Models \u2500\u2500`))}
+`);
+    for (const m of list) {
+      const slugPadded = m.slug.padEnd(24);
+      const namePadded = m.name.padEnd(22);
+      const pricePadded = m.priceFormatted.padEnd(22);
+      process.stdout.write(
+        `  ${c.bold(slugPadded)} ${c.gray(namePadded)} ${c.green(pricePadded)} ${c.dim(m.vendor)}
+`
+      );
+    }
+    process.stdout.write("\n");
+  }
+  process.stdout.write(
+    `${c.dim("Tip:")} Generate directly with ${c.cyan('tein run <model-slug> --prompt "..."')}
+
+`
+  );
+}
+function modelInfoCommand(slug) {
+  const model = getMcpModel(slug);
+  if (!model) {
+    process.stderr.write(`${c.red("Error:")} Model "${slug}" not found in Tein AI registry.
+`);
+    process.stderr.write(`Run ${c.cyan("tein models")} to see all available model slugs.
+`);
+    process.exit(1);
+  }
+  process.stdout.write(`
+${c.bold(c.cyan(model.name))} (${c.bold(model.slug)})
+`);
+  process.stdout.write(`  ${c.gray(model.description)}
+
+`);
+  process.stdout.write(`${c.bold("Metadata:")}
+`);
+  process.stdout.write(`  Category:    ${c.yellow(model.category)}
+`);
+  process.stdout.write(`  Kind:        ${model.kind}
+`);
+  process.stdout.write(`  Vendor:      ${model.vendor}
+`);
+  process.stdout.write(`  Pricing:     ${c.green(model.priceFormatted)}
+
+`);
+  process.stdout.write(`${c.bold("Parameters:")}
+`);
+  for (const param of model.parameters) {
+    const reqBadge = param.required ? c.red("(required)") : c.dim("(optional)");
+    const defaultVal = param.default !== void 0 ? c.dim(` [default: ${param.default}]`) : "";
+    process.stdout.write(
+      `  ${c.bold(`--${param.name.replace(/_/g, "-")}`)} ${c.yellow(`<${param.type}>`)} ${reqBadge}${defaultVal}
+`
+    );
+    if (param.description) {
+      process.stdout.write(`     ${c.gray(param.description)}
+`);
+    }
+    if (param.options && param.options.length > 0) {
+      process.stdout.write(`     Allowed values: ${c.dim(param.options.join(", "))}
+`);
+    }
+    if (param.min !== void 0 || param.max !== void 0) {
+      process.stdout.write(`     Range: ${param.min ?? ""} to ${param.max ?? ""}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  process.stdout.write(`${c.bold("Sample CLI Usage:")}
+`);
+  if (model.category === "Video") {
+    process.stdout.write(
+      `  ${c.cyan(`tein run ${model.slug} --prompt "Cinematic camera drone shot of a coastline" --aspect-ratio 16:9 --duration 5 -o output.mp4`)}
+
+`
+    );
+  } else if (model.category === "Image") {
+    process.stdout.write(
+      `  ${c.cyan(`tein run ${model.slug} --prompt "Cyberpunk city in the rain, 8k render" --aspect-ratio 16:9 -o output.png`)}
+
+`
+    );
+  } else if (model.category === "Audio") {
+    process.stdout.write(
+      `  ${c.cyan(`tein run ${model.slug} --prompt "Hello world from Tein AI" --speaker en_female_warm -o speech.wav`)}
+
+`
+    );
+  } else {
+    process.stdout.write(
+      `  ${c.cyan(`tein run ${model.slug} --prompt "Explain quantum computing in simple terms"`)}
+
+`
+    );
+  }
+}
+
+// src/cli/commands/status.ts
+var import_node_path4 = __toESM(require("node:path"));
+async function statusCommand(requestId, options) {
+  const apiKey = resolveApiKey(typeof options.api_key === "string" ? options.api_key : void 0);
+  const apiUrl = resolveApiUrl(typeof options.api_url === "string" ? options.api_url : void 0);
+  if (!apiKey) {
+    process.stderr.write(`${c.red("Error:")} Authentication required.
+`);
+    process.stderr.write(`Please run ${c.cyan("tein auth login")} or set ${c.cyan("TEIN_API_KEY")} environment variable.
+`);
+    process.exit(1);
+  }
+  if (!requestId) {
+    process.stderr.write(`${c.red("Error:")} Missing request ID.
+`);
+    process.stderr.write(`Usage: ${c.cyan("tein status <request-id> [--wait] [-o output.mp4]")}
+`);
+    process.exit(1);
+  }
+  const isJson = Boolean(options.json);
+  const shouldWait = Boolean(options.wait);
+  const outputFile = typeof options.output === "string" ? options.output : void 0;
+  const client = new TeinApiClient(apiKey, apiUrl);
+  const spinner = new Spinner(`Checking status of ${c.bold(requestId)}...`);
+  if (!isJson) spinner.start();
+  let job = await client.getStatus(requestId);
+  if (shouldWait && job.status === "processing") {
+    const startTime = Date.now();
+    while (job.status === "processing") {
+      const elapsed = Math.round((Date.now() - startTime) / 1e3);
+      if (!isJson) {
+        spinner.update(`Waiting for ${c.bold(job.model)} (${elapsed}s elapsed)...`);
+      }
+      await new Promise((r) => setTimeout(r, 1500));
+      try {
+        job = await client.getStatus(requestId);
+      } catch {
+      }
+    }
+  }
+  if (!isJson) {
+    if (job.status === "succeeded") {
+      spinner.succeed(`Task completed!`);
+    } else if (job.status === "failed") {
+      spinner.fail(`Task failed: ${job.error || "Unknown error"}`);
+    } else {
+      spinner.stop();
+    }
+  }
+  if (isJson) {
+    process.stdout.write(JSON.stringify(job, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write(`
+  ${c.bold("Model:")}      ${job.model}
+`);
+  process.stdout.write(`  ${c.bold("Status:")}     ${job.status === "succeeded" ? c.green(job.status) : job.status === "processing" ? c.yellow(job.status) : c.red(job.status)}
+`);
+  process.stdout.write(`  ${c.bold("Request ID:")} ${job.request_id}
+`);
+  if (job.output && job.output.length > 0) {
+    process.stdout.write(`
+${c.bold("Outputs:")}
+`);
+    for (const item of job.output) {
+      if (item.url) {
+        process.stdout.write(`  [${item.type.toUpperCase()}] ${c.cyan(c.underline(item.url))}
+`);
+        if (outputFile) {
+          const dlSpinner = new Spinner(`Downloading output to ${outputFile}...`).start();
+          try {
+            await client.downloadOutput(item.url, import_node_path4.default.resolve(process.cwd(), outputFile));
+            dlSpinner.succeed(`Saved to ${c.bold(outputFile)}`);
+          } catch (dlErr) {
+            dlSpinner.fail(`Failed to download: ${dlErr instanceof Error ? dlErr.message : dlErr}`);
+          }
+        }
+      } else if (item.text) {
+        process.stdout.write(`
+${item.text}
+`);
+      }
+    }
+  }
+  process.stdout.write("\n");
+}
+
+// src/cli/index.ts
+var CLI_VERSION = "1.0.0";
+function printHelp() {
+  process.stdout.write(`
+${c.bold(c.cyan("Tein AI CLI"))} - Official Command-Line Interface for Tein AI models
+
+${c.bold("USAGE:")}
+  ${c.cyan("tein")} <command> [arguments] [options]
+
+${c.bold("COMMANDS:")}
+  ${c.bold("auth")} <login|set-key|logout|status>   Manage Tein API key and authentication
+  ${c.bold("models")} [category]                     List all 25+ models (Video, Image, Audio, Text, 3D)
+  ${c.bold("info")} <model-slug>                     View parameter schemas, pricing, and options
+  ${c.bold("run")} <model-slug> [options]            Generate video, image, audio, or reasoning outputs
+  ${c.bold("status")} <request-id> [options]         Check generation progress and retrieve output files
+  ${c.bold("mcp")}                                   Launch stdio MCP server for Claude Desktop / Code
+
+${c.bold("GENERATION OPTIONS (for `tein run`):")}
+  ${c.cyan("-p, --prompt")} <text>          Text prompt for generation ${c.red("(required)")}
+  ${c.cyan("-o, --output")} <filepath>      Download output file locally (e.g. video.mp4, image.png)
+  ${c.cyan("--aspect-ratio")} <ratio>       Aspect ratio (16:9, 9:16, 1:1, 4:3, 21:9)
+  ${c.cyan("-d, --duration")} <seconds>     Video duration in seconds (4-30s depending on model)
+  ${c.cyan("-r, --resolution")} <res>       Resolution (720p, 1080p, 1K, 2K, 4K)
+  ${c.cyan("-q, --quality")} <quality>      Quality tier (standard, fast, mini, high)
+  ${c.cyan("-s, --speaker")} <speaker_id>   Voice speaker ID for audio TTS models
+  ${c.cyan("--image")} <url>                Input image URL for image-to-video or image-to-image
+  ${c.cyan("--generate-audio")}             Enable native synchronized audio (Seedance 2.5)
+  ${c.cyan("--async, --no-wait")}           Queue task and return request ID immediately
+  ${c.cyan("--json")}                       Output response in raw JSON format
+  ${c.cyan("--api-key")} <key>              Override API key for this request
+
+${c.bold("EXAMPLES:")}
+  ${c.dim("# 1. Authenticate with your Tein API key")}
+  ${c.cyan("tein auth login")}
+
+  ${c.dim("# 2. List all Video models")}
+  ${c.cyan("tein models video")}
+
+  ${c.dim("# 3. Generate a 16:9 cinematic image and download it")}
+  ${c.cyan('tein run gpt-image-2 --prompt "Neon Tokyo street in rain" --aspect-ratio 16:9 -o tokyo.png')}
+
+  ${c.dim("# 4. Generate a video using Seedance 2.5 with audio")}
+  ${c.cyan('tein run seedance-2-5 --prompt "Drone shot of ocean waves at sunrise" --duration 5 -o ocean.mp4')}
+
+  ${c.dim("# 5. Generate speech with Seed Audio 1.0")}
+  ${c.cyan('tein run seed-audio-1-0 --prompt "Welcome to Tein AI CLI" -o welcome.wav')}
+
+  ${c.dim("# 6. Run deep reasoning task with GPT-6 Astra")}
+  ${c.cyan('tein run gpt-6-astra --prompt "Write a TypeScript binary search tree implementation"')}
+
+`);
+}
+async function main() {
+  const rawArgs = process.argv.slice(2);
+  const parsed = parseCliArgs(rawArgs);
+  if (parsed.flags.has("help") || parsed.options.help || parsed.command === "help") {
+    printHelp();
+    return;
+  }
+  if (parsed.flags.has("version") || parsed.options.version || parsed.command === "version") {
+    process.stdout.write(`tein version ${CLI_VERSION}
+`);
+    return;
+  }
+  switch (parsed.command) {
+    case "auth": {
+      await authCommand(parsed.subcommand, parsed.options.key);
+      break;
+    }
+    case "models":
+    case "list": {
+      listModelsCommand(parsed.subcommand);
+      break;
+    }
+    case "info":
+    case "show": {
+      if (!parsed.subcommand) {
+        process.stderr.write(`${c.red("Error:")} Missing model slug.
+`);
+        process.stderr.write(`Usage: ${c.cyan("tein info <model-slug>")}
+`);
+        process.exit(1);
+      }
+      modelInfoCommand(parsed.subcommand);
+      break;
+    }
+    case "run":
+    case "generate": {
+      const modelSlug = parsed.subcommand || "";
+      await runCommand(modelSlug, parsed.options);
+      break;
+    }
+    case "status": {
+      const reqId = parsed.subcommand || "";
+      await statusCommand(reqId, parsed.options);
+      break;
+    }
+    case "mcp": {
+      const { spawn } = await import("node:child_process");
+      const cliPath = (await import("node:path")).join(__dirname, "../mcp/cli.js");
+      const child = spawn(process.execPath, [cliPath], {
+        stdio: "inherit",
+        env: process.env
+      });
+      child.on("exit", (code) => process.exit(code ?? 0));
+      break;
+    }
+    default: {
+      if (parsed.command && !parsed.command.startsWith("-")) {
+        await runCommand(parsed.command, parsed.options);
+        return;
+      }
+      printHelp();
+      break;
+    }
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`
+${c.red("Fatal error:")} ${err instanceof Error ? err.message : err}
+`);
+  process.exit(1);
+});