svmc-cli 1.0.0

package/README.md

@@ -0,0 +1,89 @@
+# svmc-cli
+
+将 `media-center-frontend` 的图生图能力封装为可供 Agent 调用的命令行工具。
+
+## 安装与构建
+
+```bash
+npm install
+npm run build
+```
+
+本地调试：
+
+```bash
+npm run dev -- --help
+```
+
+## 鉴权
+
+```bash
+svmc auth
+```
+
+该命令会引导输入 `SVMC_ACCESS_TOKEN` 并写入 `~/.svmc/config.toml`。
+服务地址默认固定使用生产环境 `https://media.sailvan.com/api/v1`（`auth` 不再询问 base_url）。
+如果接口需要会话态，可在 `auth` 时一并保存 Cookie（也可后续通过 `--cookie` 或 `SVMC_COOKIE` 传入）。
+
+验证认证状态：
+
+```bash
+svmc auth status
+```
+
+## 获取参数规格
+
+```bash
+svmc image specs --provider nano-banana
+```
+
+需要显式传 Cookie 时：
+
+```bash
+svmc image specs --provider nano-banana --cookie "session=...; sl-session=..."
+```
+
+仅列出 provider 列表：
+
+```bash
+svmc image specs
+```
+
+## 发起图生图任务
+
+```bash
+svmc image generate \
+  --provider nano-banana \
+  --input "img1.jpg" \
+  --input "img2.png" \
+  --prompt "cyberpunk style" \
+  --ratio "16:9"
+```
+
+支持传递动态参数（会原样透传给后端）：
+
+```bash
+svmc image generate ... --steps 20 --guidance_scale 7 --cookie "session=...; sl-session=..."
+```
+
+任务轮询间隔固定 5 秒，完成后输出：
+
+```text
+IMAGE_SAVED: /abs/path/to/file.jpg
+MEDIA:/abs/path/to/file.jpg
+```
+
+## 端到端验收脚本
+
+1. `svmc auth`，写入 token。
+2. `svmc image specs --provider <provider>`，确认返回规格。
+3. `svmc image generate --provider <provider> --input <img> --prompt "..."`。
+4. 观察输出包含 `IMAGE_SAVED` 和 `MEDIA`，并确认本地文件存在。
+
+## 质量命令
+
+```bash
+npm run lint:eslint
+npm run type-check
+npm test
+```

package/bin/svmc.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const { run } = require("../dist/src/index.js");
+
+run(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+});

package/dist/src/commands/auth.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAuthCommand = runAuthCommand;
+exports.runAuthStatusCommand = runAuthStatusCommand;
+const prompts_1 = require("@inquirer/prompts");
+const apiClient_1 = require("../core/apiClient");
+const config_1 = require("../core/config");
+const errors_1 = require("../core/errors");
+async function runAuthCommand(options) {
+    const resolvedConfigPath = (0, config_1.getConfigPath)(options.configPath);
+    const currentConfig = await (0, config_1.loadConfig)(resolvedConfigPath);
+    const hasExisting = Boolean(currentConfig.auth.access_token?.trim());
+    if (hasExisting) {
+        const shouldOverwrite = await (0, prompts_1.confirm)({
+            message: `检测到已有 token，是否覆盖？(${resolvedConfigPath})`,
+            default: false,
+        });
+        if (!shouldOverwrite) {
+            process.stdout.write("已取消覆盖，保留现有配置。\n");
+            return;
+        }
+    }
+    const accessToken = options.token?.trim() ||
+        (await (0, prompts_1.password)({
+            message: "请输入 SVMC_ACCESS_TOKEN",
+            mask: "*",
+            validate: (value) => (value.trim() ? true : "Token 不能为空"),
+        }));
+    const cookie = options.cookie?.trim() ||
+        (await (0, prompts_1.input)({
+            message: "请输入可选 Cookie",
+            default: currentConfig.auth.cookie ?? "",
+        }));
+    const nextConfig = {
+        auth: {
+            access_token: accessToken.trim(),
+            cookie: cookie.trim() || undefined,
+        },
+        server: { base_url: currentConfig.server.base_url },
+    };
+    await (0, config_1.saveConfig)(nextConfig, resolvedConfigPath);
+    const verifyConfig = await (0, config_1.loadConfig)(resolvedConfigPath);
+    if (verifyConfig.auth.access_token !== nextConfig.auth.access_token) {
+        throw new errors_1.CliError("配置写入校验失败，请重试。", errors_1.EXIT_CODES.IO);
+    }
+    process.stdout.write(`AUTH_OK: ${resolvedConfigPath}\n`);
+}
+async function runAuthStatusCommand(options) {
+    try {
+        const token = await (0, config_1.getAccessToken)(options.configPath);
+        const baseUrl = await (0, config_1.getBaseUrl)(undefined, options.configPath);
+        const cookie = await (0, config_1.getSessionCookie)(options.cookie, options.configPath);
+        const client = new apiClient_1.ApiClient(baseUrl, token, cookie);
+        await client.get("/image_generation/params");
+        process.stdout.write(`AUTH_STATUS: OK (${baseUrl})\n`);
+    }
+    catch (error) {
+        process.stdout.write("AUTH_STATUS: FAIL\n");
+        throw error;
+    }
+}

