@doufunao123/asset-gateway 0.6.0 → 0.7.3

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command9 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/commands/auth.ts
 import { existsSync as existsSync2, unlinkSync } from "fs";
@@ -11,68 +11,13 @@ import { Command } from "commander";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
-
-// src/errors.ts
-var GatewayError = class extends Error {
-  code;
-  exitCode;
-  suggestion;
-  constructor(message, options) {
-    super(message);
-    this.name = "GatewayError";
-    this.code = options.code;
-    this.exitCode = options.exitCode ?? 1;
-    this.suggestion = options.suggestion;
-  }
-};
-function configError(message, suggestion) {
-  return new GatewayError(message, {
-    code: "CONFIG_ERROR",
-    exitCode: 1,
-    suggestion: suggestion ?? "Run asset-gateway auth set <token> to configure credentials"
-  });
-}
-function notFoundError(message) {
-  return new GatewayError(message, {
-    code: "NOT_FOUND",
-    exitCode: 1
-  });
-}
-function apiError(message, suggestion) {
-  return new GatewayError(message, {
-    code: "GATEWAY_API_ERROR",
-    exitCode: 3,
-    suggestion: suggestion ?? "Check if the gateway is running: asset-gateway provider health"
-  });
-}
-function httpClientError(message, suggestion) {
-  return new GatewayError(message, {
-    code: "HTTP_CLIENT_ERROR",
-    exitCode: 3,
-    suggestion: suggestion ?? "Check network connectivity to the gateway"
-  });
-}
-function internalError(message) {
-  return new GatewayError(message, {
-    code: "INTERNAL_ERROR",
-    exitCode: 2
-  });
-}
-function normalizeError(error2) {
-  if (error2 instanceof GatewayError) {
-    return error2;
-  }
-  if (error2 instanceof Error) {
-    return internalError(error2.message);
-  }
-  return internalError(String(error2));
-}
+import { AssetForgeError } from "@doufunao123/assetforge-sdk";
 
 // src/meta.ts
 var CLI_NAME = "asset-gateway";
-var CLI_VERSION = "0.6.0";
+var CLI_VERSION = "0.19.0";
 var CLI_DESCRIPTION = "Universal asset generation gateway CLI";
