gaoding-cli 1.0.0-alpha.5

package/dist/src/auth/credential-store-v2.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+import { GD_DIR, CREDENTIALS_FILE, migrateCredentialsIfNeeded } from "../utils/config.js";
+import { isCredentialsV2 } from "../core/auth/types.js";
+import { ensureCredentialDir, ensureCredentialFile } from "../utils/credential-permissions.js";
+export class CredentialStoreV2 {
+    dir;
+    file;
+    constructor(customDir) {
+        if (!customDir)
+            migrateCredentialsIfNeeded();
+        this.dir = customDir ?? GD_DIR;
+        this.file = customDir
+            ? path.join(customDir, "credentials.json")
+            : CREDENTIALS_FILE;
+    }
+    read() {
+        const raw = this.readAny();
+        if (!raw || !isCredentialsV2(raw))
+            return null;
+        return raw;
+    }
+    readAny() {
+        if (!fs.existsSync(this.file))
+            return null;
+        ensureCredentialDir(this.dir);
+        ensureCredentialFile(this.file);
+        try {
+            return JSON.parse(fs.readFileSync(this.file, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    write(credentials) {
+        ensureCredentialDir(this.dir);
+        const tmp = `${this.file}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(credentials, null, 2), { mode: 0o600 });
+        ensureCredentialFile(tmp);
+        fs.renameSync(tmp, this.file);
+        ensureCredentialFile(this.file);
+    }
+    delete() {
+        if (fs.existsSync(this.file))
+            fs.unlinkSync(this.file);
+    }
+    isAkExpired() {
+        const creds = this.read();
+        if (!creds)
+            return true;
+        return new Date(creds.expires_at) <= new Date();
+    }
+    isBindExpired() {
+        const creds = this.read();
+        if (!creds?.current_org?.bind_expires_at)
+            return false;
+        return new Date(creds.current_org.bind_expires_at) <= new Date();
+    }
+}

package/dist/src/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerAuthCommand(program: Command): void;

package/dist/src/commands/auth.js

@@ -0,0 +1,191 @@
+import chalk from "chalk";
+import { withErrorHandler } from "../middleware/error-handler.js";
+import { createAuthProvider } from "../core/auth/auth-provider.js";
+import { CredentialStoreV2 } from "../auth/credential-store-v2.js";
+import { resolveEndpoints, isVerbose, isDebug } from "../utils/config.js";
+import { getIO } from "../io.js";
+import { emitJson, wrapEnvelope } from "../core/output/envelope.js";
+import { setStaticHelp } from "../utils/static-help.js";
+import { resolveInvokeOutputFormat } from "../utils/list-output-format.js";
+const loginAction = withErrorHandler(async (options) => {
+    if (isVerbose() || isDebug()) {
+        const ep = resolveEndpoints();
+        console.error(chalk.dim(`[gd-cli] env=${ep.active_env} hub=${ep.hub_api_base.value} sso=${ep.sso_api_base.value} auth_page=${ep.auth_page_origin.value}`));
+    }
+    const provider = await createAuthProvider();
+    const result = await provider.login({
+        orgId: options.org,
+        noBrowser: !!options.noBrowser,
+        scope: options.scope,
+        env: options.env,
+    });
+    const io = getIO();
+    if (io.prefersJsonOutput()) {
+        emitJson(wrapEnvelope({
+            mode: provider.mode,
+            logged_in: true,
+            user: result.credentials.user,
+            org: result.org,
+            next_steps: result.org ? [] : ["gd-cli org switch"],
+        }, { command: "auth login" }));
+        return;
+    }
+    console.log(chalk.green("\n✓ 授权成功，可以开始使用稿定能力进行创意生产\n"));
+    if (!result.org) {
+        console.log(chalk.yellow("  未获取到授权团队，请执行 gd-cli org switch 后再调用 Workflows / Tools / DAM。"));
+    }
+});
+const statusAction = withErrorHandler(async (_opts, command) => {
+    const cmd = command;
+    const format = resolveInvokeOutputFormat(cmd);
+    const io = getIO();
+    const store = new CredentialStoreV2();
+    const creds = store.read();
+    const ep = resolveEndpoints();
+    if (!creds) {
+        if (io.prefersJsonOutput(format)) {
+            emitJson(wrapEnvelope({
+                logged_in: false,
+                environment: { active: ep.active_env },
+                next_steps: ["gd-cli auth login"],
+            }, { command: "auth status" }));
+            return;
+        }
+        console.log(chalk.yellow("未授权"));
+        console.log("  登录: gd-cli auth login");
+        return;
+    }
+    const payload = buildStatusPayload(creds, store);
+    if (io.prefersJsonOutput(format)) {
+        emitJson(wrapEnvelope(payload, { command: "auth status" }));
+        return;
+    }
+    printStatusHuman(payload);
+});
+const logoutAction = withErrorHandler(async () => {
+    const provider = await createAuthProvider();
+    await provider.logout();
+    new CredentialStoreV2().delete();
+    const io = getIO();
+    if (io.prefersJsonOutput()) {
+        emitJson(wrapEnvelope({ logged_out: true }, { command: "auth logout" }));
+        return;
+    }
+    console.log(chalk.green("✓ 已取消授权，可以重新执行 gd-cli auth login 进行授权。\n"));
+});
+export function registerAuthCommand(program) {
+    const auth = program
+        .command("auth")
+        .description("登录、退出、查看登录状态");
+    setStaticHelp(auth, AUTH_HELP);
+    auth
+        .command("login")
+        .description("浏览器/扫码授权登录")
+        .option("--org <org-id>", "登录后直接绑定该组织")
+        .option("--env <env>", "环境标识 cursor / claude / ci")
+        .option("--scope <scope>", "授权范围，逗号分隔")
+        .option("--no-browser", "不自动打开浏览器")
+        .action(loginAction);
+    auth
+        .command("logout")
+        .description("取消授权")
+        .action(logoutAction);
+    auth.command("status").description("查看授权状态").action(statusAction);
+}
+const AUTH_HELP = `
+Usage: gd-cli auth [options] [command]
+
+登录、退出、查看登录状态
+
+Commands:
+  login             浏览器/扫码授权登录
+  logout            取消授权
+  status            查看授权状态
+`;
+function buildStatusPayload(creds, store) {
+    const ep = resolveEndpoints();
+    const credentialExpired = store.isAkExpired();
+    const orgBindExpired = store.isBindExpired();
+    const envMatches = !creds.issued_for_env || creds.issued_for_env === ep.active_env;
+    const nextSteps = [];
+    if (credentialExpired)
+        nextSteps.push("gd-cli auth login");
+    if (!creds.current_org?.id)
+        nextSteps.push("gd-cli org list", "gd-cli org switch");
+    if (orgBindExpired)
+        nextSteps.push("gd-cli org switch");
+    if (!envMatches)
+        nextSteps.push("gd-cli auth login");
+    const payload = {
+        logged_in: true,
+        environment: {
+            active: ep.active_env,
+            issued_for: creds.issued_for_env ?? null,
+            matches_credentials: envMatches,
+        },
+        account: {
+            user_id: creds.user?.id ?? null,
+            name: creds.user?.name ?? null,
+        },
+        organization: creds.current_org
+            ? {
+                id: creds.current_org.id,
+                name: creds.current_org.name,
+                bind_expires_at: creds.current_org.bind_expires_at ?? null,
+                bind_valid: !orgBindExpired,
+            }
+            : null,
+        credential: {
+            mode: "aksk",
+            ak_preview: `${creds.ak.slice(0, 8)}***`,
+            expires_at: creds.expires_at,
+            valid: !credentialExpired,
+            scope: creds.scope,
+        },
+        next_steps: nextSteps,
+    };
+    if (isVerbose() || isDebug()) {
+        payload.debug = {
+            hub_api_base: ep.hub_api_base.value,
+            sso_api_base: ep.sso_api_base.value,
+            auth_page_origin: ep.auth_page_origin.value,
+            web_origin: ep.web_origin.value,
+        };
+    }
+    return payload;
+}
+function printStatusHuman(payload) {
+    const environment = payload.environment;
+    const account = payload.account;
+    const organization = payload.organization;
+    const credential = payload.credential;
+    const nextSteps = payload.next_steps;
+    console.log(chalk.bold("gd-cli 授权状态"));
+    console.log(`  状态:      ${payload.logged_in ? "已登录" : "未登录"}`);
+    // console.log(`  环境:      ${environment.active}`);
+    if (environment.matches_credentials === false) {
+        console.log(chalk.yellow(`  提醒:      凭证属于 ${environment.issued_for}，当前环境为 ${environment.active}`));
+    }
+    if (account.user_id) {
+        console.log(`  用户:      ${account.name ?? account.user_id}`);
+    }
+    if (organization) {
+        const valid = organization.bind_valid ? "有效" : "已过期";
+        console.log(`  当前组织:  ${organization.name} (${organization.id})`);
+        console.log(`  组织绑定:  ${valid}${organization.bind_expires_at ? `，至 ${organization.bind_expires_at}` : ""}`);
+    }
+    else {
+        console.log(chalk.yellow("  当前组织:  未绑定"));
+    }
+    console.log(`  凭证:      AK/SK ${credential.ak_preview}，${credential.valid ? "有效" : "已过期"}`);
+    console.log(`  过期时间:  ${credential.expires_at}`);
+    const scope = Array.isArray(credential.scope) ? credential.scope.join(", ") : "";
+    if (scope)
+        console.log(`  权限范围:  ${scope}`);
+    if (nextSteps.length > 0) {
+        console.log("\n下一步:");
+        for (const step of nextSteps)
+            console.log(`  ${step}`);
+    }
+    console.log("");
+}

package/dist/src/commands/dam.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerDamCommand(program: Command): void;

package/dist/src/commands/dam.js

@@ -0,0 +1,293 @@
+import { existsSync, statSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { withAuth } from "../middleware/auth.js";
+import { withErrorHandler } from "../middleware/error-handler.js";
+import { DamClient } from "../api/dam-client.js";
+import { formatOutput } from "../middleware/output.js";
+import { resolveInvokeOutputFormat, resolveListOutputFormat, } from "../utils/list-output-format.js";
+import { createSpinner } from "../utils/spinner.js";
+import { emitJson, wrapEnvelope, shouldEmitEnvelope } from "../core/output/envelope.js";
+import { setStaticHelp } from "../utils/static-help.js";
+export function registerDamCommand(program) {
+    const dam = program
+        .command("dam")
+        .usage("<command> [options]")
+        .description("DAM 素材管理")
+        .configureHelp({ showGlobalOptions: true });
+    setStaticHelp(dam, DAM_HELP);
+    dam
+        .command("upload <file>")
+        .description("上传本地文件并提交 DAM 入库，返回 DAM asset_id 与 CDN URL")
+        .option("--repository-id <id>", "DAM 资源库 ID，默认取个人库或 GD_DAM_REPOSITORY_ID")
+        .option("--name <name>", "指定素材名称")
+        .option("--folder-id <id>", "DAM 文件夹 ID，MVP 默认 0", "0")
+        .option("--folder <name>", "文件夹名称")
+        .option("--tags <list>", "标签，逗号分隔")
+        .option("--tag-ids <list>", "标签 ID，逗号分隔")
+        .option("--storage-only", "只上传对象存储，不提交 DAM 入库", false)
+        .option("--allow-sensitive-path", "确认上传默认受保护的本地路径", false)
+        .option("--wait-analysis", "等待 DAM 后端分析完成并返回封面", false)
+        .option("--analysis-timeout <ms>", "等待分析超时时间（毫秒）", parsePositiveInteger, 180000)
+        .option("--analysis-interval <ms>", "分析轮询间隔（毫秒）", parsePositiveInteger, 3000)
+        .action(withErrorHandler(withAuth(async (file, options, command) => {
+        const opts = options;
+        const cmd = command;
+        const p = resolve(process.cwd(), String(file));
+        if (!existsSync(p) || !statSync(p).isFile()) {
+            throw new Error(`文件不存在: ${p}`);
+        }
+        const spinner = createSpinner("上传素材…");
+        if (process.stderr.isTTY)
+            spinner.start();
+        const damClient = new DamClient();
+        const uploaded = await damClient.uploadLocalAsset(p, {
+            register: !opts.storageOnly,
+            allowSensitivePath: opts.allowSensitivePath === true,
+            repositoryId: optionalString(opts.repositoryId),
+            folderId: optionalString(opts.folderId) ?? "0",
+            title: optionalString(opts.name),
+            tagIds: splitList(opts.tagIds),
+            waitAnalysis: Boolean(opts.waitAnalysis) && !opts.storageOnly,
+            analysisTimeoutMs: numberOption(opts.analysisTimeout),
+            analysisIntervalMs: numberOption(opts.analysisInterval),
+        });
+        if (process.stderr.isTTY)
+            spinner.succeed("上传完成");
+        const asset = {
+            id: uploaded.id,
+            url: uploaded.url,
+            type: uploaded.mime_type,
+            filename: basename(p),
+            source: "cli",
+            cover_url: uploaded.cover_url,
+        };
+        const payload = {
+            status: "completed",
+            asset,
+            outputs: {
+                asset_id: uploaded.id,
+                id: uploaded.id,
+                storage_id: uploaded.storage_id,
+                registered_asset_id: uploaded.registered_asset_id,
+                registered: uploaded.registered ?? false,
+                url: uploaded.url,
+                cover_url: uploaded.cover_url,
+                cover: uploaded.cover,
+                asset_info: uploaded.asset_info,
+                analysis_status: uploaded.analysis_status,
+                analysis_fail_msg: uploaded.analysis_fail_msg,
+                analysis_timed_out: uploaded.analysis_timed_out,
+                filename: uploaded.filename,
+                format: uploaded.format,
+                mime_type: uploaded.mime_type,
+                object_name: uploaded.object_name,
+                auth_key: uploaded.auth_key,
+                registration: uploaded.registration,
+            },
+        };
+        const format = resolveInvokeOutputFormat(cmd);
+        if (shouldEmitEnvelope(format)) {
+            emitJson(wrapEnvelope(payload, { command: "dam upload" }));
+        }
+        else {
+            formatOutput(payload, format);
+        }
+    })));
+    dam
+        .command("list")
+        .description("查看最近上传素材")
+        .option("--repository-id <id>", "DAM 资源库 ID，默认取个人库或 GD_DAM_REPOSITORY_ID")
+        .option("--all-repositories", "搜索当前组织下所有资源库", false)
+        .option("--folder-id <id>", "限定文件夹")
+        .option("--include-child-folder", "包含子文件夹", true)
+        .option("--no-include-child-folder", "不包含子文件夹")
+        .option("--type <type>", "image/video/audio/font/template/file")
+        .option("--format <list>", "素材格式，逗号分隔，例如 png,jpg,mp4")
+        .option("--tag-ids <list>", "标签 ID，逗号分隔")
+        .option("--page-size <n>", "每页数量，最大 100", parsePositiveInteger, 20)
+        .option("--page <n>", "页码", parsePositiveInteger, 1)
+        .option("--cursor <id>", "分页 cursor/query_id")
+        .option("--raw", "JSON 输出包含后端原始数据", false)
+        .action(withErrorHandler(withAuth(async (options, command) => {
+        const opts = options;
+        const cmd = command;
+        const damClient = new DamClient();
+        const data = await damClient.searchAssets("", {
+            ...buildDamSearchOptions(opts),
+            allowEmptyKeyword: true,
+        });
+        outputDamSearch(data, resolveListOutputFormat(cmd), "list");
+    })));
+    dam
+        .command("search <keyword>")
+        .description("搜索素材")
+        .option("--repository-id <id>", "DAM 资源库 ID，默认取个人库或 GD_DAM_REPOSITORY_ID")
+        .option("--all-repositories", "搜索当前组织下所有资源库", false)
+        .option("--folder-id <id>", "限定文件夹")
+        .option("--include-child-folder", "包含子文件夹", true)
+        .option("--no-include-child-folder", "不包含子文件夹")
+        .option("--type <type>", "image/video/audio/font/template/file")
+        .option("--format <list>", "素材格式，逗号分隔，例如 png,jpg,mp4")
+        .option("--tag-ids <list>", "标签 ID，逗号分隔")
+        .option("--page-size <n>", "每页数量，最大 100", parsePositiveInteger, 20)
+        .option("--page <n>", "页码", parsePositiveInteger, 1)
+        .option("--cursor <id>", "分页 cursor/query_id")
+        .option("--raw", "JSON 输出包含后端原始数据", false)
+        .action(withErrorHandler(withAuth(async (keyword, options, command) => {
+        const opts = options;
+        const cmd = command;
+        const damClient = new DamClient();
+        const data = await damClient.searchAssets(String(keyword), buildDamSearchOptions(opts));
+        outputDamSearch(data, resolveListOutputFormat(cmd), "search");
+    })));
+    dam
+        .command("get <id-or-url>")
+        .description("按 asset_id、CDN URL 或文件名查询素材（依赖 Hub DAM API）")
+        .action(withErrorHandler(withAuth(async (idOrUrl, _opts, command) => {
+        const cmd = command;
+        const key = String(idOrUrl);
+        const damClient = new DamClient();
+        const data = await damClient.getAsset(key);
+        const format = resolveInvokeOutputFormat(cmd);
+        if (shouldEmitEnvelope(format)) {
+            emitJson(wrapEnvelope(data, { command: "dam get" }));
+        }
+        else {
+            formatOutput(data, format);
+        }
+    })));
+    dam
+        .command("delete <asset-id>")
+        .description("删除 DAM 素材")
+        .option("--repository-id <id>", "DAM 资源库 ID，默认取个人库或 GD_DAM_REPOSITORY_ID")
+        .option("--permanent", "进入回收站后继续永久删除", false)
+        .action(withErrorHandler(withAuth(async (assetId, options, command) => {
+        const cmd = command;
+        const opts = options;
+        const id = String(assetId);
+        const damClient = new DamClient();
+        const data = await damClient.deleteAsset(id, {
+            repositoryId: optionalString(opts.repositoryId),
+            permanent: Boolean(opts.permanent),
+        });
+        const format = resolveInvokeOutputFormat(cmd);
+        if (shouldEmitEnvelope(format)) {
+            emitJson(wrapEnvelope(data, { command: "dam delete" }));
+        }
+        else {
+            formatOutput(data, format);
+        }
+    })));
+}
+function buildDamSearchOptions(opts) {
+    return {
+        repositoryId: optionalString(opts.repositoryId),
+        allRepositories: Boolean(opts.allRepositories),
+        folderId: optionalString(opts.folderId),
+        includeChildFolder: opts.includeChildFolder !== false,
+        type: optionalString(opts.type),
+        format: splitList(opts.format),
+        tagIds: splitList(opts.tagIds),
+        pageSize: numberOption(opts.pageSize),
+        page: numberOption(opts.page),
+        cursor: optionalString(opts.cursor),
+        raw: Boolean(opts.raw),
+    };
+}
+function outputDamSearch(data, format, mode) {
+    if (format === "json") {
+        formatOutput(data, "json");
+        return;
+    }
+    const repo = data.repository_ids.join(", ") || "default";
+    if (mode === "list") {
+        console.log(`Found ${data.total} recent assets in repo ${repo}`);
+    }
+    else {
+        console.log(`Found ${data.total} assets for "${data.query}" in repo ${repo}`);
+    }
+    console.log("");
+    formatOutput(rowsForDamSearch(data), format === "human" ? "table" : format);
+    if (data.next_cursor) {
+        const base = mode === "list"
+            ? "gd-cli dam list"
+            : `gd-cli dam search ${quoteShell(data.query)}`;
+        console.log(`\nNext:\n  ${base} --cursor ${data.next_cursor}`);
+    }
+    if (data.assets.length === 1) {
+        console.log(`\nUse:\n  gd-cli dam get ${data.assets[0].asset_id}`);
+    }
+}
+function rowsForDamSearch(data) {
+    return data.assets.map((asset, index) => ({
+        "#": String(index + 1),
+        "Asset ID": asset.asset_id,
+        Title: asset.title ?? "",
+        Type: asset.type ?? "",
+        Format: asset.format ?? "",
+        Size: asset.size === undefined ? "" : formatBytes(asset.size),
+        Folder: asset.folder_name ?? asset.folder_id ?? "",
+        Cover: asset.cover_url ?? asset.url ?? "",
+    }));
+}
+function optionalString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function splitList(value) {
+    const raw = optionalString(value);
+    if (!raw)
+        return undefined;
+    return raw.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function parsePositiveInteger(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`必须是正整数: ${value}`);
+    }
+    return parsed;
+}
+function numberOption(value) {
+    return typeof value === "number" ? value : undefined;
+}
+function formatBytes(value) {
+    if (!Number.isFinite(value))
+        return "";
+    if (value < 1024)
+        return `${value} B`;
+    if (value < 1024 * 1024)
+        return `${Math.round(value / 102.4) / 10} KB`;
+    if (value < 1024 * 1024 * 1024)
+        return `${Math.round(value / 104857.6) / 10} MB`;
+    return `${Math.round(value / 107374182.4) / 10} GB`;
+}
+function quoteShell(value) {
+    return /^[\w./:=,-]+$/.test(value) ? value : `"${value.replace(/"/g, '\\"')}"`;
+}
+const DAM_HELP = `Usage: gd-cli dam <command> [options]
+
+用于把本地文件上传到稿定素材库，获得可复用的 asset_id 和 CDN URL。
+适合在 Workflows / Tools / Agent 工作流中反复引用同一批商品图、Logo、参考图和交付文件。
+
+常用命令:
+  upload <file>             上传文件并入库，返回 asset_id 与 CDN URL
+  get <id-or-url>           按 asset_id、CDN URL 或文件名查询素材
+  list                      查看最近上传素材
+  search <keyword>          搜索素材
+  delete <asset-id>         删除素材
+
+常用选项:
+  --name <name>             指定素材名称
+  --folder <folder>         指定 DAM 文件夹
+  --tags <tags>             添加标签，逗号分隔
+  --format <list>           在 dam search/list 中表示素材格式过滤，例如 png,jpg
+  --json                    输出机器可读 JSON
+
+示例:
+  gd-cli dam upload ./sku-001.png --tags product,shoe
+  gd-cli dam get ast_123
+  gd-cli dam search "white sneaker" --type image --format png,jpg
+  gd-cli dam delete ast_123 --yes
+`;

package/dist/src/commands/models.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerModelsCommand(program: Command): void;

package/dist/src/commands/models.js

@@ -0,0 +1,78 @@
+import { formatOutput } from "../middleware/output.js";
+import { withErrorHandler } from "../middleware/error-handler.js";
+import { Prompt } from "../core/prompt/index.js";
+import { resolveInvokeOutputFormat, resolveListOutputFormat } from "../utils/list-output-format.js";
+import { getConfiguredModel, getDefaultModelOrder, listModels, modelEntriesForType, parseModelType, publicModelByCode, resolveModelOrder, setConfiguredModel, } from "../models/model-catalog.js";
+export function registerModelsCommand(program) {
+    const models = program
+        .command("models", { hidden: true })
+        .description("模型选择（Agent 入口）")
+        .configureHelp({ showGlobalOptions: true });
+    models
+        .command("list")
+        .description("列出可选图像/视频模型")
+        .requiredOption("--type <type>", "image / video")
+        .action(withErrorHandler(async (options, command) => {
+        const cmd = command;
+        const type = parseModelType(options.type);
+        const selected = getConfiguredModel(type);
+        const payload = {
+            type,
+            current: {
+                mode: selected === "auto" ? "auto" : "manual",
+                model: selected === "auto" ? undefined : publicModelByCode(type, selected),
+                effective_order: resolveModelOrder(type),
+            },
+            default_order: getDefaultModelOrder(type),
+            models: listModels(type),
+        };
+        const format = resolveListOutputFormat(cmd);
+        if (format === "json") {
+            formatOutput(payload, "json");
+        }
+        else {
+            formatOutput(payload.models, format);
+        }
+    }));
+    models
+        .command("switch")
+        .description("切换默认图像/视频模型")
+        .requiredOption("--type <type>", "image / video")
+        .option("--model <model>", "模型 code / 名称 / auto")
+        .action(withErrorHandler(async (options, command) => {
+        const cmd = command;
+        const opts = options;
+        const type = parseModelType(opts.type);
+        const model = typeof opts.model === "string" && opts.model.trim()
+            ? opts.model.trim()
+            : await promptModel(type);
+        const selected = setConfiguredModel(type, model);
+        const payload = {
+            type,
+            selected: selected === "auto"
+                ? { mode: "auto" }
+                : { mode: "manual", model: publicModelByCode(type, selected) },
+            effective_order: resolveModelOrder(type),
+        };
+        formatOutput(payload, resolveInvokeOutputFormat(cmd));
+    }));
+}
+async function promptModel(type) {
+    const current = getConfiguredModel(type);
+    const choices = [
+        {
+            name: current === "auto" ? "auto 当前" : "auto",
+            value: "auto",
+            description: "使用 Web 默认返回顺序和失败兜底",
+        },
+        ...modelEntriesForType(type).map((model) => ({
+            name: current === model.code ? `${model.name} 当前` : model.name,
+            value: model.code,
+            description: `${model.description} / ${model.code} / 消耗${model.cost_level}`,
+        })),
+    ];
+    return Prompt.select({
+        message: `选择默认${type === "image" ? "图像" : "视频"}模型`,
+        choices,
+    });
+}

package/dist/src/commands/org.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerOrgCommand(program: Command): void;