gaoding-cli 1.0.0-alpha.21 → 1.0.0-alpha.22

package/dist/src/features/dam/operation-executor.js

@@ -0,0 +1,72 @@
+export class DamOperationFailedError extends Error {
+    operation;
+    constructor(operation) {
+        super("DAM 操作执行失败。");
+        this.name = "DamOperationFailedError";
+        this.operation = operation;
+    }
+}
+export class DamOperationUnconfirmedError extends Error {
+    operation;
+    constructor(operation) {
+        super("DAM 操作已提交，但未能确认最终结果。");
+        this.name = "DamOperationUnconfirmedError";
+        this.operation = operation;
+    }
+}
+function copiedEntryId(resultIds) {
+    const unique = [...new Set((resultIds ?? []).filter((value) => value.trim() !== ""))];
+    return unique.length === 1 ? unique[0] : undefined;
+}
+export function createDamOperationExecutor(dependencies) {
+    return {
+        async execute(input) {
+            input.signal.throwIfAborted();
+            const startedAt = dependencies.now();
+            const submission = await input.submit();
+            input.signal.throwIfAborted();
+            const taskId = submission.task_id;
+            if (taskId === undefined) {
+                const copied = input.operation === "copy"
+                    ? copiedEntryId(submission.result_ids)
+                    : undefined;
+                return copied === undefined ? {} : { copied_entry_id: copied };
+            }
+            dependencies.annotate({ task_id: taskId });
+            let delayMilliseconds = 1_000;
+            const deadline = startedAt + 180_000;
+            while (true) {
+                input.signal.throwIfAborted();
+                if (dependencies.now() >= deadline) {
+                    throw new DamOperationUnconfirmedError(input.operation);
+                }
+                const task = await input.getTask(taskId, input.signal);
+                input.signal.throwIfAborted();
+                if (task === null)
+                    throw new DamOperationUnconfirmedError(input.operation);
+                if (task.status === 2) {
+                    if (task.fail_count !== null && task.fail_count > 0) {
+                        throw new DamOperationFailedError(input.operation);
+                    }
+                    if (input.operation !== "copy" || input.inspectResult === undefined)
+                        return {};
+                    const result = await input.inspectResult(taskId, input.signal);
+                    input.signal.throwIfAborted();
+                    const copied = copiedEntryId(result.result_ids);
+                    return copied === undefined ? {} : { copied_entry_id: copied };
+                }
+                if (task.status === 3)
+                    throw new DamOperationFailedError(input.operation);
+                if (task.status !== 0 && task.status !== 1) {
+                    throw new DamOperationUnconfirmedError(input.operation);
+                }
+                const remaining = deadline - dependencies.now();
+                if (remaining <= 0)
+                    throw new DamOperationUnconfirmedError(input.operation);
+                await dependencies.sleep(Math.min(delayMilliseconds, remaining), input.signal);
+                input.signal.throwIfAborted();
+                delayMilliseconds = Math.min(delayMilliseconds + 500, 3_000);
+            }
+        }
+    };
+}

package/dist/src/features/dam/repository-catalog.js