-var DEFAULT_GATEWAY_URL = "https://assets.xiaomao.chat";
+var DEFAULT_GATEWAY_URL = "https://asset.origingame.dev";
 
 // src/config.ts
 function configDir() {
@@ -94,8 +39,9 @@ function loadAuthConfig() {
     const parsed = JSON.parse(content);
     return { token: parsed.token, gateway_url: parsed.gateway_url };
   } catch (error2) {
-    throw configError(
-      `Failed to parse auth config at ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`
+    throw new AssetForgeError(
+      `Failed to parse auth config at ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`,
+      { code: "CONFIG_ERROR" }
     );
   }
 }
@@ -166,107 +112,8 @@ ${formatHuman(val, indent + 2)}`;
   }).join("\n");
 }
 
-// src/client.ts
-import { readFile } from "fs/promises";
-import { basename } from "path";
-var GatewayClient = class {
-  constructor(baseUrl, token) {
-    this.baseUrl = baseUrl;
-    this.token = token;
-  }
-  async get(path) {
-    return this.request("GET", path);
-  }
-  async post(path, body) {
-    return this.request("POST", path, { body });
-  }
-  async put(path, body) {
-    return this.request("PUT", path, { body });
-  }
-  async delete(path) {
-    return this.request("DELETE", path);
-  }
-  async uploadFile(filePath) {
-    let content;
-    try {
-      content = await readFile(filePath);
-    } catch (error2) {
-      throw configError(
-        `Failed to read file ${filePath}: ${error2 instanceof Error ? error2.message : String(error2)}`
-      );
-    }
-    const form = new FormData();
-    const arrayBuffer = content.buffer.slice(
-      content.byteOffset,
-      content.byteOffset + content.byteLength
-    );
-    form.append("file", new Blob([arrayBuffer]), basename(filePath));
-    return this.request("POST", "/api/assets/upload", { form });
-  }
-  async request(method, path, options = {}) {
-    const url = new URL(path, ensureTrailingSlash(this.baseUrl));
-    const headers = new Headers(options.headers);
-    if (this.token) {
-      headers.set("authorization", `Bearer ${this.token}`);
-    }
-    let body;
-    if (options.form) {
-      body = options.form;
-    } else if (options.body !== void 0) {
-      headers.set("content-type", "application/json");
-      body = JSON.stringify(options.body);
-    }
-    let response;
-    try {
-      response = await fetch(url, { method, headers, body });
-    } catch (error2) {
-      throw httpClientError(
-        error2 instanceof Error ? error2.message : String(error2)
-      );
-    }
-    const text = await response.text();
-    const payload = parseResponse(text);
-    if (!response.ok) {
-      const preview = typeof payload === "string" ? payload : JSON.stringify(payload);
-      if (response.status === 404) {
-        throw notFoundError(`HTTP 404 - ${truncate(preview, 512)}`);
-      }
-      throw apiError(`HTTP ${response.status} - ${truncate(preview, 512)}`);
-    }
-    if (isEnvelope(payload)) {
-      if (!payload.ok) {
-        const errMsg = typeof payload.error === "object" && payload.error !== null ? JSON.stringify(payload.error) : String(payload.error);
-        throw apiError(errMsg);
-      }
-      return payload.data;
-    }
-    return payload;
-  }
-};
-function isEnvelope(value) {
-  return typeof value === "object" && value !== null && "ok" in value;
-}
-function ensureTrailingSlash(url) {
-  return url.endsWith("/") ? url : `${url}/`;
-}
-function parseResponse(text) {
-  if (!text) {
-    return null;
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-function truncate(value, maxLength) {
-  if (value.length <= maxLength) {
-    return value;
-  }
-  return `${value.slice(0, maxLength)}...[truncated]`;
-}
-
 // src/commands/common.ts
+import { AssetForge, AssetForgeError as AssetForgeError2, toAssetForgeError } from "@doufunao123/assetforge-sdk";
 function getGlobalOptions(command) {
   return command.optsWithGlobals();
 }
@@ -275,13 +122,13 @@ function createContext(command, requireAuth = true) {
   const url = resolveGatewayUrl({ gatewayUrl: globals.gatewayUrl });
   const token = resolveToken({ token: globals.token });
   if (requireAuth && !token) {
-    throw configError(
+    throw new AssetForgeError2(
       "Authentication required. Use --token, set ASSET_GATEWAY_TOKEN, or run asset-gateway auth set <token>.",
-      "asset-gateway auth set <token>"
+      { code: "CONFIG_ERROR" }
     );
   }
   return {
-    client: new GatewayClient(url, token),
+    client: new AssetForge({ apiKey: token ?? "anonymous", baseUrl: url }),
     human: Boolean(globals.human),
     fields: globals.fields
   };
@@ -291,16 +138,40 @@ function printSuccess(commandName, data, ctx) {
   output(success(commandName, filtered), ctx.human);
 }
 function printError(commandName, err, human = false) {
-  const normalized = normalizeError(err);
+  const normalized = toAssetForgeError(err);
   output(
-    error(commandName, normalized.code, normalized.message, normalized.suggestion),
+    error(commandName, normalized.code, normalized.message, getSuggestion(normalized)),
     human
   );
-  process.exit(normalized.exitCode);
+  process.exit(getExitCode(normalized));
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function getSuggestion(error2) {
+  if (isRecord(error2.details) && typeof error2.details.suggestion === "string") {
+    return error2.details.suggestion;
+  }
+  if (error2.code === "CONFIG_ERROR") {
+    return "asset-gateway auth set <token>";
+  }
+  if (error2.code === "NETWORK_ERROR" || error2.code === "FETCH_UNAVAILABLE") {
+    return "Check network connectivity to the gateway";
+  }
+  if (error2.code === "API_ERROR") {
+    return "Check if the gateway is running: asset-gateway provider health";
+  }
+  return void 0;
+}
+function getExitCode(error2) {
+  if (error2.code === "INTERNAL_ERROR") {
+    return 2;
+  }
+  if (error2.status || error2.code === "API_ERROR" || error2.code === "NETWORK_ERROR") {
+    return 3;
+  }
+  return 1;
+}
 
 // src/commands/auth.ts
 function createAuthCommand() {
@@ -356,13 +227,17 @@ function mask(token) {
 
 // src/commands/describe.ts
 import { Command as Command2 } from "commander";
+
+// src/describe-schemas.ts
 var SCHEMAS = {
   auth: {
     description: "Credential management",
     subcommands: {
       set: {
         description: "Save token and gateway URL locally",
-        params: { token: { type: "string", required: true, description: "API token (agk_ prefix for admin, or any API key)" } }
+        params: {
+          token: { type: "string", required: true, description: "API token or admin token" }
+        }
       },
       status: { description: "Show current authentication status" },
       clear: { description: "Remove saved credentials" }
@@ -372,91 +247,327 @@ var SCHEMAS = {
     description: "Generate assets via the gateway",
     subcommands: {
       image: {
-        description: "Generate an image from a text prompt",
+        description: "Generate or edit an image",
         params: {
-          "--prompt": { type: "string", required: true, description: "Image description prompt" },
-          "--provider": { type: "string", required: false, description: "Provider to use" },
-          "--transparent": { type: "bool", default: false, description: "Request transparent background" },
-          "--model": { type: "string", required: false, description: "Model to use" },
-          "--size": { type: "string", required: false, description: "Image size (e.g. 1024x1024)" },
-          "--output-dir": { type: "string", default: ".", description: "Directory to save output" }
+          "--prompt": { type: "string", required: true, description: "Image prompt" },
+          "--provider": { type: "string", required: false },
+          "--transparent": { type: "bool", description: "Transparent background" },
+          "--model": { type: "string" },
+          "--size": { type: "string", description: 'e.g. "1024x1024"' },
+          "--input": { type: "string", description: "Image URL for editing" },
+          "--ref": { type: "string[]", description: "Reference image URLs (repeatable)" },
+          "--edit-mode": { type: "string", description: "edit | inpaint | restyle | expand" },
+          "--session": { type: "string", description: "Multi-turn session id" },
+          "--output-dir": { type: "string", default: "." }
         }
       },
       video: {
-        description: "Generate a video from a text prompt",
+        description: "Generate a video from text or an input image",
         params: {
-          "--prompt": { type: "string", required: true, description: "Video description prompt" },
-          "--provider": { type: "string", required: false, description: "Provider to use" },
-          "--output-dir": { type: "string", default: ".", description: "Directory to save output" }
+          "--prompt": { type: "string", required: true },
+          "--provider": { type: "string" },
+          "--input": { type: "string", description: "Image URL for I2V" },
+          "--output-dir": { type: "string", default: "." }
         }
       },
-      audio: {
-        description: "Generate audio from a text prompt",
+      batch: {
+        description: "Batch-generate assets with shared parameters and optional compose step",
         params: {
-          "--prompt": { type: "string", required: true, description: "Audio description prompt" },
-          "--type": { type: "string", required: false, description: "Audio type: bgm or sfx" },
-          "--duration": { type: "number", required: false, description: "Duration in seconds" },
-          "--output-dir": { type: "string", default: ".", description: "Directory to save output" }
+          "--prompt": { type: "string[]", required: true, description: "One prompt per frame" },
+          "--asset-type": { type: "string", default: "image" },
+          "--transparent": { type: "bool" },
+          "--size": { type: "string" },
+          "--ref": { type: "string[]" },
+          "--compose": { type: "string", description: "horizontal | vertical | grid" },
+          "--columns": { type: "number" },
+          "--frame-size": { type: "string", description: "e.g. 64x64" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      sfx: {
+        description: "Generate sound effects (impacts, footsteps, UI sounds, ambience)",
+        params: {
+          "--prompt": { type: "string", required: true },
+          "--duration": { type: "number", required: true, description: "Duration in seconds (1-5s for short SFX, 5-15s for ambience, max 30s)" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      music: {
+        description: "Generate music using the gateway music provider",
+        params: {
+          "--prompt": { type: "string", required: true },
+          "--duration": { type: "number", description: "Seconds" },
+          "--force-instrumental": { type: "bool", description: "Request instrumental output when supported" },
+          "--output-format": { type: "string", description: "Provider-specific output format override when supported" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      tts: {
+        description: "Text-to-speech via MiMo v2.5 TTS",
+        params: {
+          "--prompt": { type: "string", required: true },
+          "--voice": { type: "string", description: "MiMo prebuilt voice name (default: server config, usually Mia)" },
+          "--context": { type: "string", description: "Natural-language style or director instruction" },
+          "--output-dir": { type: "string", default: "." }
         }
       },
       model: {
-        description: "Generate a 3D model",
+        description: "3D model generation (Meshy AI)",
+        params: {
+          "--image": { type: "string", description: "Reference image path or URL" },
+          "--format": { type: "string", default: "glb" },
+          "--prompt": { type: "string" },
+          "--ai-model": { type: "string", description: "meshy-5 | meshy-6 | latest" },
+          "--polycount": { type: "number" },
+          "--pbr": { type: "bool" },
+          "--hd-texture": { type: "bool" },
+          "--pose-mode": { type: "string", description: "a-pose | t-pose" },
+          "--auto-size": { type: "bool" },
+          "--negative-prompt": { type: "string" },
+          "--multiview": { type: "string", description: "Comma-separated multiview image paths or URLs" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      character: {
+        description: "Generate a fully processed 3D character (Meshy AI)",
         params: {
-          "--image": { type: "string", required: false, description: "Reference image URL" },
-          "--prompt": { type: "string", required: false, description: "Model description prompt" },
-          "--output-dir": { type: "string", default: ".", description: "Directory to save output" }
+          "--prompt": { type: "string", description: "Character description prompt" },
+          "--image": { type: "string", description: "Reference image path or URL" },
+          "--images": { type: "string", description: "Comma-separated reference image paths or URLs" },
+          "--format": { type: "string", default: "glb" },
+          "--polycount": { type: "number" },
+          "--pbr": { type: "bool" },
+          "--hd-texture": { type: "bool" },
+          "--pose-mode": { type: "string", description: "a-pose | t-pose" },
+          "--ai-model": { type: "string", description: "meshy-5 | meshy-6 | latest" },
+          "--auto-size": { type: "bool" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      prop: {
+        description: "Generate a fully processed 3D prop (Meshy AI)",
+        params: {
+          "--prompt": { type: "string", description: "Prop description prompt" },
+          "--image": { type: "string", description: "Reference image path or URL" },
+          "--images": { type: "string", description: "Comma-separated reference image paths or URLs" },
+          "--format": { type: "string", default: "glb" },
+          "--polycount": { type: "number" },
+          "--pbr": { type: "bool" },
+          "--hd-texture": { type: "bool" },
+          "--ai-model": { type: "string", description: "meshy-5 | meshy-6 | latest" },
+          "--auto-size": { type: "bool" },
+          "--texture-prompt": { type: "string" },
+          "--output-dir": { type: "string", default: "." }
         }
       },
       text: {
-        description: "Generate text via LLM",
+        description: "LLM text via proxy",
+        params: {
+          "--prompt": { type: "string", required: true },
+          "--model": { type: "string" },
+          "--max-tokens": { type: "number" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      sprite: {
+        description: "Generate character animation spritesheet (AutoSprite)",
+        params: {
+          "--prompt": { type: "string", required: true, description: "Character description" },
+          "--input": { type: "string", description: "Reference image path or URL" },
+          "--animation-type": { type: "string", default: "walk", description: "walk, run, idle, jump, attack, death, cast, dance, wave, interact, or custom text" },
+          "--style": { type: "string", description: "Art style: 16-bit, hd-pixel, isometric, retro-8bit, anime, chibi, painterly, vector" },
+          "--frame-count": { type: "number", default: 8, description: "Number of animation frames" },
+          "--frame-size": { type: "number", default: 256, description: "Frame size in pixels (square)" },
+          "--is-humanoid": { type: "boolean", default: true },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      world: {
+        description: "Generate a 3D world or environment",
         params: {
-          "--prompt": { type: "string", required: true, description: "Text prompt" },
-          "--model": { type: "string", required: false, description: "Model to use" },
-          "--max-tokens": { type: "number", required: false, description: "Maximum tokens" },
-          "--output-dir": { type: "string", default: ".", description: "Directory to save output" }
+          "--prompt": { type: "string", required: true },
+          "--input": { type: "string", description: "Input image path or URL" },
+          "--model": { type: "string", default: "marble-1.1" },
+          "--display-name": { type: "string" },
+          "--output-dir": { type: "string", default: "." }
         }
       }
     }
   },
-  provider: {
-    description: "Provider management",
+  process: {
+    description: "Image/video post-process on gateway (ImageMagick/ffmpeg/rembg)",
+    subcommands: {
+      crop: {
+        description: "Smart crop (trim / power_of2)",
+        params: {
+          "--input": { type: "string", required: true, description: "File path or URL" },
+          "--mode": { type: "string", default: "tightest" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      resize: {
+        description: "Resize to exact width/height",
+        params: {
+          "--input": { type: "string", required: true },
+          "--width": { type: "number", required: true },
+          "--height": { type: "number", required: true },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      compose: {
+        description: "Sprite sheet from multiple images",
+        params: {
+          "--input": { type: "string[]", required: true },
+          "--direction": { type: "string", default: "horizontal" },
+          "--columns": { type: "number" },
+          "--padding": { type: "string" },
+          "--frame-width": { type: "number" },
+          "--frame-height": { type: "number" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      "remove-bg": {
+        description: "Remove background (rembg / fallback)",
+        params: {
+          "--input": { type: "string[]", required: true },
+          "--bg-color": { type: "string" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      }
+    }
+  },
+  process3d: {
+    description: "3D model post-processing (Meshy AI)",
     subcommands: {
-      list: { description: "List available providers" },
-      health: {
-        description: "Check provider health",
-        params: { name: { type: "string", required: false, description: "Specific provider name" } }
+      remesh: {
+        description: "Remesh a model and optionally change format or polygon count",
+        params: {
+          "--task-id": { type: "string", required: false, description: "Meshy task ID" },
+          "--model-url": { type: "string", required: false, description: "Model URL when remeshing without a task" },
+          "--format": { type: "string", required: true },
+          "--polycount": { type: "number" },
+          "--topology": { type: "string", description: "triangle | quad" },
+          "--auto-size": { type: "bool" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      retexture: {
+        description: "Regenerate textures for an existing Meshy model",
+        params: {
+          "--task-id": { type: "string", required: true },
+          "--prompt": { type: "string", description: "Text style prompt for the material pass" },
+          "--style-image": { type: "string", description: "Style image path or URL" },
+          "--pbr": { type: "bool" },
+          "--hd-texture": { type: "bool" },
+          "--ai-model": { type: "string", description: "meshy-5 | meshy-6 | latest" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      rig: {
+        description: "Rig a Meshy model for character animation",
+        params: {
+          "--task-id": { type: "string", required: false, description: "Meshy task ID" },
+          "--height": { type: "number", description: "Character height in meters" },
+          "--model-url": { type: "string", description: "Model URL when rigging without a task" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      animate: {
+        description: "Apply a preset animation to a rigged character. Common presets: 0=Idle, 1=Walk, 4=Attack, 8=Dead, 14=Run, 16=RunFast, 466=Jump. 500+ presets available.",
+        params: {
+          "--task-id": { type: "string", required: true, description: "Meshy rigging task ID" },
+          "--action-id": {
+            type: "number",
+            required: true,
+            description: "Animation preset ID (see docs for full list)"
+          },
+          "--fps": { type: "number", description: "Target frame rate: 24, 25, 30, or 60" },
+          "--output-dir": { type: "string", default: "." }
+        }
+      },
+      refine: {
+        description: "Refine a Meshy preview model into a higher quality result",
+        params: {
+          "--task-id": { type: "string", required: true, description: "Meshy preview task ID" },
+          "--pbr": { type: "bool" },
+          "--hd-texture": { type: "bool" },
+          "--texture-prompt": { type: "string" },
+          "--ai-model": { type: "string", description: "meshy-5 | meshy-6 | latest" },
+          "--output-dir": { type: "string", default: "." }
+        }
       }
     }
   },
+  upload: {
+    description: "Upload and list gateway assets",
+    subcommands: {
+      file: { description: "Upload file \u2192 URL", params: { "<path>": { required: true } } },
+      list: { description: "List uploads" },
+      delete: { description: "Delete by filename (admin)", params: { "<filename>": { required: true } } }
+    }
+  },
+  provider: {
+    description: "Provider discovery and health",
+    subcommands: {
+      list: { description: "List providers" },
+      health: { description: "Health check", params: { "[name]": { type: "string", required: false } } }
+    }
+  },
+  voice: {
+    description: "Design, clone, list, and delete MiMo voices",
+    subcommands: {
+      design: {
+        description: "Generate a MiMo voice from a text description",
+        params: {
+          "--voice-prompt": { type: "string", required: true },
+          "--preview-text": { type: "string", required: true },
+          "--style": { type: "string" },
+          "--name": { type: "string" },
+          "--save-as": { type: "string" },
+          "--output": { type: "string", description: "Write preview WAV to this path" }
+        }
+      },
+      clone: {
+        description: "Clone a MiMo voice from an mp3/wav sample",
+        params: {
+          "--audio": { type: "string", required: true, description: "Voice sample mp3/wav file or data URL" },
+          "--preview-text": { type: "string", required: true },
+          "--audio-mime": { type: "string" },
+          "--style": { type: "string" },
+          "--name": { type: "string" },
+          "--save-as": { type: "string" },
+          "--output": { type: "string", description: "Write preview WAV to this path" }
+        }
+      },
+      list: { description: "List saved voices", params: { "--type": { type: "string", description: "vc | vd" } } },
+      delete: { description: "Delete a saved voice", params: { "<voice-id>": { type: "string", required: true }, "--type": { type: "string", description: "vc | vd" } } }
+    }
+  },
   job: {
-    description: "Job management",
+    description: "Async job history",
     subcommands: {
       list: {
         description: "List jobs",
         params: {
-          "--status": { type: "string", required: false, description: "Filter by status" },
-          "--limit": { type: "number", required: false, description: "Maximum number of jobs to return" }
+          "--status": { type: "string" },
+          "--limit": { type: "number" }
         }
       },
-      status: {
-        description: "Get job status",
-        params: { id: { type: "string", required: true, description: "Job ID" } }
-      },
-      cancel: {
-        description: "Cancel a job",
-        params: { id: { type: "string", required: true, description: "Job ID" } }
-      }
+      status: { description: "Job detail", params: { "<id>": { type: "string", required: true } } },
+      cancel: { description: "Cancel pending/running", params: { "<id>": { type: "string", required: true } } }
     }
   },
   describe: {
-    description: "Self-describe available commands (JSON Schema)",
+    description: "Command introspection (this output)",
     params: {
-      command: { type: "string", required: false, description: "Specific command to describe" }
+      "[command]": { type: "string", required: false, description: "Top-level group: generate, process, \u2026" }
     }
   }
 };
+
+// src/commands/describe.ts
 function createDescribeCommand() {
-  return new Command2("describe").description("Self-describe available commands (JSON Schema)").argument("[command]", "Specific command to describe").action(function(commandArg) {
+  return new Command2("describe").description("Self-describe available commands (JSON Schema)").argument("[command]", "Specific command group to describe (e.g. generate, process)").action(function(commandArg) {
     const globals = this.optsWithGlobals();
     if (!commandArg) {
       output(
@@ -486,19 +597,109 @@ function createDescribeCommand() {
 }
 
 // src/commands/generate.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, extname, join as join2 } from "path";
+import { AssetForgeError as AssetForgeError3 } from "@doufunao123/assetforge-sdk";
 import { Command as Command3 } from "commander";
 function inferExtension(assetType) {
-  const map = { image: "png", audio: "mp3", tts: "mp3", video: "mp4", model3d: "glb", text: "txt" };
+  const map = {
+    image: "png",
+    audio: "mp3",
+    sfx: "mp3",
+    music: "mp3",
+    tts: "wav",
+    video: "mp4",
+    model3d: "glb",
+    character: "glb",
+    prop: "glb",
+    text: "txt",
+    sprite: "png",
+    world: "spz",
+    animation: "glb",
+    material: "zip",
+    hdri: "hdr",
+    vfx: "zip",
+    lut: "cube",
+    shader: "glsl",
+    font_typeface: "json",
+    skybox: "png",
+    decal: "png",
+    heightmap: "png"
+  };
   return map[assetType] ?? "bin";
 }
+function inferExtFromResult(result) {
+  const meta = result.metadata;
+  if (!meta) return null;
+  const ct = meta.content_type;
+  if (!ct) return null;
+  const map = {
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "video/mp4": "mp4",
+    "audio/mpeg": "mp3",
+    "audio/wav": "wav",
+    "audio/x-wav": "wav",
+    "model/gltf-binary": "glb",
+    "model/gltf+json": "gltf",
+    "model/stl": "stl",
+    "model/vnd.usdz+zip": "usdz"
+  };
+  return map[ct] ?? null;
+}
+function infer3dExtension(format) {
+  const map = {
+    glb: "glb",
+    fbx: "fbx",
+    obj: "obj",
+    usdz: "usdz",
+    stl: "stl",
+    "3mf": "3mf",
+    gltf: "gltf"
+  };
+  return format ? map[String(format).toLowerCase()] ?? null : null;
+}
 function stripDataUri(data) {
   const idx = data.indexOf(";base64,");
   return idx >= 0 ? data.slice(idx + 8) : data;
 }
-async function saveOutput(result, assetType, outputDir) {
-  const ext = inferExtension(assetType);
+function inferMimeType(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  const map = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime"
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+function toInputFile(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (!existsSync3(value)) {
+    return value;
+  }
+  const b64 = readFileSync2(value).toString("base64");
+  return `data:${inferMimeType(value)};base64,${b64}`;
+}
+function parseCommaSeparatedValues(raw) {
+  if (!raw) {
+    return [];
+  }
+  return String(raw).split(",").map((value) => value.trim()).filter(Boolean);
+}
+function collectValue(value, previous = []) {
+  previous.push(value);
+  return previous;
+}
+async function saveOutput(result, assetType, outputDir, preferredFormat) {
+  const ext = inferExtFromResult(result) ?? infer3dExtension(preferredFormat) ?? inferExtension(assetType);
   const timestamp = Date.now();
   const filename = `${assetType}_${timestamp}.${ext}`;
   mkdirSync2(outputDir, { recursive: true });
@@ -524,22 +725,109 @@ async function saveOutput(result, assetType, outputDir) {
   }
   return null;
 }
+async function saveNamedOutput(result, assetType, filePath) {
+  mkdirSync2(dirname2(filePath), { recursive: true });
+  if (result.output_data) {
+    const raw = String(result.output_data);
+    if (assetType === "text") {
+      writeFileSync2(filePath, raw, "utf8");
+    } else {
+      writeFileSync2(filePath, Buffer.from(stripDataUri(raw), "base64"));
+    }
+    return filePath;
+  }
+  if (result.output_url) {
+    const response = await fetch(String(result.output_url));
+    if (!response.ok) {
+      return null;
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    writeFileSync2(filePath, buffer);
+    return filePath;
+  }
+  return null;
+}
+function parseFrameSize(raw) {
+  const [width, height] = raw.split("x");
+  const frameWidth = Number(width);
+  const frameHeight = Number(height);
+  if (!Number.isFinite(frameWidth) || !Number.isFinite(frameHeight)) {
+    throw new Error("frame size must be formatted as WIDTHxHEIGHT");
+  }
+  return { frame_width: frameWidth, frame_height: frameHeight };
+}
+function assertHas3dInput(prompt, image, images) {
+  if (!prompt && !image && parseCommaSeparatedValues(images).length === 0) {
+    throw new Error("Provide at least one of --prompt, --image, or --images");
+  }
+}
+function toJsonObject(value) {
+  return value;
+}
+function isPackOnlyResult(value) {
+  return value.ok === false && value.pack_only === true;
+}
+async function runGeneratedAssetCommand(command, sdkMethod, commandName, assetType, options) {
+  const ctx = createContext(command);
+  const generate = ctx.client[sdkMethod];
+  const data = await generate.call(ctx.client, String(options.prompt), {
+    provider: options.provider,
+    model: options.model,
+    size: options.size,
+    quality: options.quality,
+    background: options.background,
+    output_format: options.outputFormat,
+    n: options.n ? Number(options.n) : void 0,
+    preset: options.preset,
+    transparent: options.transparent ? true : void 0,
+    input: toInputFile(options.input)
+  });
+  if (isPackOnlyResult(data)) {
+    throw new AssetForgeError3("This asset type requires a library pack. Run: asset-gateway pack list", {
+      code: "PACK_ONLY",
+      details: data
+    });
+  }
+  const localPath = await saveOutput(data, assetType, String(options.outputDir ?? "."));
+  if (localPath) data.local_path = localPath;
+  printSuccess(commandName, data, ctx);
+}
+function createGeneratedAssetCommand(name, sdkMethod, assetType, description) {
+  const command = new Command3(name).description(description).requiredOption("--prompt <text>", "Asset description prompt").option("--provider <id>", "Provider to use").option("--model <model>", "Model to use").option("--size <size>", "Output size when supported").option("--input <path>", "Input file path or URL when supported").option("--quality <quality>", "Image quality: low, medium, high").option("--background <background>", "Image background: auto, opaque, transparent").option("--output-format <fmt>", "Image output format: png, webp, jpeg").option("--n <num>", "Number of image variants (1-10)").option("--preset <preset>", "Image preset id").option("--transparent", "Request transparent background when supported").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    const commandName = `generate.${assetType}`;
+    try {
+      await runGeneratedAssetCommand(this, sdkMethod, commandName, assetType, options);
+    } catch (error2) {
+      printError(commandName, error2);
+    }
+  });
+  if (name === "font-typeface") {
+    command.alias("font_typeface");
+  }
+  return command;
+}
 function createGenerateCommand() {
   const command = new Command3("generate").description("Generate assets via the gateway");
   command.addCommand(
-    new Command3("image").description("Generate an image from a text prompt").requiredOption("--prompt <text>", "Image description prompt").option("--provider <id>", "Provider to use").option("--transparent", "Request transparent background").option("--model <model>", "Model to use").option("--size <size>", "Image size (e.g. 1024x1024)").option("--input <url>", "Input image URL for editing (Gemini/Grok)").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command3("image").description("Generate an image from a text prompt").requiredOption("--prompt <text>", "Image description prompt").option("--provider <id>", "Provider to use").option("--transparent", "Request transparent background").option("--model <model>", "Model to use").option("--size <size>", "Image size (e.g. 1024x1024)").option("--quality <quality>", "Image quality: low, medium, high").option("--background <background>", "Image background: auto, opaque, transparent").option("--output-format <fmt>", "Image output format: png, webp, jpeg").option("--n <num>", "Number of image variants (1-10)").option("--preset <preset>", "Image preset id").option("--mask <path>", "PNG alpha mask path or URL for inpainting").option("--input <url>", "Input image URL for editing (Gemini/Grok)").option("--ref <urls...>", "Reference image URLs for multi-image editing (repeatable)").option("--edit-mode <mode>", "Edit mode: edit, inpaint, restyle, expand").option("--session <id>", "Session ID for multi-turn editing").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
-        const body = {
-          asset_type: "image",
-          prompt: options.prompt
-        };
-        if (options.provider) body.provider = options.provider;
-        if (options.transparent) body.transparent = true;
-        if (options.model) body.model = options.model;
-        if (options.size) body.size = options.size;
-        if (options.input) body.input_file = options.input;
-        const data = await ctx.client.post("/api/generate", body);
+        const data = await ctx.client.image(options.prompt, {
+          provider: options.provider,
+          model: options.model,
+          size: options.size,
+          quality: options.quality,
+          background: options.background,
+          output_format: options.outputFormat,
+          n: options.n ? Number(options.n) : void 0,
+          preset: options.preset,
+          mask: toInputFile(options.mask),
+          transparent: options.transparent ? true : void 0,
+          input: toInputFile(options.input),
+          reference_images: options.ref,
+          edit_mode: options.editMode,
+          session_id: options.session
+        });
         const localPath = await saveOutput(data, "image", options.outputDir);
         if (localPath) data.local_path = localPath;
         printSuccess("generate.image", data, ctx);
@@ -549,15 +837,16 @@ function createGenerateCommand() {
     })
   );
   command.addCommand(
-    new Command3("video").description("Generate a video from a text prompt").requiredOption("--prompt <text>", "Video description prompt").option("--provider <id>", "Provider to use").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command3("video").description("Generate a video from a text prompt (or image-to-video with --input)").requiredOption("--prompt <text>", "Video description prompt").option("--provider <id>", "Provider to use").option("--input <url>", "Reference image URL for image-to-video (Grok)").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
-        const body = {
-          asset_type: "video",
-          prompt: options.prompt
+        const requestOptions = {
+          provider: options.provider,
+          input: options.input
         };
-        if (options.provider) body.provider = options.provider;
-        const data = await ctx.client.post("/api/generate", body);
+        const data = await ctx.client.video(options.prompt, {
+          ...requestOptions
+        });
         const localPath = await saveOutput(data, "video", options.outputDir);
         if (localPath) data.local_path = localPath;
         printSuccess("generate.video", data, ctx);
@@ -567,41 +856,100 @@ function createGenerateCommand() {
     })
   );
   command.addCommand(
-    new Command3("audio").description("Generate audio from a text prompt").requiredOption("--prompt <text>", "Audio description prompt").option("--type <type>", "Audio type: bgm or sfx").option("--duration <seconds>", "Duration in seconds").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command3("batch").description("Batch generate multiple assets with shared parameters").requiredOption("--prompt <texts...>", "Multiple prompts (one per frame)").option("--asset-type <type>", "Asset type", "image").option("--transparent", "Request transparent background").option("--size <size>", "Image size").option("--ref <urls...>", "Reference image URLs").option("--compose <direction>", "Auto-compose: horizontal, vertical, grid").option("--columns <n>", "Grid columns for compose").option("--frame-size <size>", "Frame size for compose (e.g. 64x64)").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
+        const shared = {};
+        if (options.transparent) shared.transparent = true;
+        if (options.size) shared.size = options.size;
+        if (options.ref && options.ref.length > 0) shared.reference_images = options.ref;
         const body = {
-          asset_type: "audio",
-          prompt: options.prompt
+          asset_type: options.assetType,
+          prompts: options.prompt,
+          shared
         };
-        if (options.type) body.audio_type = options.type;
-        if (options.duration) body.duration = Number(options.duration);
-        const data = await ctx.client.post("/api/generate", body);
+        if (options.compose) {
+          const compose = { direction: options.compose };
+          if (options.columns) compose.columns = Number(options.columns);
+          if (options.frameSize) Object.assign(compose, parseFrameSize(options.frameSize));
+          body.compose = compose;
+        }
+        const data = await ctx.client.batch(body);
+        const assetType = String(options.assetType);
+        mkdirSync2(options.outputDir, { recursive: true });
+        if (Array.isArray(data.frames)) {
+          for (const frame of data.frames) {
+            if (typeof frame !== "object" || frame === null) continue;
+            const record = frame;
+            const index = typeof record.index === "number" ? record.index : 0;
+            const localPath = await saveNamedOutput(
+              record,
+              assetType,
+              join2(options.outputDir, `frame_${String(index).padStart(3, "0")}.${inferExtension(assetType)}`)
+            );
+            if (localPath) record.local_path = localPath;
+          }
+        }
+        if (typeof data.spritesheet === "object" && data.spritesheet !== null) {
+          const record = data.spritesheet;
+          const localPath = await saveNamedOutput(
+            record,
+            "image",
+            join2(options.outputDir, "spritesheet.png")
+          );
+          if (localPath) record.local_path = localPath;
+        }
+        printSuccess("generate.batch", data, ctx);
+      } catch (error2) {
+        printError("generate.batch", error2);
+      }
+    })
+  );
+  command.addCommand(
+    new Command3("sfx").description("Generate sound effects (short audio clips: impacts, footsteps, UI sounds, ambience)").requiredOption("--prompt <text>", "Sound effect description").requiredOption("--duration <seconds>", "Duration in seconds (1-5s for short SFX, 5-15s for ambience, max 30s)").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+      try {
+        const ctx = createContext(this);
+        const data = await ctx.client.audio(options.prompt, {
+          duration: Number(options.duration)
+        });
         const localPath = await saveOutput(data, "audio", options.outputDir);
         if (localPath) data.local_path = localPath;
-        printSuccess("generate.audio", data, ctx);
+        printSuccess("generate.sfx", data, ctx);
+      } catch (error2) {
+        printError("generate.sfx", error2);
+      }
+    })
+  );
+  command.addCommand(
+    new Command3("music").description("Generate music using the gateway music provider").requiredOption("--prompt <text>", "Music description prompt").option("--duration <seconds>", "Duration in seconds").option("--force-instrumental", "Request instrumental output when supported").option(
+      "--output-format <fmt>",
+      "Provider-specific output format override when supported"
+    ).option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+      try {
+        const ctx = createContext(this);
+        const data = await ctx.client.music(options.prompt, {
+          duration: options.duration ? Number(options.duration) : void 0,
+          force_instrumental: options.forceInstrumental ? true : void 0,
+          output_format: options.outputFormat
+        });
+        const localPath = await saveOutput(data, "music", options.outputDir);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.music", data, ctx);
       } catch (error2) {
-        printError("generate.audio", error2);
+        printError("generate.music", error2);
       }
     })
   );
   command.addCommand(
-    new Command3("tts").description("Text-to-speech synthesis (Chinese/multilingual)").requiredOption("--prompt <text>", "Text to synthesize").option("--voice-id <id>", "Voice ID (e.g. 'Chinese (Mandarin)_Lyrical_Voice')").option("--model <model>", "TTS model (speech-2.6-hd, speech-2.6-turbo)").option("--speed <n>", "Speech speed [0.5, 2.0]").option("--language-boost <lang>", "Language hint: auto, Chinese, English, etc.").option("--emotion <emotion>", "Emotion: happy, sad, angry, calm, etc.").option("--provider <id>", "Provider to use").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command3("tts").description("Text-to-speech via MiMo v2.5 TTS").requiredOption("--prompt <text>", "Text to synthesize").option("--voice <name>", "MiMo prebuilt voice name (default: server config, usually Mia)").option("--context <text>", "Natural-language style or director instruction").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
         const params = {};
-        if (options.voiceId) params.voice_id = options.voiceId;
-        if (options.speed) params.speed = Number(options.speed);
-        if (options.languageBoost) params.language_boost = options.languageBoost;
-        if (options.emotion) params.emotion = options.emotion;
-        const body = {
-          asset_type: "tts",
-          prompt: options.prompt,
-          params
-        };
-        if (options.model) body.model = options.model;
-        if (options.provider) body.provider = options.provider;
-        const data = await ctx.client.post("/api/generate", body);
+        if (options.context) params.context = options.context;
+        const data = await ctx.client.tts(options.prompt, {
+          voice: options.voice,
+          params: Object.keys(params).length > 0 ? toJsonObject(params) : void 0
+        });
         const localPath = await saveOutput(data, "tts", options.outputDir);
         if (localPath) data.local_path = localPath;
         printSuccess("generate.tts", data, ctx);
@@ -611,27 +959,27 @@ function createGenerateCommand() {
     })
   );
   command.addCommand(
-    new Command3("model").description("Generate a 3D model").option("--image <url>", "Reference image URL").option("--prompt <text>", "Model description prompt").option("--model-version <v>", "Tripo model version (e.g. P1-20260311)").option("--face-limit <n>", "Max face count (48-20000)").option("--pbr", "Enable PBR textures").option("--texture-quality <q>", "Texture quality: standard or detailed").option("--auto-size", "Auto-scale to real-world dimensions").option("--negative-prompt <text>", "Negative prompt").option("--multiview <urls>", "4 image URLs comma-separated: front,left,back,right").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command3("model").description("Generate a 3D model with Meshy AI").option("--image <input>", "Reference image path or URL").option("--format <fmt>", "Output format: glb, fbx, obj, usdz, stl, 3mf", "glb").option("--prompt <text>", "Model description prompt").option("--ai-model <name>", "Meshy model: meshy-5, meshy-6, latest").option("--polycount <n>", "Target polygon count").option("--pbr", "Enable PBR textures").option("--hd-texture", "Request 4K texture output").option("--pose-mode <mode>", "Character pose mode: a-pose or t-pose").option("--auto-size", "Estimate real-world size automatically").option("--negative-prompt <text>", "Negative prompt").option("--multiview <inputs>", "Comma-separated multiview image paths or URLs").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
+        assertHas3dInput(options.prompt, options.image, options.multiview);
         const ctx = createContext(this);
-        const body = {
-          asset_type: "model3d"
-        };
         const params = {};
-        if (options.image) body.input_file = options.image;
-        if (options.prompt) body.prompt = options.prompt;
-        if (options.modelVersion) params.model_version = options.modelVersion;
-        if (options.faceLimit) params.face_limit = Number(options.faceLimit);
-        if (options.pbr) params.pbr = true;
-        if (options.textureQuality) params.texture_quality = options.textureQuality;
-        if (options.autoSize) params.auto_size = true;
         if (options.negativePrompt) params.negative_prompt = options.negativePrompt;
         if (options.multiview) {
-          params.multiview = String(options.multiview).split(",").map((value) => value.trim()).filter(Boolean);
+          params.multiview = parseCommaSeparatedValues(options.multiview).map((value) => toInputFile(value)).filter((value) => Boolean(value));
         }
-        if (Object.keys(params).length > 0) body.params = params;
-        const data = await ctx.client.post("/api/generate", body);
-        const localPath = await saveOutput(data, "model3d", options.outputDir);
+        const data = await ctx.client.model3d(options.prompt ?? "", {
+          input: toInputFile(options.image),
+          format: options.format,
+          ai_model: options.aiModel,
+          polycount: options.polycount ? Number(options.polycount) : void 0,
+          pbr: options.pbr ? true : void 0,
+          hd_texture: options.hdTexture ? true : void 0,
+          pose_mode: options.poseMode,
+          auto_size: options.autoSize ? true : void 0,
+          params: Object.keys(params).length > 0 ? toJsonObject(params) : void 0
+        });
+        const localPath = await saveOutput(data, "model3d", options.outputDir, options.format);
         if (localPath) data.local_path = localPath;
         printSuccess("generate.model", data, ctx);
       } catch (error2) {
@@ -640,55 +988,179 @@ function createGenerateCommand() {
     })
   );
   command.addCommand(
-    new Command3("text").description("Generate text via LLM").requiredOption("--prompt <text>", "Text prompt").option("--model <model>", "Model to use").option("--max-tokens <n>", "Maximum tokens").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command3("character").description("Generate a fully processed 3D character with Meshy AI").option("--prompt <text>", "Character description prompt").option("--image <input>", "Reference image path or URL").option("--images <inputs>", "Comma-separated reference image paths or URLs").option("--format <fmt>", "Output format: glb, fbx, obj, usdz, stl, 3mf", "glb").option("--polycount <n>", "Target polygon count").option("--pbr", "Enable PBR textures").option("--hd-texture", "Request 4K texture output").option("--pose-mode <mode>", "Character pose mode: a-pose or t-pose").option("--ai-model <name>", "Meshy model: meshy-5, meshy-6, latest").option("--auto-size", "Estimate real-world size automatically").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
+        assertHas3dInput(options.prompt, options.image, options.images);
         const ctx = createContext(this);
-        const body = {
-          asset_type: "text",
-          prompt: options.prompt
-        };
-        if (options.model) body.model = options.model;
-        if (options.maxTokens) body.max_tokens = Number(options.maxTokens);
-        const data = await ctx.client.post("/api/generate", body);
-        const localPath = await saveOutput(data, "text", options.outputDir);
+        const images = parseCommaSeparatedValues(options.images).map((value) => toInputFile(value)).filter((value) => Boolean(value));
+        const data = await ctx.client.character(options.prompt ?? "", {
+          input: toInputFile(options.image),
+          images: images.length > 0 ? images : void 0,
+          format: options.format,
+          polycount: options.polycount ? Number(options.polycount) : void 0,
+          pbr: options.pbr ? true : void 0,
+          hd_texture: options.hdTexture ? true : void 0,
+          pose_mode: options.poseMode,
+          ai_model: options.aiModel,
+          auto_size: options.autoSize ? true : void 0
+        });
+        const localPath = await saveOutput(data, "character", options.outputDir, options.format);
         if (localPath) data.local_path = localPath;
-        printSuccess("generate.text", data, ctx);
+        printSuccess("generate.character", data, ctx);
       } catch (error2) {
-        printError("generate.text", error2);
+        printError("generate.character", error2);
       }
     })
   );
-  return command;
-}
-
-// src/commands/job.ts
-import { Command as Command4 } from "commander";
-function createJobCommand() {
-  const command = new Command4("job").description("Job management");
   command.addCommand(
-    new Command4("list").description("List jobs").option("--status <status>", "Filter by status").option("--limit <n>", "Maximum number of jobs to return").action(async function(options) {
+    new Command3("prop").description("Generate a fully processed 3D prop with Meshy AI").option("--prompt <text>", "Prop description prompt").option("--image <input>", "Reference image path or URL").option("--images <inputs>", "Comma-separated reference image paths or URLs").option("--format <fmt>", "Output format: glb, fbx, obj, usdz, stl, 3mf", "glb").option("--polycount <n>", "Target polygon count").option("--pbr", "Enable PBR textures").option("--hd-texture", "Request 4K texture output").option("--ai-model <name>", "Meshy model: meshy-5, meshy-6, latest").option("--auto-size", "Estimate real-world size automatically").option("--texture-prompt <text>", "Optional texture prompt for the final material pass").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
+        assertHas3dInput(options.prompt, options.image, options.images);
         const ctx = createContext(this);
-        const params = new URLSearchParams();
-        if (options.status) params.set("status", options.status);
-        if (options.limit) params.set("limit", options.limit);
-        const query = params.toString();
-        const path = query ? `/api/jobs?${query}` : "/api/jobs";
-        const data = await ctx.client.get(path);
-        printSuccess("job.list", data, ctx);
+        const images = parseCommaSeparatedValues(options.images).map((value) => toInputFile(value)).filter((value) => Boolean(value));
+        const data = await ctx.client.prop(options.prompt ?? "", {
+          input: toInputFile(options.image),
+          images: images.length > 0 ? images : void 0,
+          format: options.format,
+          polycount: options.polycount ? Number(options.polycount) : void 0,
+          pbr: options.pbr ? true : void 0,
+          hd_texture: options.hdTexture ? true : void 0,
+          ai_model: options.aiModel,
+          auto_size: options.autoSize ? true : void 0,
+          texture_prompt: options.texturePrompt
+        });
+        const localPath = await saveOutput(data, "prop", options.outputDir, options.format);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.prop", data, ctx);
       } catch (error2) {
-        printError("job.list", error2);
+        printError("generate.prop", error2);
       }
     })
   );
   command.addCommand(
-    new Command4("status").description("Get job status").argument("<id>", "Job ID").action(async function(id) {
+    new Command3("text").description("Generate text via LLM").requiredOption("--prompt <text>", "Text prompt").option("--model <model>", "Model to use").option("--max-tokens <n>", "Maximum tokens").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
-        const data = await ctx.client.get(`/api/jobs/${encodeURIComponent(id)}`);
-        printSuccess("job.status", data, ctx);
+        const data = await ctx.client.text(options.prompt, {
+          model: options.model,
+          max_tokens: options.maxTokens ? Number(options.maxTokens) : void 0
+        });
+        const localPath = await saveOutput(data, "text", options.outputDir);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.text", data, ctx);
       } catch (error2) {
-        printError("job.status", error2);
+        printError("generate.text", error2);
+      }
+    })
+  );
+  command.addCommand(
+    new Command3("sprite").description("Generate character animation spritesheet (AutoSprite)").requiredOption("--prompt <text>", "Character description").option("--input <path>", "Reference image for character consistency (local path or URL)").option("--animation-type <type>", "Animation type: walk, run, idle, jump, attack, death, cast, dance, wave, interact, or custom text", "walk").option("--style <style>", "Art style: 16-bit, hd-pixel, isometric, retro-8bit, anime, chibi, painterly, vector, or any text").option("--frame-count <n>", "Number of animation frames", "8").option("--frame-size <n>", "Frame size in pixels (square)", "256").option("--is-humanoid", "Character is humanoid (default true)", true).option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+      try {
+        const ctx = createContext(this);
+        const params = {
+          frame_count: Number(options.frameCount),
+          frame_size: Number(options.frameSize),
+          is_humanoid: options.isHumanoid
+        };
+        const data = await ctx.client.sprite(options.prompt, {
+          input: toInputFile(options.input),
+          animation_type: options.animationType,
+          style: options.style,
+          params: toJsonObject(params)
+        });
+        const localPath = await saveOutput(data, "sprite", options.outputDir);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.sprite", data, ctx);
+      } catch (error2) {
+        printError("generate.sprite", error2);
+      }
+    })
+  );
+  command.addCommand(
+    new Command3("world").description("Generate a 3D world/environment using WorldLabs Marble").option("--prompt <text>", "Text prompt describing the environment").option("--input <path>", "Input image (local path or URL) for image-to-world").option("--image <path>", "Input image (local path or URL) for image-to-world").option("--panorama <path>", "360 panorama image path or URL").option("--video <path>", "Input video path or URL").option("--multi-image <path>", "Multi-view image path or URL (repeatable)", collectValue, []).option("--quality <quality>", "World quality: low, high").option("--model <model>", "Model: marble-1.0-draft, marble-1.0, marble-1.1, marble-1.1-plus", "marble-1.1").option("--display-name <name>", "Display name for the generated world").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+      try {
+        const prompt = options.prompt ?? "";
+        const multiImage = options.multiImage.map((value) => toInputFile(value)).filter((value) => Boolean(value));
+        if (!prompt && !options.input && !options.image && !options.panorama && !options.video && multiImage.length === 0) {
+          throw new Error("Provide at least one of --prompt, --image, --input, --panorama, --video, or --multi-image");
+        }
+        const ctx = createContext(this);
+        const data = await ctx.client.world(prompt, {
+          input: toInputFile(options.input ?? options.image),
+          model: options.model,
+          panorama_url: toInputFile(options.panorama),
+          video_url: toInputFile(options.video),
+          multi_image_url: multiImage.length > 0 ? multiImage : void 0,
+          quality: options.quality,
+          display_name: options.displayName
+        });
+        const localPath = await saveOutput(data, "world", options.outputDir);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.world", data, ctx);
+      } catch (error2) {
+        printError("generate.world", error2);
+      }
+    })
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("animation", "animation", "animation", "Generate a 3D animation clip with Meshy AI")
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("material", "material", "material", "Resolve a PBR material from library packs")
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("hdri", "hdri", "hdri", "Resolve an HDRI environment from library packs")
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("vfx", "vfx", "vfx", "Resolve a Three.js VFX bundle from library packs")
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("lut", "lut", "lut", "Resolve a LUT cube from library packs")
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("shader", "shader", "shader", "Resolve a GLSL shader from library packs")
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("font-typeface", "fontTypeface", "font_typeface", "Resolve a Three.js typeface font from library packs")
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("skybox", "skybox", "skybox", "Generate an equirectangular skybox image")
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("decal", "decal", "decal", "Generate a transparent decal image")
+  );
+  command.addCommand(
+    createGeneratedAssetCommand("heightmap", "heightmap", "heightmap", "Generate a grayscale terrain heightmap")
+  );
+  return command;
+}
+
+// src/commands/job.ts
+import { Command as Command4 } from "commander";
+function createJobCommand() {
+  const command = new Command4("job").description("Job management");
+  command.addCommand(
+    new Command4("list").description("List jobs").option("--status <status>", "Filter by status").option("--limit <n>", "Maximum number of jobs to return").action(async function(options) {
+      try {
+        const ctx = createContext(this);
+        const data = await ctx.client.job.list({
+          status: options.status,
+          limit: options.limit ? Number(options.limit) : void 0
+        });
+        printSuccess("job.list", data, ctx);
+      } catch (error2) {
+        printError("job.list", error2);
+      }
+    })
+  );
+  command.addCommand(
+    new Command4("status").description("Get job status").argument("<id>", "Job ID").action(async function(id) {
+      try {
+        const ctx = createContext(this);
+        const data = await ctx.client.job.status(id);
+        printSuccess("job.status", data, ctx);
+      } catch (error2) {
+        printError("job.status", error2);
       }
     })
   );
@@ -696,7 +1168,7 @@ function createJobCommand() {
     new Command4("cancel").description("Cancel a job").argument("<id>", "Job ID").action(async function(id) {
       try {
         const ctx = createContext(this);
-        const data = await ctx.client.post(`/api/jobs/${encodeURIComponent(id)}/cancel`);
+        const data = await ctx.client.job.cancel(id);
         printSuccess("job.cancel", data, ctx);
       } catch (error2) {
         printError("job.cancel", error2);
@@ -706,95 +1178,451 @@ function createJobCommand() {
   return command;
 }
 
+// src/commands/library.ts
+import { readFile, writeFile } from "fs/promises";
+import { AssetForgeError as AssetForgeError4 } from "@doufunao123/assetforge-sdk";
+import { Command as Command5 } from "commander";
+function createLibraryCommand() {
+  const command = new Command5("library").description(
+    "Search and manage the asset library"
+  );
+  command.addCommand(
+    new Command5("search").description("Search the asset library").argument("[query]", "Search query").option("-q, --query <query>", "Search query").option("-t, --type <type>", "Filter by asset type (audio, music, image, etc.)").option("--tags <tags>", "Filter by tags (comma-separated)").option("--source <source>", "Filter by source (manual, generated, imported)").option("--mode <mode>", "Search mode (fts, vector, hybrid)").option("--style <style>", "Filter by visual style").option("--composition <composition>", "Filter by composition").option("--lighting <lighting>", "Filter by lighting").option("--color-tone <tone>", "Filter by color tone").option("--mood <mood>", "Filter by mood (comma-separated)").option("--theme <theme>", "Filter by theme (comma-separated)").option("--era <era>", "Filter by era").option("--rig-name <rig>", "Filter by exact rig name").option("--compatible-rig <rig>", "Filter by compatible rig").option("--no-rerank", "Disable LLM reranking").option("-n, --limit <limit>", "Max results", "20").option("--offset <offset>", "Offset for pagination", "0").action(async function(query) {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const data = await ctx.client.library.search({
+          q: opts.query ?? query,
+          type: opts.type,
+          tags: opts.tags,
+          source: opts.source,
+          mode: opts.mode,
+          style: opts.style,
+          composition: opts.composition,
+          lighting: opts.lighting,
+          color_tone: opts.colorTone,
+          mood: opts.mood,
+          theme: opts.theme,
+          era: opts.era,
+          rig_name: opts.rigName,
+          compatible_rig: opts.compatibleRig,
+          rerank: opts.rerank,
+          limit: Number(opts.limit),
+          offset: Number(opts.offset)
+        });
+        printSuccess("library.search", data, ctx);
+      } catch (error2) {
+        printError("library.search", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("related").description("Find rig-compatible related assets").argument("<id>", "Library item ID").option("-t, --type <type>", "Filter related assets by type").option("-n, --limit <limit>", "Max results", "20").action(async function(id) {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const data = await ctx.client.library.related(id, {
+          type: opts.type,
+          limit: Number(opts.limit)
+        });
+        printSuccess("library.related", data, ctx);
+      } catch (error2) {
+        printError("library.related", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("bundle").description("Download a zip bundle of library assets").argument("<ids...>", "Library item IDs").requiredOption("-o, --output <path>", "Output zip path").action(async function(ids) {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const blob = await ctx.client.library.bundle({ asset_ids: ids, format: "zip" });
+        const buffer = Buffer.from(await blob.arrayBuffer());
+        await writeFile(opts.output, buffer);
+        printSuccess(
+          "library.bundle",
+          { output: opts.output, bytes: buffer.length, asset_ids: ids },
+          ctx
+        );
+      } catch (error2) {
+        printError("library.bundle", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("ingest").description("Queue or run a library ingest job (admin only)").requiredOption("--source <source>", "Ingest source (manual, generated, pack, imported)").requiredOption("-t, --type <type>", "Asset type").option("--file-url <url>", "Public asset URL").option("--file <path>", "Local file to encode as base64").option("--thumbnail-url <url>", "Thumbnail URL").option("--name <name>", "Display name").option("--tag <tag>", "User tag (repeatable)", collect, []).option("--source-job-id <id>", "Source generate job ID").option("--pack-id <id>", "Pack ID").option("--pack-asset-key <key>", "Pack asset key").option("--sync", "Run ingest synchronously and return the library result").action(async function() {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const request = {
+          source: opts.source,
+          asset_type: opts.type,
+          file_url: opts.fileUrl,
+          file_data_b64: opts.file ? await readBase64(opts.file) : void 0,
+          thumbnail_url: opts.thumbnailUrl,
+          name: opts.name,
+          user_tags: opts.tag,
+          source_job_id: opts.sourceJobId,
+          pack_id: opts.packId,
+          pack_asset_key: opts.packAssetKey
+        };
+        const data = opts.sync ? await ctx.client.library.ingestSync(request) : await ctx.client.library.ingest(request);
+        printSuccess(opts.sync ? "library.ingest_sync" : "library.ingest", data, ctx);
+      } catch (error2) {
+        printError("library.ingest", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("ingest-status").description("Get a library ingest job status").argument("<id>", "Ingest job ID").action(async function(id) {
+      const ctx = createContext(this);
+      try {
+        const data = await ctx.client.library.ingestStatus(id);
+        printSuccess("library.ingest_status", data, ctx);
+      } catch (error2) {
+        printError("library.ingest_status", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("ingest-wait").description("Poll a library ingest job until completion").argument("<id>", "Ingest job ID").option("--interval-ms <ms>", "Polling interval", "1000").action(async function(id) {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const data = await ctx.client.library.ingestWait(id, {
+          intervalMs: Number(opts.intervalMs)
+        });
+        printSuccess("library.ingest_wait", data, ctx);
+      } catch (error2) {
+        printError("library.ingest_wait", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("add").description("Add an item to the asset library").requiredOption("--name <name>", "Display name").requiredOption("--url <url>", "File URL (public)").requiredOption("-t, --type <type>", "Asset type (audio, music, image, etc.)").option("-d, --description <desc>", "Description").option("--tags <tags>", "Comma-separated tags").option("--duration <seconds>", "Duration in seconds (for audio/video)").option("--source <source>", "Source (manual, generated, imported)", "manual").action(async function() {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const body = {
+          asset_type: opts.type,
+          name: opts.name,
+          file_url: opts.url,
+          source: opts.source
+        };
+        if (opts.description) body.description = opts.description;
+        if (opts.tags)
+          body.tags = opts.tags.split(",").map((t) => t.trim());
+        if (opts.duration)
+          body.duration_seconds = parseFloat(opts.duration);
+        const data = await ctx.client.library.add(body);
+        printSuccess("library.add", data, ctx);
+      } catch (error2) {
+        printError("library.add", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("get").description("Get a library item by ID").argument("<id>", "Library item ID").action(async function(id) {
+      const ctx = createContext(this);
+      try {
+        const data = await ctx.client.library.get(id);
+        printSuccess("library.get", data, ctx);
+      } catch (error2) {
+        printError("library.get", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("delete").description("Delete a library item (admin only)").argument("<id>", "Library item ID").action(async function(id) {
+      const ctx = createContext(this);
+      try {
+        const data = await ctx.client.library.delete(id);
+        printSuccess("library.delete", data, ctx);
+      } catch (error2) {
+        printError("library.delete", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("catalog-jobs").description("Catalog completed generation jobs into the library (admin)").option("-t, --type <type>", "Filter jobs by asset type").option("--provider <id>", "Filter jobs by provider ID").option("--after <date>", "Only catalog jobs after this date").option("--dry-run", "Just count, don't actually catalog").action(async function() {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const body = {};
+        if (opts.type) body.asset_type = opts.type;
+        if (opts.provider) body.provider_id = opts.provider;
+        if (opts.after) body.after = opts.after;
+        if (opts.dryRun) body.dry_run = true;
+        const data = await ctx.client.library.catalogJobs(body);
+        printSuccess("library.catalog_jobs", data, ctx);
+      } catch (error2) {
+        printError("library.catalog_jobs", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("backfill").description("Queue library embedding/enrichment backfill jobs (admin)").option("-t, --asset-type <type>", "Filter by asset type").option("--since <date>", "Only backfill assets created after this RFC3339 date").option("-n, --limit <limit>", "Max items to enqueue", "100").option("--dry-run", "Return matching IDs without enqueueing jobs").action(async function() {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const request = {
+          asset_type: opts.assetType,
+          since: opts.since,
+          limit: Number(opts.limit),
+          dry_run: Boolean(opts.dryRun)
+        };
+        const data = await ctx.client.library.backfill(request);
+        printSuccess("library.backfill", data, ctx);
+      } catch (error2) {
+        printError("library.backfill", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("reenrich").description("Queue library re-enrichment jobs (admin)").option("--id <id>", "Library item ID (repeatable)", collect, []).option("-t, --asset-type <type>", "Filter by asset type").option("--taxonomy-version-lt <version>", "Only items below this taxonomy version").option("--force-visual", "Force visual/textual analysis", true).option("--no-force-visual", "Do not force visual/textual analysis").option("--recompute-embedding", "Recompute embedding vectors").option("-n, --limit <limit>", "Max items to enqueue", "100").action(async function() {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const request = {
+          ids: opts.id,
+          asset_type: opts.assetType,
+          taxonomy_version_lt: opts.taxonomyVersionLt ? Number(opts.taxonomyVersionLt) : void 0,
+          force_visual: opts.forceVisual,
+          recompute_embedding: Boolean(opts.recomputeEmbedding),
+          limit: Number(opts.limit)
+        };
+        const data = await ctx.client.library.reenrich(request);
+        printSuccess("library.reenrich", data, ctx);
+      } catch (error2) {
+        printError("library.reenrich", error2, ctx.human);
+      }
+    })
+  );
+  return command;
+}
+function collect(value, previous) {
+  previous.push(value);
+  return previous;
+}
+async function readBase64(filePath) {
+  try {
+    return (await readFile(filePath)).toString("base64");
+  } catch (error2) {
+    throw new AssetForgeError4(
+      `Failed to read file ${filePath}: ${error2 instanceof Error ? error2.message : String(error2)}`,
+      { code: "CONFIG_ERROR" }
+    );
+  }
+}
+
+// src/commands/pack.ts
+import { readFile as readFile2 } from "fs/promises";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output2 } from "process";
+import { AssetForgeError as AssetForgeError5 } from "@doufunao123/assetforge-sdk";
+import { Command as Command6 } from "commander";
+function createPackCommand() {
+  const command = new Command6("pack").description("Manage library asset packs");
+  command.addCommand(
+    new Command6("list").description("List installed library packs").action(async function() {
+      const ctx = createContext(this);
+      try {
+        const data = await ctx.client.library.packs();
+        printSuccess("pack.list", data, ctx);
+      } catch (error2) {
+        printError("pack.list", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command6("install").description("Install a library pack").argument("[source]", "Pack source (builtin, url, upload)").option("--source <source>", "Pack source (builtin, url, upload)").option("--id <id>", "Builtin pack ID").option("--version <version>", "Pack version").option("--url <url>", "HTTP tarball URL").option("--file <tarball>", "Local tarball to upload as base64").action(async function(sourceArg) {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        const source = opts.source ?? sourceArg;
+        if (!source) {
+          throw new AssetForgeError5("Pack source is required", { code: "CONFIG_ERROR" });
+        }
+        const request = {
+          source,
+          id: opts.id,
+          version: opts.version,
+          url: opts.url,
+          tarball_b64: opts.file ? await readBase642(opts.file) : void 0
+        };
+        const data = await ctx.client.library.packsInstall(request);
+        printSuccess("pack.install", data, ctx);
+      } catch (error2) {
+        printError("pack.install", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command6("delete").description("Delete a library pack (admin only)").argument("<id>", "Pack ID").option("-y, --yes", "Skip confirmation prompt").action(async function(id) {
+      const ctx = createContext(this);
+      const opts = this.opts();
+      try {
+        if (!opts.yes) {
+          await confirmDelete(id);
+        }
+        const data = await ctx.client.library.packsDelete(id);
+        printSuccess("pack.delete", data, ctx);
+      } catch (error2) {
+        printError("pack.delete", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command6("refresh").description("Refresh an installed library pack (admin only)").argument("<id>", "Pack ID").action(async function(id) {
+      const ctx = createContext(this);
+      try {
+        const data = await ctx.client.library.packsRefresh(id);
+        printSuccess("pack.refresh", data, ctx);
+      } catch (error2) {
+        printError("pack.refresh", error2, ctx.human);
+      }
+    })
+  );
+  return command;
+}
+async function readBase642(filePath) {
+  try {
+    return (await readFile2(filePath)).toString("base64");
+  } catch (error2) {
+    throw new AssetForgeError5(
+      `Failed to read file ${filePath}: ${error2 instanceof Error ? error2.message : String(error2)}`,
+      { code: "CONFIG_ERROR" }
+    );
+  }
+}
+async function confirmDelete(id) {
+  if (!input.isTTY) {
+    throw new AssetForgeError5("Refusing to delete pack without confirmation. Pass --yes to confirm.", {
+      code: "CONFIG_ERROR"
+    });
+  }
+  const rl = createInterface({ input, output: output2 });
+  try {
+    const answer = await rl.question(`Delete pack ${id}? Type the pack ID to confirm: `);
+    if (answer !== id) {
+      throw new AssetForgeError5("Pack deletion cancelled", { code: "CONFIG_ERROR" });
+    }
+  } finally {
+    rl.close();
+  }
+}
+
 // src/commands/process.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
-import { existsSync as existsSync3 } from "fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { join as join3 } from "path";
-import { Command as Command5 } from "commander";
-function readInputAsBase64(input) {
-  if (existsSync3(input)) {
-    const bytes = readFileSync2(input);
+import { Command as Command7 } from "commander";
+function readInputAsBase64(input2) {
+  if (existsSync4(input2)) {
+    const bytes = readFileSync3(input2);
     return `data:image/png;base64,${bytes.toString("base64")}`;
   }
-  return input;
+  return input2;
 }
 function saveProcessOutput(data, outputDir) {
-  const outputData = data.output_data;
-  if (typeof outputData !== "string" || !outputData) return null;
   mkdirSync3(outputDir, { recursive: true });
   const timestamp = Date.now();
+  const outputs = data.outputs;
+  if (Array.isArray(outputs) && outputs.length > 0) {
+    const localPaths = [];
+    for (let i = 0; i < outputs.length; i++) {
+      const item = outputs[i];
+      const b64 = item.output_data;
+      if (typeof b64 !== "string" || !b64) continue;
+      const filePath2 = join3(outputDir, `frame_${timestamp}_${String(i).padStart(4, "0")}.png`);
+      writeFileSync3(filePath2, Buffer.from(b64, "base64"));
+      localPaths.push(filePath2);
+    }
+    delete data.outputs;
+    data.local_paths = localPaths;
+    return localPaths[0] ?? null;
+  }
+  const outputData = data.output_data;
+  if (typeof outputData !== "string" || !outputData) return null;
   const filePath = join3(outputDir, `processed_${timestamp}.png`);
   writeFileSync3(filePath, Buffer.from(outputData, "base64"));
   delete data.output_data;
   return filePath;
 }
 function createProcessCommand() {
-  const command = new Command5("process").description("Post-process images (remove-bg, crop, resize, upscale)");
+  const command = new Command7("process").description("Post-process images (crop, resize, compose, remove-bg)");
   command.addCommand(
-    new Command5("remove-bg").description("Remove background from an image (AI-powered, BiRefNet)").requiredOption("--input <path>", "Input image (file path or URL)").option("--smart-crop", "Also crop to power-of-2 after removing background").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command7("crop").description("Smart crop an image (trim transparent borders)").requiredOption("--input <path>", "Input image (file path or URL)").option("--mode <mode>", "Crop mode: tightest or power_of2", "tightest").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
-        const ops = [{ op: "remove_bg" }];
-        if (options.smartCrop) {
-          ops.push({ op: "smart_crop", mode: "power_of2" });
-        }
-        const data = await ctx.client.post("/api/process", {
+        const data = await ctx.client.process({
           input: readInputAsBase64(options.input),
-          operations: ops
+          operations: [{ op: "smart_crop", mode: options.mode }]
         });
         const localPath = saveProcessOutput(data, options.outputDir);
         if (localPath) data.local_path = localPath;
-        printSuccess("process.remove-bg", data, ctx);
+        printSuccess("process.crop", data, ctx);
       } catch (error2) {
-        printError("process.remove-bg", error2);
+        printError("process.crop", error2);
       }
     })
   );
   command.addCommand(
-    new Command5("crop").description("Smart crop an image (trim transparent borders)").requiredOption("--input <path>", "Input image (file path or URL)").option("--mode <mode>", "Crop mode: tightest or power_of2", "tightest").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command7("resize").description("Resize an image to exact dimensions").requiredOption("--input <path>", "Input image (file path or URL)").requiredOption("--width <n>", "Target width").requiredOption("--height <n>", "Target height").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
-        const data = await ctx.client.post("/api/process", {
+        const data = await ctx.client.process({
           input: readInputAsBase64(options.input),
-          operations: [{ op: "smart_crop", mode: options.mode }]
+          operations: [{ op: "resize", width: Number(options.width), height: Number(options.height) }]
         });
         const localPath = saveProcessOutput(data, options.outputDir);
         if (localPath) data.local_path = localPath;
-        printSuccess("process.crop", data, ctx);
+        printSuccess("process.resize", data, ctx);
       } catch (error2) {
-        printError("process.crop", error2);
+        printError("process.resize", error2);
       }
     })
   );
   command.addCommand(
-    new Command5("resize").description("Resize an image to exact dimensions").requiredOption("--input <path>", "Input image (file path or URL)").requiredOption("--width <n>", "Target width").requiredOption("--height <n>", "Target height").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command7("compose").description("Compose multiple images into a sprite sheet").requiredOption("--input <paths...>", "Input images (files or URLs)").option("--direction <dir>", "Layout: horizontal, vertical, grid", "horizontal").option("--columns <n>", "Columns for grid layout").option("--padding <n>", "Padding between frames in px", "0").option("--frame-width <n>", "Normalize each frame to this width").option("--frame-height <n>", "Normalize each frame to this height").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
-        const data = await ctx.client.post("/api/process", {
-          input: readInputAsBase64(options.input),
-          operations: [{ op: "resize", width: Number(options.width), height: Number(options.height) }]
+        const inputs = Array.isArray(options.input) ? options.input : [options.input];
+        const data = await ctx.client.process({
+          inputs: inputs.map(readInputAsBase64),
+          operations: [{
+            op: "compose",
+            direction: options.direction,
+            columns: options.columns ? Number(options.columns) : void 0,
+            padding: Number(options.padding),
+            frame_width: options.frameWidth ? Number(options.frameWidth) : void 0,
+            frame_height: options.frameHeight ? Number(options.frameHeight) : void 0
+          }]
         });
         const localPath = saveProcessOutput(data, options.outputDir);
         if (localPath) data.local_path = localPath;
-        printSuccess("process.resize", data, ctx);
+        printSuccess("process.compose", data, ctx);
       } catch (error2) {
-        printError("process.resize", error2);
+        printError("process.compose", error2);
       }
     })
   );
   command.addCommand(
-    new Command5("upscale").description("AI upscale an image (2x or 4x via Real-ESRGAN)").requiredOption("--input <path>", "Input image (file path or URL)").option("--scale <n>", "Scale factor (2 or 4)", "4").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command7("remove-bg").description("Remove background from image(s)").requiredOption("--input <paths...>", "Input images (files or URLs)").option("--bg-color <color>", "Background color hint for fallback (e.g. white, black)").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
-        const data = await ctx.client.post("/api/process", {
-          input: readInputAsBase64(options.input),
-          operations: [{ op: "upscale", scale: Number(options.scale) }]
+        const inputs = Array.isArray(options.input) ? options.input : [options.input];
+        const op = { op: "remove_bg" };
+        if (options.bgColor) op.bg_color = options.bgColor;
+        const data = await ctx.client.process({
+          inputs: inputs.map(readInputAsBase64),
+          operations: [op]
         });
         const localPath = saveProcessOutput(data, options.outputDir);
         if (localPath) data.local_path = localPath;
-        printSuccess("process.upscale", data, ctx);
+        printSuccess("process.remove_bg", data, ctx);
       } catch (error2) {
-        printError("process.upscale", error2);
+        printError("process.remove_bg", error2);
       }
     })
   );
@@ -802,10 +1630,10 @@ function createProcessCommand() {
 }
 
 // src/commands/process3d.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
-import { Command as Command6 } from "commander";
-function infer3dExtension(format) {
+import { Command as Command8 } from "commander";
+function infer3dExtension2(format) {
   const map = {
     fbx: "fbx",
     usdz: "usdz",
@@ -817,11 +1645,32 @@ function infer3dExtension(format) {
   };
   return map[String(format ?? "glb").toLowerCase()] ?? "glb";
 }
+function inferMimeType2(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".png")) return "image/png";
+  if (lower.endsWith(".webp")) return "image/webp";
+  if (lower.endsWith(".gif")) return "image/gif";
+  return "application/octet-stream";
+}
+function toInputFile2(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (!existsSync5(value)) {
+    return value;
+  }
+  const b64 = readFileSync4(value).toString("base64");
+  return `data:${inferMimeType2(value)};base64,${b64}`;
+}
+function toJsonObject2(value) {
+  return value;
+}
 async function saveProcess3dOutput(data, operation, outputDir, format) {
   if (!data.output_url) {
     return null;
   }
-  const ext = infer3dExtension(format);
+  const ext = infer3dExtension2(format);
   const timestamp = Date.now();
   const filePath = join4(outputDir, `${operation}_${timestamp}.${ext}`);
   mkdirSync4(outputDir, { recursive: true });
@@ -834,63 +1683,73 @@ async function saveProcess3dOutput(data, operation, outputDir, format) {
   return filePath;
 }
 function createProcess3dCommand() {
-  const command = new Command6("process3d").description("3D model post-processing via Tripo pipeline");
+  const command = new Command8("process3d").description("3D model post-processing via Meshy AI");
   command.addCommand(
-    new Command6("convert").description("Convert 3D model format (FBX/USDZ/OBJ/STL/GLTF/3MF)").requiredOption("--task-id <id>", "Tripo task ID from generate model").requiredOption("--format <fmt>", "Target format: FBX, USDZ, OBJ, STL, GLTF, 3MF").option("--quad", "Enable quad remeshing").option("--face-limit <n>", "Max face count").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command8("remesh").description("Remesh a model and optionally change format or polygon count").option("--task-id <id>", "Meshy task ID").option("--model-url <url>", "Model URL to remesh without an existing task").requiredOption("--format <fmt>", "Target format: glb, fbx, obj, usdz, stl, 3mf").option("--polycount <n>", "Target polygon count").option("--topology <type>", "Topology type: triangle or quad").option("--auto-size", "Estimate real-world size automatically").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
+        if (!options.taskId && !options.modelUrl) {
+          throw new Error("Either --task-id or --model-url is required");
+        }
         const ctx = createContext(this);
         const params = {
-          format: options.format
+          target_formats: [options.format]
         };
-        if (options.quad) params.quad = true;
-        if (options.faceLimit) params.face_limit = Number(options.faceLimit);
-        const data = await ctx.client.post("/api/process3d", {
-          task_id: options.taskId,
-          operation: "convert",
-          params
+        if (options.modelUrl) params.model_url = options.modelUrl;
+        if (options.polycount) params.polycount = Number(options.polycount);
+        if (options.topology) params.topology = options.topology;
+        if (options.autoSize) params.auto_size = true;
+        const data = await ctx.client.process3d({
+          task_id: options.taskId ?? "",
+          operation: "remesh",
+          params: toJsonObject2(params)
         });
-        const localPath = await saveProcess3dOutput(data, "convert", options.outputDir, options.format);
+        const localPath = await saveProcess3dOutput(data, "remesh", options.outputDir, options.format);
         if (localPath) data.local_path = localPath;
-        printSuccess("process3d.convert", data, ctx);
+        printSuccess("process3d.remesh", data, ctx);
       } catch (error2) {
-        printError("process3d.convert", error2);
+        printError("process3d.remesh", error2);
       }
     })
   );
   command.addCommand(
-    new Command6("texture").description("Re-texture a 3D model with new materials").requiredOption("--task-id <id>", "Tripo task ID").option("--prompt <text>", "Texture description prompt").option("--pbr", "Enable PBR materials").option("--quality <q>", "Texture quality: standard or detailed").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command8("retexture").description("Regenerate textures for an existing Meshy model").requiredOption("--task-id <id>", "Meshy task ID").option("--prompt <text>", "Text style prompt for the new material pass").option("--style-image <input>", "Texture style reference image URL or local file path").option("--pbr", "Enable PBR materials").option("--hd-texture", "Request 4K texture output").option("--ai-model <name>", "Meshy model: meshy-5, meshy-6, latest").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
         const params = {};
-        if (options.prompt) params.prompt = options.prompt;
+        if (options.prompt) params.text_style_prompt = options.prompt;
+        if (options.styleImage) params.image_style_url = toInputFile2(options.styleImage);
         if (options.pbr) params.pbr = true;
-        if (options.quality) params.quality = options.quality;
-        const data = await ctx.client.post("/api/process3d", {
+        if (options.hdTexture) params.hd_texture = true;
+        if (options.aiModel) params.ai_model = options.aiModel;
+        const data = await ctx.client.process3d({
           task_id: options.taskId,
-          operation: "texture",
-          params
+          operation: "retexture",
+          params: toJsonObject2(params)
         });
-        const localPath = await saveProcess3dOutput(data, "texture", options.outputDir);
+        const localPath = await saveProcess3dOutput(data, "retexture", options.outputDir);
         if (localPath) data.local_path = localPath;
-        printSuccess("process3d.texture", data, ctx);
+        printSuccess("process3d.retexture", data, ctx);
       } catch (error2) {
-        printError("process3d.texture", error2);
+        printError("process3d.retexture", error2);
       }
     })
   );
   command.addCommand(
-    new Command6("rig").description("Auto-rig a 3D model (add skeleton for animation)").requiredOption("--task-id <id>", "Tripo task ID").option("--format <fmt>", "Output format: glb or fbx", "glb").option("--spec <spec>", "Rig spec: mixamo or tripo", "mixamo").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command8("rig").description("Rig a Meshy model for character animation").option("--task-id <id>", "Meshy task ID").option("--height <meters>", "Estimated character height in meters").option("--model-url <url>", "Model URL to rig without an existing task").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
+        if (!options.taskId && !options.modelUrl) {
+          throw new Error("Either --task-id or --model-url is required");
+        }
         const ctx = createContext(this);
-        const data = await ctx.client.post("/api/process3d", {
-          task_id: options.taskId,
+        const params = {};
+        if (options.height) params.height_meters = Number(options.height);
+        if (options.modelUrl) params.model_url = options.modelUrl;
+        const data = await ctx.client.process3d({
+          task_id: options.taskId ?? "",
           operation: "rig",
-          params: {
-            format: options.format,
-            spec: options.spec
-          }
+          params: toJsonObject2(params)
         });
-        const localPath = await saveProcess3dOutput(data, "rig", options.outputDir, options.format);
+        const localPath = await saveProcess3dOutput(data, "rig", options.outputDir);
         if (localPath) data.local_path = localPath;
         printSuccess("process3d.rig", data, ctx);
       } catch (error2) {
@@ -899,18 +1758,21 @@ function createProcess3dCommand() {
     })
   );
   command.addCommand(
-    new Command6("animate").description("Apply preset animation to a rigged model").requiredOption("--task-id <id>", "Tripo task ID (from rig step)").requiredOption("--animation <preset>", "Animation preset (e.g. preset:walk, preset:idle, preset:run)").option("--format <fmt>", "Output format: glb or fbx", "glb").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command8("animate").description("Apply a preset animation to a rigged Meshy character").requiredOption("--task-id <id>", "Meshy rigging task ID").requiredOption("--action-id <n>", "Animation preset ID (see docs for full list)").option("--fps <n>", "Target frame rate: 24, 25, 30, or 60").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
-        const data = await ctx.client.post("/api/process3d", {
+        const params = {
+          action_id: Number(options.actionId)
+        };
+        if (options.fps) {
+          params.fps = Number(options.fps);
+        }
+        const data = await ctx.client.process3d({
           task_id: options.taskId,
           operation: "animate",
-          params: {
-            animation: options.animation,
-            format: options.format
-          }
+          params: toJsonObject2(params)
         });
-        const localPath = await saveProcess3dOutput(data, "animate", options.outputDir, options.format);
+        const localPath = await saveProcess3dOutput(data, "animate", options.outputDir);
         if (localPath) data.local_path = localPath;
         printSuccess("process3d.animate", data, ctx);
       } catch (error2) {
@@ -919,162 +1781,233 @@ function createProcess3dCommand() {
     })
   );
   command.addCommand(
-    new Command6("reduce").description("Reduce polygon count (high-poly to low-poly)").requiredOption("--task-id <id>", "Tripo task ID").option("--face-limit <n>", "Target face count").option("--quad", "Use quad topology").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command8("refine").description("Refine a Meshy preview model into a higher quality result").requiredOption("--task-id <id>", "Meshy preview task ID").option("--pbr", "Enable PBR materials").option("--hd-texture", "Request 4K texture output").option("--texture-prompt <text>", "Optional texture prompt for the refinement pass").option("--ai-model <name>", "Meshy model: meshy-5, meshy-6, latest").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
       try {
         const ctx = createContext(this);
         const params = {};
-        if (options.faceLimit) params.face_limit = Number(options.faceLimit);
-        if (options.quad) params.quad = true;
-        const data = await ctx.client.post("/api/process3d", {
+        if (options.pbr) params.pbr = true;
+        if (options.hdTexture) params.hd_texture = true;
+        if (options.texturePrompt) params.texture_prompt = options.texturePrompt;
+        if (options.aiModel) params.ai_model = options.aiModel;
+        const data = await ctx.client.process3d({
           task_id: options.taskId,
-          operation: "reduce",
-          params
+          operation: "refine",
+          params: toJsonObject2(params)
         });
-        const localPath = await saveProcess3dOutput(data, "reduce", options.outputDir);
+        const localPath = await saveProcess3dOutput(data, "refine", options.outputDir);
         if (localPath) data.local_path = localPath;
-        printSuccess("process3d.reduce", data, ctx);
+        printSuccess("process3d.refine", data, ctx);
       } catch (error2) {
-        printError("process3d.reduce", error2);
+        printError("process3d.refine", error2);
       }
     })
   );
+  return command;
+}
+
+// src/commands/provider.ts
+import { Command as Command9 } from "commander";
+function createProviderCommand() {
+  const command = new Command9("provider").description("Provider management");
   command.addCommand(
-    new Command6("stylize").description("Apply artistic style to a model").requiredOption("--task-id <id>", "Tripo task ID").requiredOption("--style <style>", "Style: lego, voxel, voronoi, minecraft").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command9("list").description("List available providers").action(async function() {
       try {
         const ctx = createContext(this);
-        const data = await ctx.client.post("/api/process3d", {
-          task_id: options.taskId,
-          operation: "stylize",
-          params: {
-            style: options.style
-          }
-        });
-        const localPath = await saveProcess3dOutput(data, "stylize", options.outputDir);
-        if (localPath) data.local_path = localPath;
-        printSuccess("process3d.stylize", data, ctx);
+        const data = await ctx.client.providers.list();
+        printSuccess("provider.list", data, ctx);
       } catch (error2) {
-        printError("process3d.stylize", error2);
+        printError("provider.list", error2);
       }
     })
   );
   command.addCommand(
-    new Command6("segment").description("Segment mesh into logical parts").requiredOption("--task-id <id>", "Tripo task ID").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command9("health").description("Check provider health").argument("[name]", "Specific provider name").action(async function(name) {
       try {
         const ctx = createContext(this);
-        const data = await ctx.client.post("/api/process3d", {
-          task_id: options.taskId,
-          operation: "segment",
-          params: {}
-        });
-        const localPath = await saveProcess3dOutput(data, "segment", options.outputDir);
-        if (localPath) data.local_path = localPath;
-        printSuccess("process3d.segment", data, ctx);
+        const data = name ? await ctx.client.providers.health(name) : await ctx.client.providers.health();
+        printSuccess("provider.health", data, ctx);
       } catch (error2) {
-        printError("process3d.segment", error2);
+        printError("provider.health", error2);
       }
     })
   );
+  return command;
+}
+
+// src/commands/upload.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename } from "path";
+import { AssetForgeError as AssetForgeError6 } from "@doufunao123/assetforge-sdk";
+import { Command as Command10 } from "commander";
+function createUploadCommand() {
+  const command = new Command10("upload").description("Upload and manage assets");
   command.addCommand(
-    new Command6("prerigcheck").description("Check if a model can be rigged").requiredOption("--task-id <id>", "Tripo task ID").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+    new Command10("file").description("Upload a file and get a public URL").argument("<path>", "Path to file to upload").action(async function(filePath) {
+      const ctx = createContext(this);
       try {
-        const ctx = createContext(this);
-        const data = await ctx.client.post("/api/process3d", {
-          task_id: options.taskId,
-          operation: "prerigcheck",
-          params: {}
-        });
-        const localPath = await saveProcess3dOutput(data, "prerigcheck", options.outputDir);
-        if (localPath) data.local_path = localPath;
-        printSuccess("process3d.prerigcheck", data, ctx);
+        const content = await readLocalFile(filePath);
+        const data = await ctx.client.assets.upload(content, { filename: basename(filePath) });
+        printSuccess("asset.upload", data, ctx);
       } catch (error2) {
-        printError("process3d.prerigcheck", error2);
+        printError("asset.upload", error2, ctx.human);
       }
     })
   );
-  return command;
-}
-
-// src/commands/provider.ts
-import { Command as Command7 } from "commander";
-function createProviderCommand() {
-  const command = new Command7("provider").description("Provider management");
   command.addCommand(
-    new Command7("list").description("List available providers").action(async function() {
+    new Command10("list").description("List uploaded assets").action(async function() {
+      const ctx = createContext(this);
       try {
-        const ctx = createContext(this);
-        const data = await ctx.client.get("/api/providers");
-        printSuccess("provider.list", data, ctx);
+        const data = await ctx.client.assets.list();
+        printSuccess("asset.list", data, ctx);
       } catch (error2) {
-        printError("provider.list", error2);
+        printError("asset.list", error2, ctx.human);
       }
     })
   );
   command.addCommand(
-    new Command7("health").description("Check provider health").argument("[name]", "Specific provider name").action(async function(name) {
+    new Command10("delete").description("Delete an uploaded asset (admin only)").argument("<filename>", "Filename to delete").action(async function(filename) {
+      const ctx = createContext(this);
       try {
-        const ctx = createContext(this);
-        const path = name ? `/api/providers/${encodeURIComponent(name)}/health` : "/api/providers/health";
-        const data = await ctx.client.get(path);
-        printSuccess("provider.health", data, ctx);
+        const data = await ctx.client.assets.delete(filename);
+        printSuccess("asset.delete", data, ctx);
       } catch (error2) {
-        printError("provider.health", error2);
+        printError("asset.delete", error2, ctx.human);
       }
     })
   );
   return command;
 }
+async function readLocalFile(filePath) {
+  try {
+    return await readFile3(filePath);
+  } catch (error2) {
+    throw new AssetForgeError6(
+      `Failed to read file ${filePath}: ${error2 instanceof Error ? error2.message : String(error2)}`,
+      { code: "CONFIG_ERROR" }
+    );
+  }
+}
 
-// src/commands/upload.ts
-import { Command as Command8 } from "commander";
-function createUploadCommand() {
-  const command = new Command8("upload").description("Upload and manage assets");
+// src/commands/voice.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname3, extname as extname2 } from "path";
+import { Command as Command11 } from "commander";
+function createVoiceCommand() {
+  const command = new Command11("voice").description("Design, clone, list, and delete voices");
   command.addCommand(
-    new Command8("file").description("Upload a file and get a public URL").argument("<path>", "Path to file to upload").action(async function(filePath) {
+    new Command11("design").description("Generate a MiMo voice from a text description").requiredOption("--voice-prompt <text>", "Voice description / style prompt").requiredOption("--preview-text <text>", "Text to synthesize for preview").option("--style <text>", "Additional director/style instruction").option("--name <name>", "Save generated voice with this name").option("--save-as <name>", "Alias for --name").option("--output <path>", "Write preview WAV to this path").action(async function(options) {
       const ctx = createContext(this);
       try {
-        const data = await ctx.client.uploadFile(filePath);
-        printSuccess("asset.upload", data, ctx);
+        const request = {
+          voice_prompt: options.voicePrompt,
+          preview_text: options.previewText,
+          style: options.style,
+          name: options.name,
+          save_as: options.saveAs
+        };
+        const data = await ctx.client.voice.design(request);
+        const localPath = writeWavOutput(data, options.output);
+        if (localPath) data.local_path = localPath;
+        printSuccess("voice.design", data, ctx);
       } catch (error2) {
-        printError("asset.upload", error2, ctx.human);
+        printError("voice.design", error2, ctx.human);
       }
     })
   );
   command.addCommand(
-    new Command8("list").description("List uploaded assets").action(async function() {
+    new Command11("clone").description("Clone a MiMo voice from an mp3/wav sample").requiredOption("--audio <path-or-data-url>", "Voice sample mp3/wav file or data URL").requiredOption("--preview-text <text>", "Text to synthesize for preview").option("--audio-mime <mime>", "Audio MIME type when --audio is raw base64").option("--style <text>", "Director/style instruction").option("--name <name>", "Save cloned voice with this name").option("--save-as <name>", "Alias for --name").option("--output <path>", "Write preview WAV to this path").action(async function(options) {
       const ctx = createContext(this);
       try {
-        const data = await ctx.client.get("/api/assets");
-        printSuccess("asset.list", data, ctx);
+        const sample = readVoiceSample(options.audio, options.audioMime);
+        const request = {
+          ...sample,
+          preview_text: options.previewText,
+          style: options.style,
+          name: options.name,
+          save_as: options.saveAs
+        };
+        const data = await ctx.client.voice.clone(request);
+        const localPath = writeWavOutput(data, options.output);
+        if (localPath) data.local_path = localPath;
+        printSuccess("voice.clone", data, ctx);
       } catch (error2) {
-        printError("asset.list", error2, ctx.human);
+        printError("voice.clone", error2, ctx.human);
       }
     })
   );
   command.addCommand(
-    new Command8("delete").description("Delete an uploaded asset (admin only)").argument("<filename>", "Filename to delete").action(async function(filename) {
+    new Command11("list").description("List saved voices").option("--type <type>", "Voice type: vc or vd").action(async function(options) {
       const ctx = createContext(this);
       try {
-        const data = await ctx.client.delete(`/api/assets/${encodeURIComponent(filename)}`);
-        printSuccess("asset.delete", data, ctx);
+        const data = await ctx.client.voice.list({ type: options.type });
+        printSuccess("voice.list", data, ctx);
       } catch (error2) {
-        printError("asset.delete", error2, ctx.human);
+        printError("voice.list", error2, ctx.human);
+      }
+    })
+  );
+  command.addCommand(
+    new Command11("delete").description("Delete a saved voice").argument("<voice-id>", "Voice ID").option("--type <type>", "Voice type: vc or vd").action(async function(voiceId, options) {
+      const ctx = createContext(this);
+      try {
+        const data = await ctx.client.voice.delete(voiceId, { type: options.type });
+        printSuccess("voice.delete", data, ctx);
+      } catch (error2) {
+        printError("voice.delete", error2, ctx.human);
       }
     })
   );
   return command;
 }
+function readVoiceSample(input2, audioMime) {
+  if (input2.startsWith("data:")) {
+    return { sample_data_url: input2 };
+  }
+  if (existsSync6(input2)) {
+    return {
+      audio_base64: readFileSync5(input2).toString("base64"),
+      audio_mime: audioMime ?? inferAudioMime(input2)
+    };
+  }
+  return { audio_base64: input2, audio_mime: audioMime ?? "audio/wav" };
+}
+function inferAudioMime(filePath) {
+  const ext = extname2(filePath).toLowerCase();
+  if (ext === ".mp3") return "audio/mpeg";
+  if (ext === ".wav") return "audio/wav";
+  return "audio/wav";
+}
+function writeWavOutput(data, outputPath) {
+  if (!outputPath) {
+    return null;
+  }
+  const raw = data.wav_base64 ?? data.output_data;
+  if (typeof raw !== "string" || !raw) {
+    return null;
+  }
+  mkdirSync5(dirname3(outputPath), { recursive: true });
+  writeFileSync5(outputPath, Buffer.from(stripDataUri2(raw), "base64"));
+  return outputPath;
+}
+function stripDataUri2(data) {
+  const idx = data.indexOf(";base64,");
+  return idx >= 0 ? data.slice(idx + 8) : data;
+}
 
 // src/index.ts
-var program = new Command9().name("asset-gateway").description("Universal asset generation gateway CLI").version(CLI_VERSION).option(
+var program = new Command12().name("asset-gateway").description("Universal asset generation gateway CLI").version(CLI_VERSION).option(
   "--gateway-url <url>",
   `Gateway URL (default: $ASSET_GATEWAY_URL, auth config, or ${DEFAULT_GATEWAY_URL})`
 ).option("--token <token>", "API token for authentication").option("--human", "Human-readable output instead of JSON").option("--fields <fields>", "Comma-separated list of output fields");
 program.addCommand(createAuthCommand());
 program.addCommand(createGenerateCommand());
+program.addCommand(createLibraryCommand());
+program.addCommand(createPackCommand());
 program.addCommand(createProcessCommand());
 program.addCommand(createProcess3dCommand());
 program.addCommand(createProviderCommand());
 program.addCommand(createUploadCommand());
 program.addCommand(createJobCommand());
+program.addCommand(createVoiceCommand());
 program.addCommand(createDescribeCommand());
 await program.parseAsync(process.argv);