package/dist/src/commands/image.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runImageSpecsCommand = runImageSpecsCommand;
+exports.runImageGenerateCommand = runImageGenerateCommand;
+const node_path_1 = require("node:path");
+const apiClient_1 = require("../core/apiClient");
+const config_1 = require("../core/config");
+const downloader_1 = require("../core/downloader");
+const errors_1 = require("../core/errors");
+const parser_1 = require("../core/parser");
+const poller_1 = require("../core/poller");
+async function runImageSpecsCommand(options) {
+    const token = await (0, config_1.getAccessToken)(options.configPath);
+    const baseUrl = await (0, config_1.getBaseUrl)(options.baseUrl, options.configPath);
+    const cookie = await (0, config_1.getSessionCookie)(options.cookie, options.configPath);
+    const client = new apiClient_1.ApiClient(baseUrl, token, cookie);
+    const params = await client.get("/image_generation/params");
+    const suppliers = params.img2img?.for_supplier ?? {};
+    if (!options.provider) {
+        process.stdout.write(`${JSON.stringify({ providers: Object.keys(suppliers) }, null, 2)}\n`);
+        return;
+    }
+    const providerSpec = suppliers[options.provider];
+    if (!providerSpec) {
+        throw new errors_1.CliError(`未找到 provider: ${options.provider}`, errors_1.EXIT_CODES.USAGE);
+    }
+    process.stdout.write(`${JSON.stringify({ provider: options.provider, spec: providerSpec }, null, 2)}\n`);
+}
+async function runImageGenerateCommand(options) {
+    const parsed = (0, parser_1.parseGenerateCliArgs)(options.rawArgs);
+    await (0, parser_1.ensureInputsReadable)(parsed.input);
+    const token = await (0, config_1.getAccessToken)(options.configPath);
+    const baseUrl = await (0, config_1.getBaseUrl)(parsed.baseUrl, options.configPath);
+    const cookie = await (0, config_1.getSessionCookie)(parsed.cookie, options.configPath);
+    const client = new apiClient_1.ApiClient(baseUrl, token, cookie);
+    const imageData = await (0, parser_1.readImagesAsDataUrls)(parsed.input);
+    const submitPayload = {
+        supplier: parsed.provider,
+        image: imageData,
+        ...parsed.dynamicParams,
+    };
+    if (parsed.prompt) {
+        submitPayload.prompt = parsed.prompt;
+    }
+    if (parsed.ratio) {
+        submitPayload.ratio = parsed.ratio;
+    }
+    if (parsed.verbose) {
+        process.stdout.write(`[generate] provider=${parsed.provider} images=${imageData.length}\n`);
+    }
+    const submittedTask = await client.post("/image_generation/img2img", submitPayload);
+    const taskUuid = submittedTask.task_uuid;
+    if (!taskUuid) {
+        throw new errors_1.CliError("提交成功但未返回 task_uuid。", errors_1.EXIT_CODES.API);
+    }
+    process.stdout.write(`TASK_UUID: ${taskUuid}\n`);
+    const completedTask = await (0, poller_1.pollTaskUntilDone)(() => client.get(`/image_generation/get_task?task_uuid=${taskUuid}`), {
+        intervalMs: 5000,
+        timeoutMs: parsed.timeoutSec * 1000,
+        verbose: parsed.verbose,
+    });
+    const results = completedTask.results ?? [];
+    if (results.length === 0) {
+        throw new errors_1.CliError("任务已完成，但未返回任何图片结果。", errors_1.EXIT_CODES.TASK_FAILED);
+    }
+    const outputDir = parsed.outputDir ? (0, node_path_1.join)(process.cwd(), parsed.outputDir) : process.cwd();
+    for (let index = 0; index < results.length; index += 1) {
+        const item = results[index];
+        if (!item.result_url) {
+            continue;
+        }
+        const name = `img2img_${taskUuid}_${Date.now()}_${index + 1}.${item.format || "jpg"}`;
+        const localPath = await (0, downloader_1.downloadToLocal)(item.result_url, outputDir, name);
+        process.stdout.write(`IMAGE_SAVED: ${localPath}\n`);
+        process.stdout.write(`MEDIA:${localPath}\n`);
+    }
+}