@@ -0,0 +1,127 @@
+import { RemoteProtocolError } from "../../platform/remote-protocol.js";
+const permissions = new Set([
+    "OWNER",
+    "MANAGE",
+    "EDIT",
+    "USE",
+    "READ"
+]);
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function rows(value) {
+    if (Array.isArray(value))
+        return value;
+    const nested = record(value)?.data;
+    if (Array.isArray(nested))
+        return nested;
+    throw new RemoteProtocolError();
+}
+function nonblank(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function permission(value) {
+    return typeof value === "string"
+        && permissions.has(value)
+        ? value
+        : undefined;
+}
+function privateRepositories(value) {
+    return rows(value).flatMap((candidate) => {
+        const item = record(candidate);
+        const repositoryId = nonblank(item?.repository_id);
+        const name = nonblank(item?.name) ?? nonblank(item?.title);
+        const type = item?.type === 1
+            ? "personal"
+            : item?.type === 6
+                ? "draft"
+                : undefined;
+        if (repositoryId === undefined || name === undefined || type === undefined)
+            return [];
+        return [{ repository_id: repositoryId, name, type, is_default: false }];
+    });
+}
+function teamRepositories(value) {
+    return rows(value).flatMap((candidate) => {
+        const item = record(candidate);
+        const repositoryId = nonblank(item?.repository_id);
+        const name = nonblank(item?.name) ?? nonblank(item?.title);
+        if (repositoryId === undefined || name === undefined)
+            return [];
+        const permissionCode = permission(item?.permission_code);
+        return [{
+                repository_id: repositoryId,
+                name,
+                type: "team",
+                ...(permissionCode === undefined ? {} : { permission_code: permissionCode }),
+                is_default: false
+            }];
+    });
+}
+function enterpriseRepositories(value) {
+    return rows(value).flatMap((candidate) => {
+        const item = record(candidate);
+        const repositoryId = nonblank(item?.id);
+        const name = nonblank(item?.name) ?? nonblank(item?.title);
+        if (repositoryId === undefined || name === undefined)
+            return [];
+        const permissionCode = permission(item?.permission_code);
+        return [{
+                repository_id: repositoryId,
+                name,
+                type: "enterprise",
+                ...(permissionCode === undefined ? {} : { permission_code: permissionCode }),
+                is_default: false
+            }];
+    });
+}
+export function normalizeRepositoryCatalog(privateRows, teamRows, enterpriseRows) {
+    const merged = [
+        ...privateRepositories(privateRows),
+        ...teamRepositories(teamRows),
+        ...enterpriseRepositories(enterpriseRows)
+    ];
+    const seen = new Set();
+    const unique = merged.filter((repository) => {
+        if (seen.has(repository.repository_id))
+            return false;
+        seen.add(repository.repository_id);
+        return true;
+    });
+    const defaultIndex = unique.findIndex((repository) => repository.type === "personal");
+    const selectedIndex = defaultIndex === -1 && unique.length > 0 ? 0 : defaultIndex;
+    return unique.map((repository, index) => ({
+        ...repository,
+        is_default: index === selectedIndex
+    }));
+}
+function requestContext(input) {
+    return {
+        credential: input.access.credential,
+        organizationId: input.access.organizationId,
+        signal: input.signal
+    };
+}
+export function createDamRepositoryCatalog(dependencies) {
+    return {
+        async list(input) {
+            const [privateRows, teamRows, enterpriseRows] = await Promise.all([
+                dependencies.transport.getJson({
+                    path: "/tb-dam/repositories",
+                    ...requestContext(input)
+                }),
+                dependencies.transport.getJson({
+                    path: "/tb-dam/teams",
+                    ...requestContext(input)
+                }),
+                dependencies.transport.getJson({
+                    path: "/dam/org-repositories",
+                    ...requestContext(input)
+                })
+            ]);
+            return normalizeRepositoryCatalog(privateRows, teamRows, enterpriseRows);
+        }
+    };
+}

package/dist/src/features/dam/use-cases.js

@@ -1,12 +1,19 @@
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { DamOperationUnconfirmedError } from "./operation-executor.js";
 export class DamInputError extends Error {
     constructor() {
         super("DAM 输入不可用。");
         this.name = "DamInputError";
     }
 }
+export class DamRepositoryNotFoundError extends Error {
+    constructor() {
+        super("当前组织没有可用的 DAM 资源库。");
+        this.name = "DamRepositoryNotFoundError";
+    }
+}
+export { DamOperationUnconfirmedError } from "./operation-executor.js";
 function invalid() {
     throw new DamInputError();
 }
@@ -17,6 +24,14 @@ function assertPageSize(value) {
     if (value !== undefined && (!Number.isInteger(value) || value < 1 || value > 100))
         invalid();
 }
+function assertPage(value) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 1))
+        invalid();
+}
+function assertOptionalNonblank(value) {
+    if (value !== undefined && !nonblank(value))
+        invalid();
+}
 function assertAssetId(value) {
     if (value.trim() === "" || /^https?:\/\//iu.test(value))
         invalid();
@@ -42,23 +57,139 @@ function searchRequest(input, keyword, repositoryIds) {
 }
 export function createDamUseCases(dependencies) {
     const validate = dependencies.validate;
+    async function entryTitle(input) {
+        if (input.kind === "asset") {
+            return (await dependencies.api.getAsset({
+                assetId: input.entryId,
+                access: input.access,
+                signal: input.signal
+            })).title;
+        }
+        return (await dependencies.api.getFolder({
+            folderId: input.entryId,
+            repositoryId: input.repositoryId,
+            access: input.access,
+            signal: input.signal
+        })).title;
+    }
+    async function entryLocation(input) {
+        if (input.kind === "asset") {
+            const detail = await dependencies.api.getAsset({
+                assetId: input.entryId,
+                access: input.access,
+                signal: input.signal
+            });
+            return {
+                ...(detail.repository_id === undefined ? {} : { repositoryId: detail.repository_id }),
+                ...(detail.folder_id === undefined ? {} : { folderId: detail.folder_id })
+            };
+        }
+        const detail = await dependencies.api.getFolder({
+            folderId: input.entryId,
+            repositoryId: input.repositoryId,
+            access: input.access,
+            signal: input.signal
+        });
+        return { repositoryId: detail.repository_id, folderId: detail.folder_id };
+    }
+    function assertEntryOperationInput(input) {
+        assertAssetId(input.entry_id);
+        if (input.kind !== "asset" && input.kind !== "folder")
+            invalid();
+        if (!nonblank(input.targetFolderId))
+            invalid();
+        assertOptionalNonblank(input.repositoryId);
+        assertOptionalNonblank(input.targetRepositoryId);
+        if (input.kind === "folder" && input.entry_id === input.targetFolderId)
+            invalid();
+    }
+    async function entryOperation(input) {
+        assertEntryOperationInput(input.request);
+        const [sourceRepository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+            ...(input.request.repositoryId === undefined
+                ? {}
+                : { repositoryId: input.request.repositoryId })
+        }, input.access, input.signal)));
+        if (sourceRepository === undefined)
+            throw new DamRepositoryNotFoundError();
+        const targetRepositoryId = input.request.targetRepositoryId ?? sourceRepository.id;
+        const locationRequest = {
+            entryId: input.request.entry_id,
+            kind: input.request.kind,
+            repositoryId: sourceRepository.id,
+            access: input.access,
+            signal: input.signal
+        };
+        const current = await dependencies.telemetry.stage("resolve", () => (entryLocation(locationRequest)));
+        if (input.operation === "move"
+            && current.repositoryId === targetRepositoryId
+            && current.folderId === input.request.targetFolderId)
+            invalid();
+        const execution = await dependencies.telemetry.stage("wait", () => (dependencies.operations.execute({
+            operation: input.operation,
+            submit: () => dependencies.telemetry.stage("submit", () => (dependencies.api.submitEntryOperation({
+                entryId: input.request.entry_id,
+                kind: input.request.kind,
+                operation: input.operation,
+                sourceRepositoryId: sourceRepository.id,
+                targetRepositoryId,
+                targetFolderId: input.request.targetFolderId,
+                access: input.access,
+                signal: input.signal
+            }))),
+            getTask: (taskId, signal) => dependencies.api.getOperationTask({
+                taskId,
+                access: input.access,
+                signal
+            }),
+            ...(input.operation === "copy"
+                ? {
+                    inspectResult: (taskId, signal) => (dependencies.api.getOperationChildren({
+                        taskId,
+                        access: input.access,
+                        signal
+                    }))
+                }
+                : {}),
+            signal: input.signal
+        })));
+        return {
+            sourceRepositoryId: sourceRepository.id,
+            targetRepositoryId,
+            targetFolderId: input.request.targetFolderId,
+            ...(execution.copied_entry_id === undefined
+                ? {}
+                : { copiedEntryId: execution.copied_entry_id })
+        };
+    }
     async function resolveRepositories(input, access, signal) {
         assertRepositorySelection(input);
         if (input.repositoryId !== undefined)
             return [{ id: input.repositoryId }];
         signal.throwIfAborted();
-        const available = await dependencies.api.listRepositories({ access, signal });
+        const available = await dependencies.repositories.list({ access, signal });
         signal.throwIfAborted();
         if (available.length === 0)
-            throw new RemoteRequestError();
-        if (input.allRepositories === true)
-            return available;
-        const selected = available.find((repository) => repository.type === 1) ?? available[0];
-        if (selected === undefined)
-            throw new RemoteRequestError();
-        return [selected];
+            throw new DamRepositoryNotFoundError();
+        const selected = input.allRepositories === true
+            ? available
+            : [available.find((repository) => repository.is_default) ?? available[0]];
+        return selected.map((repository) => ({
+            id: repository.repository_id,
+            ...(repository.name === undefined ? {} : { name: repository.name })
+        }));
     }
     return {
+        async repositoryList({ access, signal }) {
+            signal.throwIfAborted();
+            const repositories = await dependencies.repositories.list({ access, signal });
+            signal.throwIfAborted();
+            if (repositories.length === 0)
+                throw new DamRepositoryNotFoundError();
+            const result = { repositories };
+            validate.repositoryList(result);
+            return result;
+        },
         async list({ input, access, signal }) {
             signal.throwIfAborted();
             assertPageSize(input.pageSize);
@@ -91,6 +222,187 @@ export function createDamUseCases(dependencies) {
                 return result;
             });
         },
