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

package/dist/src/creative/media.d.ts

@@ -0,0 +1,19 @@
+import type { UploadedAsset } from "../api/dam-client.js";
+import type { CreativeMedia } from "./contract.js";
+export interface PreparedCreativeMedia {
+    source: string;
+    url: string;
+    role: CreativeMedia["role"];
+    mime_type: string;
+    name: string;
+    from_user_upload: boolean;
+}
+export type CreativeMediaUploader = (file: string, options: {
+    register?: boolean;
+}) => Promise<UploadedAsset>;
+/**
+ * Resolve public media references into the URL-shaped payload expected by the
+ * Editor chat endpoint. Local files are uploaded as transient storage only;
+ * they are deliberately not registered as DAM assets.
+ */
+export declare function prepareCreativeMedia(media: CreativeMedia[] | undefined, upload: CreativeMediaUploader): Promise<PreparedCreativeMedia[]>;

package/dist/src/creative/media.js

@@ -0,0 +1,83 @@
+import { basename, extname } from "node:path";
+import { assertSafeHttpUrl } from "../utils/url-safety.js";
+/**
+ * Resolve public media references into the URL-shaped payload expected by the
+ * Editor chat endpoint. Local files are uploaded as transient storage only;
+ * they are deliberately not registered as DAM assets.
+ */
+export async function prepareCreativeMedia(media = [], upload) {
+    const prepared = [];
+    for (const item of media) {
+        if (isRemoteSource(item.source)) {
+            const url = assertSafeHttpUrl(item.source, { context: "Creative media" });
+            prepared.push({
+                source: item.source,
+                url,
+                role: item.role,
+                mime_type: inferMimeType(item.source),
+                name: inferName(item.source),
+                from_user_upload: false,
+            });
+            continue;
+        }
+        const uploaded = await upload(item.source, { register: false });
+        prepared.push({
+            source: item.source,
+            url: uploaded.url,
+            role: item.role,
+            mime_type: uploaded.mime_type || inferMimeType(uploaded.filename || item.source),
+            name: uploaded.filename || inferName(item.source),
+            from_user_upload: true,
+        });
+    }
+    return prepared;
+}
+function isRemoteSource(source) {
+    return /^https?:\/\//i.test(source);
+}
+function inferName(source) {
+    try {
+        if (isRemoteSource(source)) {
+            const url = new URL(source);
+            const value = basename(url.pathname);
+            return value || "creative-media";
+        }
+    }
+    catch {
+        // Input validation already rejects malformed URLs. Keep a safe fallback
+        // here for callers that use this helper independently.
+    }
+    return basename(source) || "creative-media";
+}
+function inferMimeType(source) {
+    const extension = extname(source.split("?")[0]?.split("#")[0] ?? "")
+        .slice(1)
+        .toLowerCase();
+    const mime = MIME_BY_EXTENSION[extension];
+    return mime ?? "application/octet-stream";
+}
+const MIME_BY_EXTENSION = {
+    aac: "audio/aac",
+    avif: "image/avif",
+    bmp: "image/bmp",
+    flac: "audio/flac",
+    gif: "image/gif",
+    heic: "image/heic",
+    heif: "image/heif",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    m4a: "audio/mp4",
+    m4v: "video/x-m4v",
+    mkv: "video/x-matroska",
+    mov: "video/quicktime",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    oga: "audio/ogg",
+    ogg: "audio/ogg",
+    opus: "audio/opus",
+    png: "image/png",
+    svg: "image/svg+xml",
+    wav: "audio/wav",
+    webm: "video/webm",
+    webp: "image/webp",
+};

package/dist/src/creative/protocol.d.ts