package/dist/src/core/apiClient.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const errors_1 = require("./errors");
+class ApiClient {
+    baseUrl;
+    accessToken;
+    sessionCookie;
+    defaultTimeoutMs;
+    constructor(baseUrl, accessToken, sessionCookie, defaultTimeoutMs = 30000) {
+        this.baseUrl = baseUrl;
+        this.accessToken = accessToken;
+        this.sessionCookie = sessionCookie;
+        this.defaultTimeoutMs = defaultTimeoutMs;
+    }
+    async get(path) {
+        return this.request(path, { method: "GET" });
+    }
+    async post(path, body) {
+        return this.request(path, { method: "POST", body });
+    }
+    async request(path, options) {
+        const controller = new AbortController();
+        const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const url = `${this.baseUrl}${path}`;
+        try {
+            const response = await fetch(url, {
+                method: options.method ?? "GET",
+                signal: controller.signal,
+                headers: buildHeaders(this.accessToken, this.sessionCookie),
+                body: options.body ? JSON.stringify(options.body) : undefined,
+            });
+            const text = await response.text();
+            const payload = text ? safeJsonParse(text) : null;
+            if (!response.ok) {
+                const errorMessage = extractErrorMessage(payload) ?? (text || response.statusText);
+                if (response.status === 401) {
+                    throw new errors_1.CliError(`鉴权失败(401): ${errorMessage}`, errors_1.EXIT_CODES.AUTH);
+                }
+                throw new errors_1.CliError(`请求失败(${response.status}) ${path}: ${errorMessage}`, errors_1.EXIT_CODES.API);
+            }
+            return unwrapApiEnvelope(payload);
+        }
+        catch (error) {
+            if (error instanceof errors_1.CliError) {
+                throw error;
+            }
+            if (error.name === "AbortError") {
+                throw new errors_1.CliError(`请求超时: ${path}`, errors_1.EXIT_CODES.API);
+            }
+            throw new errors_1.CliError(`网络请求异常: ${error.message}`, errors_1.EXIT_CODES.API);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+exports.ApiClient = ApiClient;
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { message: text };
+    }
+}
+function extractErrorMessage(payload) {
+    if (!payload || typeof payload !== "object") {
+        return null;
+    }
+    const maybeMessage = payload.message;
+    if (typeof maybeMessage === "string") {
+        return maybeMessage;
+    }
+    const maybeDetail = payload.detail;
+    if (typeof maybeDetail === "string") {
+        return maybeDetail;
+    }
+    return null;
+}
+function buildHeaders(token, cookie) {
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+    };
+    if (cookie?.trim()) {
+        headers.Cookie = cookie.trim();
+    }
+    return headers;
+}
+function unwrapApiEnvelope(payload) {
+    if (!payload || typeof payload !== "object") {
+        return payload;
+    }
+    const record = payload;
+    if (typeof record.code !== "number") {
+        return payload;
+    }
+    if (record.code !== 200) {
+        const message = typeof record.message === "string" ? record.message : "接口返回错误";
+        if (record.code === 401) {
+            throw new errors_1.CliError(`鉴权失败(401): ${message}`, errors_1.EXIT_CODES.AUTH);
+        }
+        throw new errors_1.CliError(`请求失败(${record.code}): ${message}`, errors_1.EXIT_CODES.API);
+    }
+    return record.data;
+}