+        async folderList({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertOptionalNonblank(input.parentId);
+            assertOptionalNonblank(input.query);
+            assertPage(input.page);
+            assertPageSize(input.pageSize);
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.listFolders({
+                    repositoryId: repository.id,
+                    parentId: input.parentId ?? "0",
+                    page: input.page ?? 1,
+                    pageSize: input.pageSize ?? 20,
+                    ...(input.query === undefined ? {} : { query: input.query }),
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.folderList(result);
+                return result;
+            });
+        },
+        async tagList({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertOptionalNonblank(input.query);
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.listTags({
+                    repositoryId: repository.id,
+                    ...(input.query === undefined ? {} : { query: input.query }),
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.tagList(result);
+                return result;
+            });
+        },
+        async download({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertAssetId(input.asset_id);
+            assertOptionalNonblank(input.outputDir);
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            const detail = await dependencies.telemetry.stage("resolve", () => (dependencies.api.getAsset({ assetId: input.asset_id, access, signal })));
+            signal.throwIfAborted();
+            const urls = await dependencies.telemetry.stage("download", () => (dependencies.api.getDownloadUrls({
+                assetId: input.asset_id,
+                repositoryId: repository.id,
+                access,
+                signal
+            })));
+            signal.throwIfAborted();
+            const files = await dependencies.telemetry.stage("persist", () => (dependencies.downloader.download({
+                urls,
+                ...(detail.title === undefined ? {} : { fallbackTitle: detail.title }),
+                ...(detail.format === undefined ? {} : { fallbackFormat: detail.format }),
+                outputDirectory: input.outputDir ?? ".",
+                signal
+            })));
+            signal.throwIfAborted();
+            const result = { asset_id: input.asset_id, files };
+            validate.download(result);
+            return result;
+        },
+        async rename({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertAssetId(input.entry_id);
+            if (input.kind !== "asset" && input.kind !== "folder")
+                invalid();
+            if (!nonblank(input.title) || input.title.length > 100)
+                invalid();
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal)));
+            if (repository === undefined)
+                throw new DamRepositoryNotFoundError();
+            const request = {
+                entryId: input.entry_id,
+                kind: input.kind,
+                repositoryId: repository.id,
+                access,
+                signal
+            };
+            const currentTitle = await dependencies.telemetry.stage("rename", async () => {
+                const title = await entryTitle(request);
+                signal.throwIfAborted();
+                if (title?.trim() !== input.title.trim()) {
+                    await dependencies.api.renameEntry({
+                        ...request,
+                        repositoryId: repository.id,
+                        title: input.title
+                    });
+                }
+                return title;
+            });
+            if (currentTitle?.trim() === input.title.trim()) {
+                const result = {
+                    entry_id: input.entry_id,
+                    kind: input.kind,
+                    repository_id: repository.id,
+                    title: currentTitle
+                };
+                validate.rename(result);
+                return result;
+            }
+            await dependencies.telemetry.stage("verify", async () => {
+                for (let attempt = 0; attempt <= 30; attempt += 1) {
+                    signal.throwIfAborted();
+                    if (await entryTitle(request) === input.title)
+                        return;
+                    if (attempt < 30)
+                        await dependencies.sleep(2_000, signal);
+                }
+                throw new DamOperationUnconfirmedError("rename");
+            });
+            const result = {
+                entry_id: input.entry_id,
+                kind: input.kind,
+                repository_id: repository.id,
+                title: input.title
+            };
+            validate.rename(result);
+            return result;
+        },
+        async move({ input, access, signal }) {
+            signal.throwIfAborted();
+            const operation = await entryOperation({ operation: "move", request: input, access, signal });
+            await dependencies.telemetry.stage("verify", async () => {
+                for (let attempt = 0; attempt <= 30; attempt += 1) {
+                    signal.throwIfAborted();
+                    const location = await entryLocation({
+                        entryId: input.entry_id,
+                        kind: input.kind,
+                        repositoryId: operation.targetRepositoryId,
+                        access,
+                        signal
+                    });
+                    if (location.repositoryId === operation.targetRepositoryId
+                        && location.folderId === operation.targetFolderId)
+                        return;
+                    if (attempt < 30)
+                        await dependencies.sleep(2_000, signal);
+                }
+                throw new DamOperationUnconfirmedError("move");
+            });
+            const result = {
+                entry_id: input.entry_id,
+                kind: input.kind,
+                repository_id: operation.targetRepositoryId,
+                folder_id: operation.targetFolderId
+            };
+            await dependencies.telemetry.stage("output", () => { validate.move(result); });
+            return result;
+        },
+        async copy({ input, access, signal }) {
+            signal.throwIfAborted();
+            const operation = await entryOperation({ operation: "copy", request: input, access, signal });
+            const result = {
+                source_entry_id: input.entry_id,
+                kind: input.kind,
+                repository_id: operation.targetRepositoryId,
+                folder_id: operation.targetFolderId,
+                ...(operation.copiedEntryId === undefined
+                    ? {}
+                    : { copied_entry_id: operation.copiedEntryId })
+            };
+            await dependencies.telemetry.stage("output", () => { validate.copy(result); });
+            return result;
+        },
         async get({ input, access, signal }) {
             signal.throwIfAborted();
             assertAssetId(input.asset_id);
@@ -120,7 +432,7 @@ export function createDamUseCases(dependencies) {
                 ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
             }, access, signal)));
             if (repository === undefined)