@@ -0,0 +1,60 @@
+import type { CreativeInput } from "./contract.js";
+import type { PreparedCreativeMedia } from "./media.js";
+export interface CreativeRequestIds {
+    local_thread_id: string;
+    local_message_id: string;
+}
+export interface CreativeAgentAttachment {
+    uri: string;
+    mime_type: string;
+    from_user_upload: boolean;
+}
+export interface CreativeAgentPromptText {
+    type: "text";
+    content: string;
+}
+export interface CreativeAgentPromptMedia {
+    type: "media";
+    url: string;
+    name: string;
+    mime: string;
+}
+export type CreativeAgentPromptItem = CreativeAgentPromptText | CreativeAgentPromptMedia;
+export interface CreativeAgentContent {
+    type: "plain" | "user";
+    text?: string;
+    prompt?: CreativeAgentPromptItem[];
+    parameters?: Record<string, unknown>;
+    answer?: {
+        answers: string[][];
+    };
+}
+export interface CreativeAgentRequest {
+    content: CreativeAgentContent;
+    name: "user" | "ask_user_question";
+    role: "user";
+    local_thread_id: string;
+    local_message_id: string;
+    thread_id: string;
+    attachments: CreativeAgentAttachment[];
+    extra: Record<string, unknown>;
+}
+/**
+ * Adapt the public Creative contract to the request shape emitted by the
+ * Editor chat sender. No model, skill, or tool identifier is selected here.
+ */
+export declare function buildCreativeAgentRequest(input: CreativeInput, media: PreparedCreativeMedia[] | undefined, ids: CreativeRequestIds): CreativeAgentRequest;
+export interface CreativeAgentMessage {
+    [key: string]: unknown;
+    message_id?: string;
+    messageId?: string;
+    thread_id?: string;
+    threadId?: string;
+    role?: string;
+    name?: string;
+    status?: string;
+    event?: string;
+    content?: unknown;
+    extra?: Record<string, unknown>;
+}
+export declare function normalizeCreativeMessages(messages: CreativeAgentMessage[], fallbackConversationId?: string): import("./contract.js").CreativeResult;

package/dist/src/creative/protocol.js