package/dist/src/core/config.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BASE_URL = void 0;
+exports.getConfigPath = getConfigPath;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.getAccessToken = getAccessToken;
+exports.getSessionCookie = getSessionCookie;
+exports.getBaseUrl = getBaseUrl;
+exports.normalizeBaseUrl = normalizeBaseUrl;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const toml_1 = require("@iarna/toml");
+const errors_1 = require("./errors");
+const DEFAULT_CONFIG_PATH = (0, node_path_1.join)((0, node_os_1.homedir)(), ".svmc", "config.toml");
+exports.DEFAULT_BASE_URL = "https://media.sailvan.com/api/v1";
+const EMPTY_CONFIG = {
+    auth: { access_token: "" },
+    server: {},
+};
+function getConfigPath(overridePath) {
+    return overridePath ?? process.env.SVMC_CONFIG_PATH ?? DEFAULT_CONFIG_PATH;
+}
+async function loadConfig(configPath) {
+    const resolved = getConfigPath(configPath);
+    try {
+        const content = await (0, promises_1.readFile)(resolved, "utf8");
+        const raw = (0, toml_1.parse)(content);
+        return {
+            auth: {
+                access_token: raw.auth?.access_token ?? "",
+                cookie: raw.auth?.cookie ?? undefined,
+            },
+            server: { base_url: raw.server?.base_url ?? undefined },
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { ...EMPTY_CONFIG };
+        }
+        throw new errors_1.CliError(`读取配置失败: ${error.message}`, errors_1.EXIT_CODES.IO);
+    }
+}
+async function saveConfig(config, configPath) {
+    const resolved = getConfigPath(configPath);
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(resolved), { recursive: true });
+    const content = (0, toml_1.stringify)(config);
+    await (0, promises_1.writeFile)(resolved, content, "utf8");
+    return resolved;
+}
+async function getAccessToken(configPath) {
+    const cfg = await loadConfig(configPath);
+    const token = cfg.auth.access_token?.trim();
+    if (!token) {
+        throw new errors_1.CliError("未找到 SVMC_ACCESS_TOKEN，请先执行 `svmc auth` 完成鉴权。", errors_1.EXIT_CODES.AUTH);
+    }
+    return stripBearerPrefix(token);
+}
+async function getSessionCookie(cookieFlag, configPath) {
+    const fromFlag = cookieFlag?.trim();
+    if (fromFlag) {
+        return fromFlag;
+    }
+    const fromEnv = process.env.SVMC_COOKIE?.trim();
+    if (fromEnv) {
+        return fromEnv;
+    }
+    const cfg = await loadConfig(configPath);
+    const fromConfig = cfg.auth.cookie?.trim();
+    return fromConfig || undefined;
+}
+async function getBaseUrl(baseUrlFlag, configPath) {
+    const fromFlag = baseUrlFlag?.trim();
+    if (fromFlag) {
+        return normalizeBaseUrl(fromFlag);
+    }
+    const fromEnv = process.env.SVMC_BASE_URL?.trim();
+    if (fromEnv) {
+        return normalizeBaseUrl(fromEnv);
+    }
+    const config = await loadConfig(configPath);
+    const fromConfig = config.server.base_url?.trim();
+    if (fromConfig) {
+        return normalizeBaseUrl(fromConfig);
+    }
+    return exports.DEFAULT_BASE_URL;
+}
+function normalizeBaseUrl(url) {
+    return url.replace(/\/+$/, "");
+}
+function stripBearerPrefix(token) {
+    const normalized = token.trim();
+    if (normalized.toLowerCase().startsWith("bearer ")) {
+        return normalized.slice(7).trim();
+    }
+    return normalized;
+}