-                throw new RemoteRequestError();
+                throw new DamRepositoryNotFoundError();
             const result = await dependencies.uploader.upload({
                 input,
                 file,
@@ -139,7 +451,7 @@ export function createDamUseCases(dependencies) {
                 ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
             }, access, signal)));
             if (repository === undefined)
-                throw new RemoteRequestError();
+                throw new DamRepositoryNotFoundError();
             const request = {
                 repositoryId: repository.id,
                 assetId: input.asset_id,

package/dist/src/features/editor/bridge-server.js

@@ -3,11 +3,14 @@ import { createServer } from "node:http";
 import { WebSocket, WebSocketServer } from "ws";
 import { EDITOR_PROTOCOL_VERSION } from "./protocol.js";
 const DEFAULT_RPC_TIMEOUT_MS = 60_000;
+const DEFAULT_SAVE_RPC_TIMEOUT_MS = 5 * 60_000 + 30_000;
 export async function startEditorBridge(options) {
     const token = options.token ?? randomBytes(32).toString("hex");
     const now = options.now ?? (() => new Date());
     const nextRequestId = options.requestId ?? randomUUID;
-    const rpcTimeoutMs = Math.max(0, options.rpcTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS);
+    const rpcTimeoutOverrideMs = options.rpcTimeoutMs === undefined
+        ? undefined
+        : Math.max(0, options.rpcTimeoutMs);
     const webSockets = new WebSocketServer({ noServer: true });
     let pageSocket = null;
     let pending;
@@ -146,6 +149,8 @@ export async function startEditorBridge(options) {
             }
             const requestId = nextRequestId();
             const socket = pageSocket;
+            const rpcTimeoutMs = rpcTimeoutOverrideMs
+                ?? (body.method === "save" ? DEFAULT_SAVE_RPC_TIMEOUT_MS : DEFAULT_RPC_TIMEOUT_MS);
             const timer = setTimeout(() => {
                 const current = takePending(requestId);
                 if (!current)

package/dist/src/platform/signature.js

@@ -3,7 +3,8 @@ export function canonicalizeQuery(entries) {
     const sorted = [...entries].sort(([left], [right]) => left.localeCompare(right));
     return new URLSearchParams(sorted.map(([key, value]) => [key, value]))
         .toString()
-        .replaceAll("%2C", ",");
+        .replaceAll("%2C", ",")
+        .replaceAll("%3A", ":");
 }
 export function createSigningString(input) {
     return `${input.method.toUpperCase()}@${input.pathname}@${input.canonicalQuery}@${input.timestamp}`;

package/dist/src/platform/signed-http-transport.js

@@ -108,13 +108,21 @@ export function createSignedHttpTransport(options) {
             throw new RemoteProtocolError(evidence);
         }
     }
+    async function getJsonResponse(request) {
+        const response = await send("GET", request, "application/json", undefined, true);
+        return { body: await json(response), headers: response.headers };
+    }
     return {
         async getJson(request) {
-            return json(await send("GET", request, "application/json", undefined, true));
+            return (await getJsonResponse(request)).body;
         },
+        getJsonResponse,
         async postJson(request) {
             return json(await send("POST", request, "application/json", JSON.stringify(request.body), true));
         },
+        async putJson(request) {
+            return json(await send("PUT", request, "application/json", JSON.stringify(request.body), true));
+        },
         async postStream(request) {
             const response = await send("POST", request, request.accept, JSON.stringify(request.body), false);
             if (!response.ok) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaoding-cli",
-  "version": "1.0.0-alpha.21",
+  "version": "1.0.0-alpha.22",
   "description": "Gaoding command-line interface for agents and people.",
   "type": "module",
   "license": "MIT",

package/skills/gd-cli/SKILL.md

@@ -9,7 +9,7 @@ description: Use when creating images, videos or text with GD CLI, operating the
 
 - 按业务意图选择 Agent / Tool 创作路由、发现 Model 并生成图片、视频或文本：[创作](references/creation.md)
 - 操作当前 AI+ Editor 作品：[编辑器](references/editor.md)
-- 查询、上传或删除 DAM 素材：[素材管理](references/dam.md)
+- 发现资源库、文件夹与标签，查询、上传、下载或单条目管理 DAM 资源：[素材管理](references/dam.md)
 - 登录或选择组织：[登录与组织](references/auth-org.md)
 - 处理输出、警告、失败或中断：[错误处理](references/errors.md)
 - 更新 CLI 与随包 Agent Skill：[更新](references/update.md)