@@ -0,0 +1,337 @@
+import { CliUsageError } from "../core/output/cli-error.js";
+/**
+ * Adapt the public Creative contract to the request shape emitted by the
+ * Editor chat sender. No model, skill, or tool identifier is selected here.
+ */
+export function buildCreativeAgentRequest(input, media = [], ids) {
+    const promptItems = [];
+    if (input.prompt !== undefined) {
+        promptItems.push({ type: "text", content: input.prompt });
+    }
+    for (const item of media) {
+        // The Editor's first/last-frame plugin serializes the semantic role as a
+        // text prefix before the media node; role is not a completion media field.
+        if (item.role === "first_frame" || item.role === "last_frame") {
+            promptItems.push({
+                type: "text",
+                content: item.role === "first_frame" ? "首帧" : "尾帧",
+            });
+        }
+        promptItems.push({
+            type: "media",
+            url: item.url,
+            name: item.name,
+            mime: item.mime_type,
+        });
+    }
+    const isAnswer = Array.isArray(input.answers);
+    const content = isAnswer
+        ? buildAnswerContent(input, promptItems)
+        : buildCreationContent(input, promptItems);
+    const extra = {};
+    if (input.conversation_id && input.last_tool_message_id) {
+        extra.lastToolMessageId = input.last_tool_message_id;
+        extra.last_tool_message_id = input.last_tool_message_id;
+    }
+    if (isAnswer) {
+        const questions = input.answers.map(toEditorAnswer);
+        extra.askUserQuestionAnsweredQuestions = questions;
+        extra.questions = questions;
+    }
+    return {
+        content,
+        name: isAnswer ? "ask_user_question" : "user",
+        role: "user",
+        local_thread_id: input.conversation_id ? "" : ids.local_thread_id,
+        local_message_id: ids.local_message_id,
+        thread_id: input.conversation_id ?? "",
+        attachments: media.map((item) => ({
+            uri: item.url,
+            mime_type: item.mime_type,
+            from_user_upload: item.from_user_upload,
+        })),
+        extra,
+    };
+}
+function buildCreationContent(input, promptItems) {
+    const parameters = input.parameters
+        ? toEditorParameters(input.parameters)
+        : undefined;
+    // The Editor sends the compact plain-text form when no structured content
+    // exists. Keeping that form preserves the existing Agent text-chat path.
+    if (promptItems.length === 1 && promptItems[0]?.type === "text" && !parameters) {
+        return { type: "plain", text: promptItems[0].content };
+    }
+    return {
+        type: "plain",
+        prompt: promptItems,
+        ...(parameters ? { parameters } : {}),
+    };
+}
+function buildAnswerContent(input, promptItems) {
+    const text = input.prompt ?? "";
+    return {
+        type: "user",
+        text,
+        prompt: promptItems.length > 0 ? promptItems : [{ type: "text", content: text }],
+        ...(input.parameters ? { parameters: toEditorParameters(input.parameters) } : {}),
+        answer: {
+            answers: input.answers.map((answer) => [...answer.values]),
+        },
+    };
+}
+/**
+ * Keep the public contract descriptive while matching the field names used by
+ * the Editor's structured content payload. In particular, Editor serializes
+ * video duration as the string field `duration`.
+ */
+function toEditorParameters(parameters) {
+    return {
+        ...(parameters.ratio !== undefined ? { ratio: parameters.ratio } : {}),
+        ...(parameters.resolution !== undefined ? { resolution: parameters.resolution } : {}),
+        ...(parameters.duration_seconds !== undefined
+            ? { duration: String(parameters.duration_seconds) }
+            : {}),
+    };
+}
+function toEditorAnswer(answer) {
+    return {
+        question: answer.question,
+        answers: [...answer.values],
+    };
+}
+export function normalizeCreativeMessages(messages, fallbackConversationId = "") {
+    if (messages.length === 0) {
+        invalidAgentResponse("GD Agent 没有返回可识别的最终结果");
+    }
+    const systemError = messages.find((message) => message.event === "system_error");
+    if (systemError) {
+        const content = contentRecord(systemError.content);
+        invalidAgentResponse(stringValue(content?.text) || "GD Agent 返回系统错误");
+    }
+    const latest = new Map();
+    const anonymous = [];
+    for (const message of messages) {
+        const id = stringValue(message.message_id ?? message.messageId);
+        if (id)
+            latest.set(id, message);
+        else
+            anonymous.push(message);
+    }
+    const normalizedMessages = [...latest.values(), ...anonymous];
+    const conversationId = firstString(normalizedMessages, ["thread_id", "threadId"]) || fallbackConversationId;
+    if (!conversationId) {
+        invalidAgentResponse("GD Agent 返回结果缺少 conversation_id");
+    }
+    const ask = normalizedMessages.find((message) => isAskUserQuestion(message));
+    const outputs = [];
+    const textParts = [];
+    for (const message of normalizedMessages) {
+        const content = contentRecord(message.content);
+        const type = stringValue(content?.type);
+        if (type === "plain" || type === "user" || type === "text" || type === "system") {
+            const text = stringValue(content?.text);
+            if (text)
+                textParts.push(text);
+            continue;
+        }
+        if (type === "function_response") {
+            collectFunctionResponse(content?.text, outputs, textParts);
+            continue;
+        }
+        if (typeof message.content === "string" && message.content.trim()) {
+            textParts.push(message.content.trim());
+        }
+    }
+    if (ask) {
+        const questionData = parseAskUserQuestion(ask);
+        const lastToolMessageId = stringValue(ask.message_id ?? ask.messageId) ||
+            stringValue(ask.extra?.last_tool_message_id ?? ask.extra?.lastToolMessageId);
+        if (!lastToolMessageId) {
+            invalidAgentResponse("GD Agent 追问结果缺少追问消息标识");
+        }
+        if (questionData.questions.length === 0 ||
+            questionData.questions.some((question) => !question.question)) {
+            invalidAgentResponse("GD Agent 追问结果缺少有效问题");
+        }
+        return {
+            conversation_id: conversationId,
+            finish_reason: "requires_input",
+            message: textParts.at(-1) ?? questionData.title,
+            outputs: dedupeOutputs(outputs),
+            last_tool_message_id: lastToolMessageId,
+            questions: questionData,
+        };
+    }
+    const textOutputs = textParts
+        .filter(Boolean)
+        .map((text) => ({ type: "text", text }));
+    return {
+        conversation_id: conversationId,
+        finish_reason: "completed",
+        message: textParts.at(-1) ?? "创作已完成",
+        outputs: dedupeOutputs([...textOutputs, ...outputs]),
+    };
+}
+function invalidAgentResponse(message) {
+    throw new CliUsageError({
+        code: "CREATIVE_RESPONSE_INVALID",
+        type: "business",
+        message,
+        hint: "请稍后重试；如果问题持续，请保留本次请求信息联系稿定支持。",
+        retryable: true,
+    });
+}
+function isAskUserQuestion(message) {
+    const content = contentRecord(message.content);
+    if (content?.type !== "function_call")
+        return false;
+    const payload = parseJson(content.text);
+    return objectRecord(payload)?.name === "ask_user_question";
+}
+function parseAskUserQuestion(message) {
+    const content = contentRecord(message.content);
+    const payload = objectRecord(parseJson(content?.text));
+    const args = objectRecord(parseJson(payload?.arguments)) ?? objectRecord(payload?.arguments) ?? {};
+    const questions = Array.isArray(args.questions)
+        ? args.questions.map((question) => {
+            const item = objectRecord(question) ?? {};
+            const options = Array.isArray(item.options)
+                ? item.options
+                    .map((option) => {
+                    const value = objectRecord(option);
+                    const label = stringValue(value?.label);
+                    return label ? { label } : null;
+                })
+                    .filter((option) => option !== null)
+                : [];
+            return {
+                question: stringValue(item.question),
+                options,
+                allow_multiple: Boolean(item.allow_multiple ?? item.allowMultiple),
+            };
+        })
+        : [];
+    return {
+        title: stringValue(args.title),
+        questions,
+    };
+}
+function collectFunctionResponse(raw, outputs, textParts) {
+    const parsed = parseJson(raw);
+    const values = Array.isArray(parsed) ? parsed : parsed === undefined ? [] : [parsed];
+    for (const value of values) {
+        const record = objectRecord(value);
+        if (!record) {
+            if (typeof value === "string" && value.trim())
+                textParts.push(value.trim());
+            continue;
+        }
+        const text = stringValue(record.text);
+        if (text && !record.uri && !record.url)
+            textParts.push(text);
+        const url = stringValue(record.uri ?? record.url);
+        if (!url) {
+            if (Object.keys(record).length > 0 && !text)
+                outputs.push({ type: "json", value });
+            continue;
+        }
+        const mimeType = stringValue(record.mime_type ?? record.mimeType) || inferMimeType(url);
+        outputs.push({
+            type: mediaTypeFromMime(mimeType, url),
+            url,
+            mime_type: mimeType,
+            ...(stringValue(record.filename ?? record.name)
+                ? { name: stringValue(record.filename ?? record.name) }
+                : {}),
+            ...(stringValue(record.asset_id ?? record.assetId)
+                ? { asset_id: stringValue(record.asset_id ?? record.assetId) }
+                : {}),
+            ...(numberValue(record.width) !== undefined ? { width: numberValue(record.width) } : {}),
+            ...(numberValue(record.height) !== undefined ? { height: numberValue(record.height) } : {}),
+            ...(numberValue(record.duration_seconds ?? record.duration) !== undefined
+                ? { duration_seconds: numberValue(record.duration_seconds ?? record.duration) }
+                : {}),
+        });
+    }
+}
+function dedupeOutputs(outputs) {
+    const seen = new Set();
+    return outputs.filter((output) => {
+        const key = output.type === "text"
+            ? `text:${output.text}`
+            : output.type === "json"
+                ? `json:${JSON.stringify(output.value)}`
+                : `${output.type}:${output.url}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function contentRecord(value) {
+    return objectRecord(value) ?? undefined;
+}
+function objectRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function parseJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function stringValue(value) {
+    return typeof value === "string" ? value.trim() : value == null ? "" : String(value).trim();
+}
+function firstString(messages, keys) {
+    for (const message of messages) {
+        for (const key of keys) {
+            const value = stringValue(message[key]);
+            if (value)
+                return value;
+        }
+    }
+    return "";
+}
+function numberValue(value) {
+    const number = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+function inferMimeType(url) {
+    const extension = url.split("?")[0]?.split("#")[0]?.split(".").at(-1)?.toLowerCase();
+    return {
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        webp: "image/webp",
+        gif: "image/gif",
+        mp4: "video/mp4",
+        webm: "video/webm",
+        mov: "video/quicktime",
+        mp3: "audio/mpeg",
+        wav: "audio/wav",
+    }[extension ?? ""] ?? "application/octet-stream";
+}
+function mediaTypeFromMime(mime, url) {
+    if (mime.startsWith("image/"))
+        return "image";
+    if (mime.startsWith("video/"))
+        return "video";
+    if (mime.startsWith("audio/"))
+        return "audio";
+    const inferred = inferMimeType(url);
+    if (inferred.startsWith("image/"))
+        return "image";
+    if (inferred.startsWith("video/"))
+        return "video";
+    if (inferred.startsWith("audio/"))
+        return "audio";
+    return "file";
+}

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

@@ -1,3 +1,7 @@
-type ActionHandler = (...args: any[]) => Promise<void>;
-export declare function withAuth(handler: ActionHandler): ActionHandler;
+import type { Command } from "commander";
+import { type AuthGuardLike, type AuthRequirement } from "../core/auth/auth-guard.js";
+type AuthRequirementResolver = AuthRequirement | ((command: Command) => AuthRequirement);
+export declare function setAuthRequirement<T extends Command>(command: T, requirement: AuthRequirementResolver): T;
+export declare function authRequirementFor(command: Command): AuthRequirement;
+export declare function installAuthPreflight(program: Command, guard?: AuthGuardLike): void;
 export {};

package/dist/src/middleware/auth.js

@@ -1,5 +1,28 @@
-import { CredentialStoreV2 } from "../auth/credential-store-v2.js";
-import { OrgManager } from "../core/auth/org-manager.js";
+import { AuthGuard, } from "../core/auth/auth-guard.js";
+import { CliUsageError } from "../core/output/cli-error.js";
+import { withErrorHandler } from "./error-handler.js";
+const commandAuthRequirements = new WeakMap();
+export function setAuthRequirement(command, requirement) {
+    commandAuthRequirements.set(command, requirement);
+    return command;
+}
+export function authRequirementFor(command) {
+    const declared = commandAuthRequirements.get(command);
+    if (!declared) {
+        throw new CliUsageError({
+            code: "AUTH_POLICY_MISSING",
+            type: "unknown",
+            message: `命令 ${commandPath(command).join(" ")} 未声明鉴权级别。`,
+            retryable: false,
+        });
+    }
+    return typeof declared === "function" ? declared(command) : declared;
+}
+export function installAuthPreflight(program, guard = new AuthGuard()) {
+    program.hook("preAction", withErrorHandler(async (_thisCommand, actionCommand) => {
+        await guard.ensure(authRequirementFor(actionCommand));
+    }));
+}
 function commandPath(cmd) {
     const names = [];
     let c = cmd;
@@ -11,64 +34,3 @@ function commandPath(cmd) {
     }
     return names;
 }
-function shouldSkipAuth(cmd) {
-    const path = commandPath(cmd);
-    if (path.length === 0)
-        return false;
-    if (path[0] === "config")
-        return true;
-    if (path.includes("auth")) {
-        const sub = path[path.length - 1];
-        return sub === "login" || sub === "logout";
-    }
-    return false;
-}
-function isDirectBusinessCommand(cmd) {
-    const path = commandPath(cmd);
-    return path.includes("tools") || path.includes("workflows") || path.includes("dam");
-}
-export function withAuth(handler) {
-    return async (...args) => {
-        const command = args[args.length - 1];
-        if (shouldSkipAuth(command)) {
-            return handler(...args);
-        }
-        const v2Store = new CredentialStoreV2();
-        const v2 = v2Store.read();
-        if (v2) {
-            if (v2Store.isAkExpired()) {
-                console.error("Error: AK/SK 已过期");
-                console.error("\n  请重新登录：\n    gd-cli auth login\n");
-                process.exit(1);
-            }
-            if (v2Store.isBindExpired() && v2.current_org?.id) {
-                try {
-                    const orgMgr = new OrgManager();
-                    await orgMgr.switchOrg(v2.current_org.id);
-                }
-                catch {
-                    console.error("Error: 组织绑定已过期");
-                    console.error("\n  请切换组织：\n    gd-cli org switch\n");
-                    process.exit(1);
-                }
-            }
-            if (isDirectBusinessCommand(command) && !v2Store.read()?.current_org?.id) {
-                console.error("Error: 当前未绑定组织");
-                console.error("\n  请先切换组织：");
-                console.error("    gd-cli org switch\n");
-                process.exit(1);
-            }
-            return handler(...args);
-        }
-        if (isDirectBusinessCommand(command)) {
-            console.error("Error: 未找到 AK/SK 凭证");
-            console.error("\n  请先登录并绑定组织：");
-            console.error("    gd-cli auth login\n");
-            process.exit(1);
-        }
-        console.error("Error: 未找到 AK/SK 凭证");
-        console.error("\n  请先登录：");
-        console.error("    gd-cli auth login\n");
-        process.exit(1);
-    };
-}

package/dist/src/middleware/error-handler.d.ts

@@ -1,3 +1,5 @@
+import { type CliErrorBody } from "../core/output/envelope.js";
 type ActionHandler = (...args: any[]) => Promise<void>;
 export declare function withErrorHandler(handler: ActionHandler): ActionHandler;
+export declare function toCliErrorBody(error: unknown): CliErrorBody;
 export {};

package/dist/src/middleware/error-handler.js

@@ -11,11 +11,10 @@ const ERROR_GUIDES = {
     AUTH_EXPIRED: "凭证已过期，请重新登录：\n    gd-cli auth login",
     AUTH_REFRESH_FAILED: "凭证刷新失败：\n    gd-cli auth login",
     AUTH_SCOPE_DENIED: "权限不足，请重新授权",
-    ORG_BIND_EXPIRED: "组织绑定已过期：\n    gd-cli org switch",
     ORG_INVALID: "当前组织无效：\n    gd-cli org list",
     PARAM_MISSING: "查看命令帮助：\n    gd-cli <command> --help",
     PARAM_INVALID: "参数值不合法，请检查参数格式",
-    TOOL_NOT_FOUND: "工具不存在：\n    gd-cli tools list",
+    TOOL_NOT_FOUND: "能力路由不存在，请检查输入或重试当前命令",
     APP_NOT_FOUND: "Workflow 不存在：\n    gd-cli workflows list",
     TASK_NOT_FOUND: "任务不存在或已过期",
     RATE_LIMITED: "请求过于频繁，请稍后重试",
@@ -104,7 +103,7 @@ function isCommandLike(value) {
         "opts" in value &&
         typeof value.opts === "function");
 }
-function toCliErrorBody(error) {
+export function toCliErrorBody(error) {
     if (error instanceof CliUsageError) {
         return error.body;
     }
@@ -227,7 +226,7 @@ function printCliUsageError(body) {
             .filter(Boolean)
         : [];
     if (missingTools.length > 0) {
-        console.error(`  缺失 Tool: ${missingTools.join(", ")}`);
+        console.error(`  缺失内部能力: ${missingTools.join(", ")}`);
     }
     if (body.hint)
         console.error(`\n  说明: ${body.hint}`);