@doufunao123/asset-gateway 0.1.0

package/README.md

@@ -0,0 +1,86 @@
+# @doufunao123/asset-gateway
+
+Lightweight npm CLI client for the universal asset generation gateway.
+
+## Install
+
+```bash
+npm install -g @doufunao123/asset-gateway
+```
+
+Or run directly:
+
+```bash
+npx @doufunao123/asset-gateway provider list
+```
+
+## Quick Start
+
+```bash
+# 1. Save your API token
+asset-gateway auth set agk_xxx
+
+# 2. Generate assets
+asset-gateway generate image --prompt "a red dragon"
+asset-gateway generate video --prompt "ocean waves at sunset"
+```
+
+## Authentication
+
+Supports `agk_` admin tokens or plain API keys.
+
+**Resolution order:**
+
+1. `--token <token>` CLI flag
+2. `ASSET_GATEWAY_TOKEN` environment variable
+3. `~/.config/asset-gateway/auth.json` (saved via `auth set`)
+
+Config file format:
+
+```json
+{
+  "token": "agk_...",
+  "gateway_url": "https://assets.xiaomao.chat"
+}
+```
+
+## Commands
+
+```bash
+# Auth
+asset-gateway auth set <token>        # Save token locally
+asset-gateway auth status             # Show current auth state
+asset-gateway auth clear              # Remove saved credentials
+
+# Generate
+asset-gateway generate image --prompt "a cat" --size 1024x1024
+asset-gateway generate image --prompt "icon" --transparent --provider flux
+asset-gateway generate video --prompt "ocean waves"
+asset-gateway generate audio --prompt "epic battle" --type bgm --duration 30
+asset-gateway generate model --image https://example.com/ref.png
+asset-gateway generate text --prompt "describe a forest" --model gpt-5.4
+
+# Providers
+asset-gateway provider list
+asset-gateway provider health
+asset-gateway provider health flux
+
+# Jobs
+asset-gateway job list
+asset-gateway job list --status pending --limit 10
+asset-gateway job status <id>
+asset-gateway job cancel <id>
+
+# Self-describe (JSON Schema)
+asset-gateway describe
+asset-gateway describe generate
+```
+
+## Output
+
+JSON by default. Use `--human` for readable output, `--fields` to filter:
+
+```bash
+asset-gateway provider list --human
+asset-gateway job status abc123 --fields "status,created_at"
+```

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,688 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/auth.ts
+import { existsSync as existsSync2, unlinkSync } from "fs";
+import { Command } from "commander";
+
+// src/config.ts
+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));
+}
+
+// src/meta.ts
+var CLI_NAME = "asset-gateway";
+var CLI_VERSION = "0.1.0";
+var CLI_DESCRIPTION = "Universal asset generation gateway CLI";
+var DEFAULT_GATEWAY_URL = "https://assets.xiaomao.chat";
+
+// src/config.ts
+function configDir() {
+  return join(homedir(), ".config", "asset-gateway");
+}
+function configPath() {
+  return join(configDir(), "auth.json");
+}
+function loadAuthConfig() {
+  const path = configPath();
+  if (!existsSync(path)) {
+    return {};
+  }
+  const content = readFileSync(path, "utf8");
+  if (!content.trim()) {
+    return {};
+  }
+  try {
+    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)}`
+    );
+  }
+}
+function saveAuthConfig(config) {
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  chmodSync(path, 384);
+}
+function resolveGatewayUrl(overrides) {
+  return overrides?.gatewayUrl ?? process.env.ASSET_GATEWAY_URL ?? loadAuthConfig().gateway_url ?? DEFAULT_GATEWAY_URL;
+}
+function resolveToken(overrides) {
+  return overrides?.token ?? process.env.ASSET_GATEWAY_TOKEN ?? loadAuthConfig().token;
+}
+
+// src/output.ts
+function success(command, data) {
+  return { ok: true, command, data };
+}
+function error(command, code, message, suggestion) {
+  return {
+    ok: false,
+    command,
+    error: { code, message, ...suggestion ? { suggestion } : {} }
+  };
+}
+function output(result, human = false) {
+  if (human) {
+    if (result.ok) {
+      console.log(`\u2713 ${result.command}`);
+      console.log(formatHuman(result.data));
+    } else {
+      console.error(`\u2717 ${result.command}: ${result.error.message}`);
+      if (result.error.suggestion) {
+        console.error(`  \u2192 ${result.error.suggestion}`);
+      }
+    }
+  } else {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  }
+}
+function filterFields(data, fields) {
+  if (!fields) return data;
+  const allowed = new Set(fields.split(",").map((f) => f.trim()));
+  const filtered = {};
+  for (const key of allowed) {
+    if (key in data) {
+      filtered[key] = data[key];
+    }
+  }
+  return filtered;
+}
+function formatHuman(data, indent = 0) {
+  if (data === null || data === void 0) return "";
+  if (typeof data === "string") return " ".repeat(indent) + data;
+  if (typeof data !== "object") return " ".repeat(indent) + String(data);
+  const pad = " ".repeat(indent);
+  if (Array.isArray(data)) {
+    return data.map((item) => formatHuman(item, indent + 2)).join("\n");
+  }
+  return Object.entries(data).map(([key, val]) => {
+    if (typeof val === "object" && val !== null) {
+      return `${pad}${key}:
+${formatHuman(val, indent + 2)}`;
+    }
+    return `${pad}${key}: ${val}`;
+  }).join("\n");
+}
+
+// src/client.ts
+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 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.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
+function getGlobalOptions(command) {
+  return command.optsWithGlobals();
+}
+function createContext(command, requireAuth = true) {
+  const globals = getGlobalOptions(command);
+  const url = resolveGatewayUrl({ gatewayUrl: globals.gatewayUrl });
+  const token = resolveToken({ token: globals.token });
+  if (requireAuth && !token) {
+    throw configError(
+      "Authentication required. Use --token, set ASSET_GATEWAY_TOKEN, or run asset-gateway auth set <token>.",
+      "asset-gateway auth set <token>"
+    );
+  }
+  return {
+    client: new GatewayClient(url, token),
+    human: Boolean(globals.human),
+    fields: globals.fields
+  };
+}
+function printSuccess(commandName, data, ctx) {
+  const filtered = isRecord(data) ? filterFields(data, ctx.fields) : data;
+  output(success(commandName, filtered), ctx.human);
+}
+function printError(commandName, err, human = false) {
+  const normalized = normalizeError(err);
+  output(
+    error(commandName, normalized.code, normalized.message, normalized.suggestion),
+    human
+  );
+  process.exit(normalized.exitCode);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/commands/auth.ts
+function createAuthCommand() {
+  const command = new Command("auth").description("Credential management");
+  command.addCommand(
+    new Command("set").description("Save token and gateway URL locally").argument("<token>", "API token (agk_ prefix for admin, or any API key)").action(function(token) {
+      const globals = this.optsWithGlobals();
+      try {
+        const current = loadAuthConfig();
+        const gatewayUrl = resolveGatewayUrl({ gatewayUrl: globals.gatewayUrl });
+        saveAuthConfig({ ...current, token, gateway_url: gatewayUrl });
+        output(
+          success("auth.set", { saved: true, gateway_url: gatewayUrl }),
+          Boolean(globals.human)
+        );
+      } catch (error2) {
+        printError("auth.set", error2);
+      }
+    })
+  );
+  command.addCommand(
+    new Command("status").description("Show current authentication status").action(function() {
+      const globals = this.optsWithGlobals();
+      const config = loadAuthConfig();
+      const path = configPath();
+      output(
+        success("auth.status", {
+          config_path: path,
+          has_token: Boolean(config.token),
+          token_preview: config.token ? mask(config.token) : null,
+          gateway_url: config.gateway_url ?? null
+        }),
+        Boolean(globals.human)
+      );
+    })
+  );
+  command.addCommand(
+    new Command("clear").description("Remove saved credentials").action(function() {
+      const globals = this.optsWithGlobals();
+      const path = configPath();
+      if (existsSync2(path)) {
+        unlinkSync(path);
+      }
+      output(success("auth.clear", { cleared: true }), Boolean(globals.human));
+    })
+  );
+  return command;
+}
+function mask(token) {
+  if (token.length <= 12) return "***";
+  return `${token.slice(0, 8)}...${token.slice(-4)}`;
+}
+
+// src/commands/describe.ts
+import { Command as Command2 } from "commander";
+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)" } }
+      },
+      status: { description: "Show current authentication status" },
+      clear: { description: "Remove saved credentials" }
+    }
+  },
+  generate: {
+    description: "Generate assets via the gateway",
+    subcommands: {
+      image: {
+        description: "Generate an image from a text prompt",
+        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" }
+        }
+      },
+      video: {
+        description: "Generate a video from a text prompt",
+        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" }
+        }
+      },
+      audio: {
+        description: "Generate audio from a text prompt",
+        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" }
+        }
+      },
+      model: {
+        description: "Generate a 3D model",
+        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" }
+        }
+      },
+      text: {
+        description: "Generate text via LLM",
+        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" }
+        }
+      }
+    }
+  },
+  provider: {
+    description: "Provider management",
+    subcommands: {
+      list: { description: "List available providers" },
+      health: {
+        description: "Check provider health",
+        params: { name: { type: "string", required: false, description: "Specific provider name" } }
+      }
+    }
+  },
+  job: {
+    description: "Job management",
+    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: {
+        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" } }
+      }
+    }
+  },
+  describe: {
+    description: "Self-describe available commands (JSON Schema)",
+    params: {
+      command: { type: "string", required: false, description: "Specific command to describe" }
+    }
+  }
+};
+function createDescribeCommand() {
+  return new Command2("describe").description("Self-describe available commands (JSON Schema)").argument("[command]", "Specific command to describe").action(function(commandArg) {
+    const globals = this.optsWithGlobals();
+    if (!commandArg) {
+      output(
+        success("describe", {
+          name: CLI_NAME,
+          version: CLI_VERSION,
+          description: CLI_DESCRIPTION,
+          commands: SCHEMAS
+        }),
+        globals.human
+      );
+      return;
+    }
+    const schema = SCHEMAS[commandArg];
+    if (!schema) {
+      output(
+        success("describe", {
+          error: `Unknown command: ${commandArg}`,
+          available: Object.keys(SCHEMAS)
+        }),
+        globals.human
+      );
+      return;
+    }
+    output(success("describe", { command: commandArg, schema }), globals.human);
+  });
+}
+
+// src/commands/generate.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { Command as Command3 } from "commander";
+function inferExtension(assetType) {
+  const map = { image: "png", audio: "mp3", video: "mp4", model3d: "glb", text: "txt" };
+  return map[assetType] ?? "bin";
+}
+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);
+  const timestamp = Date.now();
+  const filename = `${assetType}_${timestamp}.${ext}`;
+  mkdirSync2(outputDir, { recursive: true });
+  const filePath = join2(outputDir, filename);
+  if (result.output_data) {
+    const raw = String(result.output_data);
+    if (assetType === "text") {
+      writeFileSync2(filePath, raw, "utf8");
+    } else {
+      const base64 = stripDataUri(raw);
+      writeFileSync2(filePath, Buffer.from(base64, "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 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("--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;
+        const data = await ctx.client.post("/api/generate", body);
+        const localPath = await saveOutput(data, "image", options.outputDir);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.image", data, ctx);
+      } catch (error2) {
+        printError("generate.image", error2);
+      }
+    })
+  );
+  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) {
+      try {
+        const ctx = createContext(this);
+        const body = {
+          asset_type: "video",
+          prompt: options.prompt
+        };
+        if (options.provider) body.provider = options.provider;
+        const data = await ctx.client.post("/api/generate", body);
+        const localPath = await saveOutput(data, "video", options.outputDir);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.video", data, ctx);
+      } catch (error2) {
+        printError("generate.video", error2);
+      }
+    })
+  );
+  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) {
+      try {
+        const ctx = createContext(this);
+        const body = {
+          asset_type: "audio",
+          prompt: options.prompt
+        };
+        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);
+        const localPath = await saveOutput(data, "audio", options.outputDir);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.audio", data, ctx);
+      } catch (error2) {
+        printError("generate.audio", error2);
+      }
+    })
+  );
+  command.addCommand(
+    new Command3("model").description("Generate a 3D model").option("--image <url>", "Reference image URL").option("--prompt <text>", "Model description prompt").option("--output-dir <dir>", "Directory to save output", ".").action(async function(options) {
+      try {
+        const ctx = createContext(this);
+        const body = {
+          asset_type: "model3d"
+        };
+        if (options.image) body.image_url = options.image;
+        if (options.prompt) body.prompt = options.prompt;
+        const data = await ctx.client.post("/api/generate", body);
+        const localPath = await saveOutput(data, "model3d", options.outputDir);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.model", data, ctx);
+      } catch (error2) {
+        printError("generate.model", error2);
+      }
+    })
+  );
+  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) {
+      try {
+        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);
+        if (localPath) data.local_path = localPath;
+        printSuccess("generate.text", data, ctx);
+      } catch (error2) {
+        printError("generate.text", 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) {
+      try {
+        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);
+      } 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.get(`/api/jobs/${encodeURIComponent(id)}`);
+        printSuccess("job.status", data, ctx);
+      } catch (error2) {
+        printError("job.status", error2);
+      }
+    })
+  );
+  command.addCommand(
+    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`);
+        printSuccess("job.cancel", data, ctx);
+      } catch (error2) {
+        printError("job.cancel", error2);
+      }
+    })
+  );
+  return command;
+}
+
+// src/commands/provider.ts
+import { Command as Command5 } from "commander";
+function createProviderCommand() {
+  const command = new Command5("provider").description("Provider management");
+  command.addCommand(
+    new Command5("list").description("List available providers").action(async function() {
+      try {
+        const ctx = createContext(this);
+        const data = await ctx.client.get("/api/providers");
+        printSuccess("provider.list", data, ctx);
+      } catch (error2) {
+        printError("provider.list", error2);
+      }
+    })
+  );
+  command.addCommand(
+    new Command5("health").description("Check provider health").argument("[name]", "Specific provider name").action(async function(name) {
+      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);
+      } catch (error2) {
+        printError("provider.health", error2);
+      }
+    })
+  );
+  return command;
+}
+
+// src/index.ts
+var program = new Command6().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(createProviderCommand());
+program.addCommand(createJobCommand());
+program.addCommand(createDescribeCommand());
+await program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@doufunao123/asset-gateway",
+  "version": "0.1.0",
+  "description": "Universal asset generation gateway CLI",
+  "type": "module",
+  "bin": {
+    "asset-gateway": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fran0220/agent-skills.git",
+    "directory": "asset-gateway/npm"
+  },
+  "author": "doufunao123",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.0"
+  }
+}