gaoding-cli 1.0.0-alpha.8 → 1.0.0-alpha.9

package/dist/src/commands/creative.js

@@ -2,69 +2,69 @@ import chalk from "chalk";
 import { CreativeClient } from "../api/creative-client.js";
 import { CliUsageError } from "../core/output/cli-error.js";
 import { formatOutput } from "../middleware/output.js";
-import { toCliErrorBody } from "../middleware/error-handler.js";
+import { jsonFailureEnvelopeFor, setJsonFailureProjector, } from "../middleware/error-handler.js";
 import { getCreativeExamples, getCreativeSchema, validateCreativeInput, } from "../creative/contract.js";
-import { resolveInvokeOutputFormat, resolveListOutputFormat } from "../utils/list-output-format.js";
 import { readJsonInput } from "../utils/input-json.js";
-import { setStaticHelp } from "../utils/static-help.js";
 import { setAuthRequirement } from "../middleware/auth.js";
+const CREATIVE_FAILURE_META = {
+    command: "creative run",
+    schema_version: "creative/v1",
+};
 export function registerCreativeCommand(program, deps = {}) {
     const creative = program
         .command("creative")
         .usage("<command> [options]")
-        .description("通过稿定 Creative 完成图片、视频和文本创作")
-        .configureHelp({ showGlobalOptions: true });
-    setStaticHelp(creative, CREATIVE_HELP);
+        .description("通过稿定 Creative 完成图片、视频和文本创作");
     const run = creative
         .command("run")
         .usage("[options]")
         .description("发起创作、继续已有创作或回答追问")
         .option("--prompt <text>", "详细描述期望的最终结果")
         .option("--input <path>", "从 JSON 文件读取完整输入；传 - 表示读取 stdin")
+        .option("--json", "输出机器可读 JSON")
         .action(async (options, command) => {
         await runCreative(options, command, deps);
     });
+    setJsonFailureProjector(run, creativeFailureEnvelope);
     setAuthRequirement(run, "current-org");
     const schema = creative
         .command("schema")
         .description("查看 Creative 输入与输出 JSON Schema")
+        .option("--json", "输出完整 JSON Schema")
         .action((_options, command) => {
         const payload = getCreativeSchema();
-        const format = resolveListOutputFormat(command);
-        if (format === "json") {
+        if (command.opts().json === true) {
             formatOutput(payload, "json");
             return;
         }
-        console.log("Creative Input Schema\n");
-        console.log(JSON.stringify(payload.input_schema, null, 2));
-        console.log("\nCreative Output Schema\n");
-        console.log(JSON.stringify(payload.output_schema, null, 2));
+        console.log("Creative 输入: prompt、media、parameters、conversation_id、question_message_id、answers");
+        console.log("Creative 输出: message、outputs，以及连续创作或追问所需的会话信息");
+        console.log("完整 JSON Schema: gd-cli creative schema --json");
     });
     setAuthRequirement(schema, "none");
     const examples = creative
         .command("examples")
         .description("查看 Creative 调用示例")
-        .action((_options, command) => {
+        .action(() => {
         const payload = getCreativeExamples();
-        const format = resolveListOutputFormat(command);
-        if (format === "json") {
-            formatOutput(payload, "json");
-            return;
-        }
         for (const [index, example] of payload.examples.entries()) {
             console.log(`${index + 1}. ${example.description} (${example.name})`);
-            console.log(JSON.stringify(example.input, null, 2));
+            console.log(`  ${example.command}`);
+            console.log("  请求 JSON:");
+            console.log(indentJson(JSON.stringify(example.input, null, 2), "    "));
             console.log("");
         }
     });
     setAuthRequirement(examples, "none");
 }
+function indentJson(value, prefix) {
+    return value
+        .split("\n")
+        .map((line) => `${prefix}${line}`)
+        .join("\n");
+}
 export async function runCreative(options, command, deps = {}) {
-    const format = resolveInvokeOutputFormat(command);
-    const meta = {
-        command: "creative run",
-        schema_version: "creative/v1",
-    };
+    const format = command.opts().json === true ? "json" : "human";
     try {
         const input = await resolveCreativeInput(options, deps.readInput ?? readJsonInput);
         const client = deps.createClient?.() ?? new CreativeClient();
@@ -73,17 +73,12 @@ export async function runCreative(options, command, deps = {}) {
             status: "completed",
             data: result,
             error: null,
-            meta,
+            meta: CREATIVE_FAILURE_META,
         };
         renderCreativeEnvelope(envelope, format);
     }
     catch (error) {
-        const envelope = {
-            status: "failed",
-            data: null,
-            error: toCreativeError(error),
-            meta,
-        };
+        const envelope = jsonFailureEnvelopeFor(command, error);
         if (format === "json") {
             formatOutput(envelope, "json");
         }
@@ -140,8 +135,8 @@ function printCreativeResult(result, format) {
             }
         }
         console.log(`\n  conversation_id: ${result.conversation_id}`);
-        if (result.last_tool_message_id) {
-            console.log(`  last_tool_message_id: ${result.last_tool_message_id}`);
+        if (result.question_message_id) {
+            console.log(`  question_message_id: ${result.question_message_id}`);
         }
     }
 }
@@ -164,8 +159,15 @@ function printCreativeError(error) {
     if (error.hint)
         console.error(`  说明: ${error.hint}`);
 }
-function toCreativeError(error) {
-    const body = toCliErrorBody(error);
+function creativeFailureEnvelope(error) {
+    return {
+        status: "failed",
+        data: null,
+        error: toCreativeError(error),
+        meta: CREATIVE_FAILURE_META,
+    };
+}
+function toCreativeError(body) {
     return {
         code: body.code,
         type: body.type,
@@ -174,13 +176,3 @@ function toCreativeError(error) {
         ...(body.retryable !== undefined ? { retryable: body.retryable } : {}),
     };
 }
-const CREATIVE_HELP = `
-Usage: gd-cli creative <command> [options]
-
-通过稿定 Creative 完成图片、视频和文本创作
-
-常用命令:
-  run                  发起创作、继续已有创作或回答追问
-  schema               查看输入与输出 JSON Schema
-  examples             查看调用示例
-`;

package/dist/src/commands/dam.js

@@ -4,31 +4,27 @@ import { setAuthRequirement } 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";
+import { emitJson, wrapEnvelope } from "../core/output/envelope.js";
+import { CliUsageError } from "../core/output/cli-error.js";
+import { isSensitiveKey } from "../utils/redact.js";
+import { assertSafeHttpUrl, isBlockedHost } from "../utils/url-safety.js";
+const DAM_ASSET_TYPES = new Set(["image", "video", "audio", "font", "template", "file"]);
 export function registerDamCommand(program) {
     const dam = program
         .command("dam")
         .usage("<command> [options]")
-        .description("DAM 素材管理")
-        .configureHelp({ showGlobalOptions: true });
-    setStaticHelp(dam, DAM_HELP);
+        .description("DAM 素材管理");
     const upload = 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)
+        .option("--json", "输出机器可读 JSON")
         .action(withErrorHandler(async (file, options, command) => {
         const opts = options;
         const cmd = command;
@@ -41,56 +37,37 @@ export function registerDamCommand(program) {
             spinner.start();
         const damClient = new DamClient();
         const uploaded = await damClient.uploadLocalAsset(p, {
-            register: !opts.storageOnly,
+            register: true,
             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),
+            waitAnalysis: Boolean(opts.waitAnalysis),
         });
         if (process.stderr.isTTY)
             spinner.succeed("上传完成");
-        const asset = {
-            id: uploaded.id,
-            url: uploaded.url,
-            type: uploaded.mime_type,
+        const asset = projectPublicDamAsset({
+            ...uploaded,
+            asset_id: uploaded.id,
             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,
+                asset_id: asset.asset_id,
+                url: asset.url,
+                cover_url: asset.cover_url,
+                filename: asset.filename,
+                type: asset.mime_type ?? asset.type,
             },
         };
-        const format = resolveInvokeOutputFormat(cmd);
-        if (shouldEmitEnvelope(format)) {
+        if (isJson(cmd)) {
             emitJson(wrapEnvelope(payload, { command: "dam upload" }));
         }
         else {
-            formatOutput(payload, format);
+            formatOutput(payload, "human");
         }
     }));
     setAuthRequirement(upload, "current-org");
@@ -100,15 +77,13 @@ export function registerDamCommand(program) {
         .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("--asset-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)
+        .option("--json", "输出机器可读 JSON")
         .action(withErrorHandler(async (options, command) => {
         const opts = options;
         const cmd = command;
@@ -117,7 +92,7 @@ export function registerDamCommand(program) {
             ...buildDamSearchOptions(opts),
             allowEmptyKeyword: true,
         });
-        outputDamSearch(data, resolveListOutputFormat(cmd), "list");
+        outputDamSearch(data, isJson(cmd), "list");
     }));
     setAuthRequirement(list, "current-org");
     const search = dam
@@ -126,37 +101,39 @@ export function registerDamCommand(program) {
         .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("--asset-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)
+        .option("--json", "输出机器可读 JSON")
         .action(withErrorHandler(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");
+        outputDamSearch(data, isJson(cmd), "search");
     }));
     setAuthRequirement(search, "current-org");
     const get = dam
-        .command("get <id-or-url>")
-        .description("按 asset_id、CDN URL 或文件名查询素材（依赖 Hub DAM API）")
-        .action(withErrorHandler(async (idOrUrl, _opts, command) => {
+        .command("get <asset-id>")
+        .description("按 asset_id 查询素材")
+        .option("--json", "输出机器可读 JSON")
+        .action(withErrorHandler(async (assetId, _opts, command) => {
         const cmd = command;
-        const key = String(idOrUrl);
+        const key = requireAssetId(assetId);
         const damClient = new DamClient();
         const data = await damClient.getAsset(key);
-        const format = resolveInvokeOutputFormat(cmd);
-        if (shouldEmitEnvelope(format)) {
-            emitJson(wrapEnvelope(data, { command: "dam get" }));
+        const payload = {
+            status: "completed",
+            asset: projectPublicDamAsset(data, key),
+        };
+        if (isJson(cmd)) {
+            emitJson(wrapEnvelope(payload, { command: "dam get" }));
         }
         else {
-            formatOutput(data, format);
+            formatOutput(payload, "human");
         }
     }));
     setAuthRequirement(get, "current-org");
@@ -165,8 +142,7 @@ export function registerDamCommand(program) {
         .description("删除 DAM 素材")
         .option("--repository-id <id>", "DAM 资源库 ID，默认取个人库或 GD_DAM_REPOSITORY_ID")
         .option("--permanent", "进入回收站后继续永久删除", false)
-        .action(withErrorHandler(async (assetId, options, command) => {
-        const cmd = command;
+        .action(withErrorHandler(async (assetId, options) => {
         const opts = options;
         const id = String(assetId);
         const damClient = new DamClient();
@@ -174,53 +150,55 @@ export function registerDamCommand(program) {
             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);
-        }
+        formatOutput(data, "human");
     }));
     setAuthRequirement(deleteCommand, "current-org");
 }
 function buildDamSearchOptions(opts) {
+    const repositoryId = optionalString(opts.repositoryId);
+    const allRepositories = Boolean(opts.allRepositories);
+    if (repositoryId && allRepositories) {
+        invalidDamOption("--repository-id 与 --all-repositories 不能同时使用");
+    }
+    const type = optionalString(opts.type)?.toLowerCase();
+    if (type && !DAM_ASSET_TYPES.has(type)) {
+        invalidDamOption("--type 必须是 image、video、audio、font、template 或 file");
+    }
     return {
-        repositoryId: optionalString(opts.repositoryId),
-        allRepositories: Boolean(opts.allRepositories),
+        repositoryId,
+        allRepositories,
         folderId: optionalString(opts.folderId),
         includeChildFolder: opts.includeChildFolder !== false,
-        type: optionalString(opts.type),
+        type,
         format: splitList(opts.assetFormat),
         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");
+function outputDamSearch(data, json, mode) {
+    const payload = projectPublicDamSearchResult(data);
+    if (json) {
+        emitJson(wrapEnvelope(payload, { command: `dam ${mode}` }));
         return;
     }
-    const repo = data.repository_ids.join(", ") || "default";
+    const repo = payload.repository_ids.join(", ") || "default";
     if (mode === "list") {
-        console.log(`Found ${data.total} recent assets in repo ${repo}`);
+        console.log(`Found ${payload.total} recent assets in repo ${repo}`);
     }
     else {
-        console.log(`Found ${data.total} assets for "${data.query}" in repo ${repo}`);
+        console.log(`Found ${payload.total} assets for "${payload.query}" in repo ${repo}`);
     }
     console.log("");
-    formatOutput(rowsForDamSearch(data), format === "human" ? "table" : format);
-    if (data.next_cursor) {
+    formatOutput(rowsForDamSearch(payload), "table");
+    if (payload.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}`);
+            : `gd-cli dam search ${quoteShell(payload.query)}`;
+        console.log(`\nNext:\n  ${base} --cursor ${payload.next_cursor}`);
     }
-    if (data.assets.length === 1) {
-        console.log(`\nUse:\n  gd-cli dam get ${data.assets[0].asset_id}`);
+    if (payload.assets.length === 1) {
+        console.log(`\nUse:\n  gd-cli dam get ${payload.assets[0].asset_id}`);
     }
 }
 function rowsForDamSearch(data) {
@@ -257,6 +235,191 @@ function parsePositiveInteger(value) {
 function numberOption(value) {
     return typeof value === "number" ? value : undefined;
 }
+function requireAssetId(value) {
+    const assetId = optionalString(value);
+    if (!assetId)
+        invalidDamOption("asset_id 不能为空");
+    if (/^https?:\/\//i.test(assetId))
+        invalidDamOption("asset_id 不能是 URL");
+    return assetId;
+}
+function invalidDamOption(message) {
+    throw new CliUsageError({
+        code: "PARAM_INVALID",
+        type: "validation",
+        message,
+        retryable: false,
+    });
+}
+function isJson(command) {
+    return command.opts().json === true;
+}
+function projectPublicDamSearchResult(data) {
+    return {
+        status: "completed",
+        query: data.query,
+        repository_ids: [...data.repository_ids],
+        page: data.page,
+        page_size: data.page_size,
+        total: data.total,
+        finish: data.finish,
+        ...(data.next_cursor ? { next_cursor: data.next_cursor } : {}),
+        assets: data.assets.map((asset) => projectPublicDamAsset(asset)),
+    };
+}
+function projectPublicDamAsset(value, fallbackAssetId = "") {
+    const item = publicDamAssetRecord(value);
+    const origin = recordValue(item.origin_info) ?? recordValue(item.originInfo);
+    const preview = recordValue(item.preview) ??
+        recordValue(item.preview_info) ??
+        recordValue(item.previewInfo) ??
+        recordValue(item.cover);
+    const folder = recordValue(item.folder_info) ?? recordValue(item.folderInfo);
+    const format = stringValue(origin?.format) ?? stringValue(item.format);
+    const mimeType = stringValue(item.mime_type) ?? stringValue(item.mimeType);
+    const url = stringValue(origin?.url) ?? stringValue(item.origin_url) ?? stringValue(item.url);
+    const coverUrl = stringValue(preview?.url) ??
+        stringValue(item.cover_url) ??
+        stringValue(item.preview_url);
+    const assetId = stringValue(item.asset_id) ??
+        stringValue(item.id) ??
+        stringValue(item.content_id) ??
+        fallbackAssetId;
+    const tags = publicTags(item.tags);
+    const tagIds = publicTagIds(item.tag_ids, item.tags);
+    return compactRecord({
+        asset_id: assetId,
+        title: stringValue(item.title) ?? stringValue(item.name),
+        filename: stringValue(item.filename),
+        format,
+        mime_type: mimeType,
+        type: publicDamAssetType(item, format, mimeType),
+        size: numberValue(origin?.size) ?? numberValue(item.size),
+        url: url ? publicAssetUrl(url) : undefined,
+        cover_url: coverUrl ? publicAssetUrl(coverUrl) : undefined,
+        width: numberValue(preview?.width) ?? numberValue(item.width),
+        height: numberValue(preview?.height) ?? numberValue(item.height),
+        repository_id: stringValue(item.repository_id),
+        folder_id: stringValue(item.folder_id) ?? stringValue(folder?.id),
+        folder_name: stringValue(folder?.title) ?? stringValue(folder?.name),
+        tags,
+        tag_ids: tagIds,
+        analysis_status: numberValue(item.analysis_result) ??
+            numberValue(item.analysis_status) ??
+            stringValue(item.analysis_result) ??
+            stringValue(item.analysis_status),
+        created_at: stringValue(item.created_at),
+        updated_at: stringValue(item.updated_at),
+    });
+}
+function publicDamAssetRecord(value) {
+    if (!recordValue(value))
+        return {};
+    const queue = [value];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const candidate = queue.shift();
+        const record = recordValue(candidate);
+        if (!record || seen.has(record))
+            continue;
+        seen.add(record);
+        if (isDamAssetRecord(record))
+            return record;
+        for (const key of ["data", "asset", "asset_info"]) {
+            if (record[key] !== undefined)
+                queue.push(record[key]);
+        }
+    }
+    return {};
+}
+function isDamAssetRecord(value) {
+    return [
+        "asset_id",
+        "id",
+        "content_id",
+        "origin_info",
+        "originInfo",
+        "origin_url",
+        "url",
+    ].some((key) => value[key] !== undefined);
+}
+function publicDamAssetType(item, format, mimeType) {
+    const explicit = stringValue(item.type)?.toLowerCase();
+    if (explicit && DAM_ASSET_TYPES.has(explicit))
+        return explicit;
+    const contentFormat = stringValue(item.content_format)?.toLowerCase() ??
+        stringValue(item.storage_format)?.toLowerCase();
+    if (contentFormat === "gdpic" || contentFormat === "gdimage")
+        return "image";
+    if (contentFormat === "gdvideo")
+        return "video";
+    if (contentFormat === "gdaudio")
+        return "audio";
+    if (contentFormat === "gdfont")
+        return "font";
+    if (contentFormat === "gdtemplate")
+        return "template";
+    const mimeCategory = mimeType?.split("/", 1)[0]?.toLowerCase();
+    if (mimeCategory && DAM_ASSET_TYPES.has(mimeCategory))
+        return mimeCategory;
+    const normalizedFormat = format?.toLowerCase();
+    if (normalizedFormat && ["png", "jpg", "jpeg", "gif", "webp", "svg"].includes(normalizedFormat)) {
+        return "image";
+    }
+    if (normalizedFormat && ["mp4", "mov", "webm", "mkv"].includes(normalizedFormat)) {
+        return "video";
+    }
+    if (normalizedFormat && ["mp3", "wav", "m4a", "aac"].includes(normalizedFormat)) {
+        return "audio";
+    }
+    return undefined;
+}
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function publicTags(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const tags = value
+        .map((item) => typeof item === "string" ? item : stringValue(recordValue(item)?.name))
+        .filter((item) => Boolean(item));
+    return tags.length > 0 ? tags : undefined;
+}
+function publicTagIds(tagIds, tags) {
+    const values = Array.isArray(tagIds)
+        ? tagIds
+        : Array.isArray(tags)
+            ? tags.map((item) => recordValue(item)?.id)
+            : [];
+    const ids = values.filter((item) => typeof item === "string" || typeof item === "number");
+    return ids.length > 0 ? ids : undefined;
+}
+function compactRecord(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function publicAssetUrl(value) {
+    try {
+        const url = new URL(assertSafeHttpUrl(value, { context: "DAM 素材 URL" }));
+        if (isBlockedHost(url.hostname))
+            return undefined;
+        for (const key of [...url.searchParams.keys()]) {
+            if (isSensitiveKey(key))
+                url.searchParams.delete(key);
+        }
+        return url.toString();
+    }
+    catch {
+        return undefined;
+    }
+}
 function formatBytes(value) {
     if (!Number.isFinite(value))
         return "";
@@ -271,28 +434,3 @@ function formatBytes(value) {
 function quoteShell(value) {
     return /^[\w./:=,-]+$/.test(value) ? value : `"${value.replace(/"/g, '\\"')}"`;
 }
-const DAM_HELP = `Usage: gd-cli dam <command> [options]
-
-用于把本地文件上传到稿定素材库，获得可复用的 asset_id 和 CDN URL。
-适合在 Creative、Workflows 和其他自动化流程中反复引用同一批商品图、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>             添加标签，逗号分隔
-  --asset-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 --asset-format png,jpg
-  gd-cli dam delete ast_123 --yes
-`;