package/dist/src/core/downloader.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadToLocal = downloadToLocal;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const errors_1 = require("./errors");
+async function downloadToLocal(url, outputDir, preferredName) {
+    await (0, promises_1.mkdir)(outputDir, { recursive: true });
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new errors_1.CliError(`下载失败(${response.status}): ${url}`, errors_1.EXIT_CODES.DOWNLOAD_FAILED);
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const fileName = sanitizeFileName(preferredName ?? ((0, node_path_1.basename)(new URL(url).pathname) || "image.jpg"));
+    const fullPath = (0, node_path_1.resolve)((0, node_path_1.join)(outputDir, ensureExt(fileName, response.headers.get("content-type"))));
+    await (0, promises_1.writeFile)(fullPath, bytes);
+    return fullPath;
+}
+function ensureExt(fileName, contentType) {
+    if ((0, node_path_1.extname)(fileName)) {
+        return fileName;
+    }
+    if (!contentType) {
+        return `${fileName}.jpg`;
+    }
+    if (contentType.includes("png")) {
+        return `${fileName}.png`;
+    }
+    if (contentType.includes("webp")) {
+        return `${fileName}.webp`;
+    }
+    return `${fileName}.jpg`;
+}
+function sanitizeFileName(input) {
+    return input.replace(/[^\w.-]+/g, "_");
+}

package/dist/src/core/errors.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXIT_CODES = exports.CliError = void 0;
+class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = "CliError";
+        this.exitCode = exitCode;
+    }
+}
+exports.CliError = CliError;
+exports.EXIT_CODES = {
+    OK: 0,
+    USAGE: 2,
+    AUTH: 3,
+    API: 4,
+    TASK_FAILED: 5,
+    DOWNLOAD_FAILED: 6,
+    IO: 7,
+};

package/dist/src/core/parser.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGenerateCliArgs = parseGenerateCliArgs;
+exports.ensureInputsReadable = ensureInputsReadable;
+exports.readImagesAsDataUrls = readImagesAsDataUrls;
+const promises_1 = require("node:fs/promises");
+const yargs_parser_1 = __importDefault(require("yargs-parser"));
+const errors_1 = require("./errors");
+function parseGenerateCliArgs(rawArgs) {
+    const parsed = (0, yargs_parser_1.default)(rawArgs, {
+        array: ["input"],
+        string: ["provider", "prompt", "ratio", "output-dir", "base-url", "cookie", "config-path"],
+        boolean: ["verbose"],
+        number: ["timeout-sec"],
+        configuration: {
+            "camel-case-expansion": false,
+            "dot-notation": false,
+            "unknown-options-as-args": false,
+            "strip-aliased": true,
+            "strip-dashed": false,
+        },
+    });
+    const provider = asString(parsed.provider);
+    if (!provider) {
+        throw new errors_1.CliError("缺少 `--provider` 参数。", errors_1.EXIT_CODES.USAGE);
+    }
+    const input = toStringArray(parsed.input);
+    if (input.length === 0) {
+        throw new errors_1.CliError("至少传入一个 `--input` 图片路径。", errors_1.EXIT_CODES.USAGE);
+    }
+    const timeoutSec = typeof parsed["timeout-sec"] === "number" ? parsed["timeout-sec"] : 600;
+    if (!Number.isFinite(timeoutSec) || timeoutSec <= 0) {
+        throw new errors_1.CliError("`--timeout-sec` 必须为正整数。", errors_1.EXIT_CODES.USAGE);
+    }
+    const dynamicParams = collectDynamicParams(parsed, [
+        "_",
+        "$0",
+        "provider",
+        "input",
+        "prompt",
+        "ratio",
+        "output-dir",
+        "timeout-sec",
+        "verbose",
+        "base-url",
+        "cookie",
+        "config-path",
+    ]);
+    return {
+        provider,
+        input,
+        prompt: asString(parsed.prompt),
+        ratio: asString(parsed.ratio),
+        outputDir: asString(parsed["output-dir"]),
+        timeoutSec,
+        verbose: Boolean(parsed.verbose),
+        baseUrl: asString(parsed["base-url"]),
+        cookie: asString(parsed.cookie),
+        dynamicParams,
+    };
+}
+async function ensureInputsReadable(paths) {
+    for (const path of paths) {
+        try {
+            await (0, promises_1.access)(path);
+        }
+        catch {
+            throw new errors_1.CliError(`输入文件不存在或不可读: ${path}`, errors_1.EXIT_CODES.USAGE);
+        }
+    }
+}
+async function readImagesAsDataUrls(paths) {
+    const urls = [];
+    for (const path of paths) {
+        const content = await (0, promises_1.readFile)(path);
+        const ext = path.split(".").pop()?.toLowerCase() ?? "jpg";
+        const mime = toMime(ext);
+        urls.push(`data:${mime};base64,${content.toString("base64")}`);
+    }
+    return urls;
+}
+function toMime(ext) {
+    switch (ext) {
+        case "png":
+            return "image/png";
+        case "webp":
+            return "image/webp";
+        case "gif":
+            return "image/gif";
+        case "jpeg":
+        case "jpg":
+        default:
+            return "image/jpeg";
+    }
+}
+function collectDynamicParams(parsed, excludedKeys) {
+    const excluded = new Set(excludedKeys);
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        if (excluded.has(key)) {
+            continue;
+        }
+        if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean" ||
+            (Array.isArray(value) && value.every((item) => typeof item === "string"))) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function toStringArray(value) {
+    if (!value) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === "string");
+    }
+    return typeof value === "string" ? [value] : [];
+}

package/dist/src/core/poller.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollTaskUntilDone = pollTaskUntilDone;
+const errors_1 = require("./errors");
+const RUNNING_STATUSES = new Set(["pending", "processing", "running"]);
+async function pollTaskUntilDone(fetchTask, options = {}) {
+    const intervalMs = options.intervalMs ?? 5000;
+    const timeoutMs = options.timeoutMs ?? 600_000;
+    const start = Date.now();
+    while (true) {
+        const task = await fetchTask();
+        const status = task.status;
+        if (options.verbose) {
+            process.stdout.write(`[poll] status=${status} task_uuid=${task.task_uuid}\n`);
+        }
+        if (status === "completed") {
+            return task;
+        }
+        if (status === "failed") {
+            const reason = task.error_message ?? "任务失败（无错误详情）";
+            throw new errors_1.CliError(reason, errors_1.EXIT_CODES.TASK_FAILED);
+        }
+        if (!RUNNING_STATUSES.has(status)) {
+            throw new errors_1.CliError(`未知任务状态: ${status}`, errors_1.EXIT_CODES.API);
+        }
+        if (Date.now() - start > timeoutMs) {
+            throw new errors_1.CliError("轮询超时，请稍后重试。", errors_1.EXIT_CODES.API);
+        }
+        await sleep(intervalMs);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}