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

package/dist/src/features/dam/dam-api-adapter.js

@@ -1,4 +1,6 @@
 import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { RemoteProtocolError } from "../../platform/remote-protocol.js";
+import { parseSafeRemoteAssetUrl, UrlSafetyError } from "../../platform/url-safety.js";
 import { projectDamAssetDetail, projectDamAssetSummary } from "./asset-projection.js";
 export class DamAssetNotFoundError extends Error {
     constructor() {
@@ -6,6 +8,18 @@ export class DamAssetNotFoundError extends Error {
         this.name = "DamAssetNotFoundError";
     }
 }
+export class DamAssetNotDownloadableError extends Error {
+    constructor() {
+        super("该 DAM 素材当前不可下载。");
+        this.name = "DamAssetNotDownloadableError";
+    }
+}
+export class DamFolderNotFoundError extends Error {
+    constructor() {
+        super("DAM 文件夹不存在。");
+        this.name = "DamFolderNotFoundError";
+    }
+}
 const contentFormats = {
     image: ["gdpic", "gdimage"],
     video: ["gdvideo"],
@@ -25,28 +39,245 @@ function nonblank(value) {
 function finiteNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
-function repositories(response) {
-    const source = Array.isArray(response)
-        ? response
-        : Array.isArray(record(response)?.data)
-            ? record(response)?.data
-            : undefined;
-    if (source === undefined)
-        throw new RemoteRequestError();
-    return source.flatMap((value) => {
-        const item = record(value);
-        const id = nonblank(item?.repository_id) ?? nonblank(item?.id);
-        if (item === undefined || id === undefined)
+function nonnegativeInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+const permissions = new Set(["OWNER", "MANAGE", "EDIT", "USE", "READ"]);
+function folderPermission(value) {
+    return typeof value === "string"
+        && permissions.has(value)
+        ? value
+        : undefined;
+}
+function optionalString(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const projected = String(value);
+    return projected.trim() === "" ? undefined : projected;
+}
+function folderRows(value) {
+    if (!Array.isArray(value))
+        throw new RemoteProtocolError();
+    return value.flatMap((candidate) => {
+        const item = record(candidate);
+        const folderId = nonblank(item?.id);
+        const title = nonblank(item?.title);
+        const parentId = nonblank(item?.parent_id);
+        const repositoryId = nonblank(item?.repository_id);
+        if (folderId === undefined
+            || title === undefined
+            || parentId === undefined
+            || repositoryId === undefined)
             return [];
-        const name = nonblank(item.name) ?? nonblank(item.title);
-        const type = finiteNumber(item.type);
+        const permissionCode = folderPermission(item?.permission_code);
+        const path = nonblank(item?.path);
+        const createdAt = optionalString(item?.created_at);
+        const updatedAt = optionalString(item?.updated_at);
         return [{
-                id,
-                ...(name === undefined ? {} : { name }),
-                ...(type === undefined ? {} : { type })
+                folder_id: folderId,
+                title,
+                parent_id: parentId,
+                repository_id: repositoryId,
+                ...(permissionCode === undefined ? {} : { permission_code: permissionCode }),
+                child_folder_count: nonnegativeInteger(item?.child_folder_count),
+                asset_count: nonnegativeInteger(item?.content_count),
+                ...(path === undefined ? {} : { path }),
+                ...(createdAt === undefined ? {} : { created_at: createdAt }),
+                ...(updatedAt === undefined ? {} : { updated_at: updatedAt })
             }];
     });
 }
+function folderPagination(headers) {
+    const raw = headers.get("x-pagination");
+    if (raw === null)
+        throw new RemoteProtocolError();
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new RemoteProtocolError();
+    }
+    const pagination = record(value);
+    const page = pagination?.num;
+    const pageSize = pagination?.size;
+    const total = pagination?.total;
+    if (!Number.isInteger(page) || page < 1
+        || !Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100
+        || !Number.isInteger(total) || total < 0) {
+        throw new RemoteProtocolError();
+    }
+    return { page: page, pageSize: pageSize, total: total };
+}
+function tagRows(value) {
+    if (!Array.isArray(value))
+        throw new RemoteProtocolError();
+    return value.flatMap((candidate) => {
+        const item = record(candidate);
+        const tagId = nonblank(item?.id);
+        const name = nonblank(item?.name);
+        if (tagId === undefined || name === undefined)
+            return [];
+        const groupId = nonblank(item?.group_id);
+        return [{
+                tag_id: tagId,
+                name,
+                ...(groupId === undefined ? {} : { group_id: groupId }),
+                asset_count: nonnegativeInteger(item?.file_count)
+            }];
+    });
+}
+function downloadUrls(value) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new RemoteProtocolError();
+    }
+    const urls = value.filter((item) => (typeof item === "string" && item.trim() !== ""));
+    if (urls.length === 0)
+        throw new DamAssetNotDownloadableError();
+    for (const value of urls) {
+        try {
+            const url = parseSafeRemoteAssetUrl(value);
+            if (url.protocol !== "https:")
+                throw new UrlSafetyError();
+        }
+        catch (error) {
+            if (error instanceof UrlSafetyError)
+                throw new RemoteProtocolError();
+            throw error;
+        }
+    }
+    return urls;
+}
+function folderDetail(response) {
+    for (const source of responseRecords(response).reverse()) {
+        const entryId = nonblank(source.id);
+        const title = nonblank(source.title);
+        const repositoryId = nonblank(source.repository_id);
+        const parentId = nonblank(source.parent_id);
+        if (entryId !== undefined
+            && title !== undefined
+            && repositoryId !== undefined
+            && parentId !== undefined) {
+            return {
+                entry_id: entryId,
+                kind: "folder",
+                title,
+                repository_id: repositoryId,
+                folder_id: parentId
+            };
+        }
+    }
+    throw new RemoteProtocolError();
+}
+function operationSubmission(response) {
+    const root = record(response);
+    const source = record(root?.data) ?? root;
+    if (source === undefined)
+        throw new RemoteProtocolError();
+    const rawTaskId = source.task_id;
+    let taskId;
+    if (rawTaskId !== undefined && rawTaskId !== null) {
+        if (typeof rawTaskId === "number") {
+            if (!Number.isSafeInteger(rawTaskId) || rawTaskId < 0)
+                throw new RemoteProtocolError();
+            if (rawTaskId !== 0)
+                taskId = String(rawTaskId);
+        }
+        else if (typeof rawTaskId === "string" && rawTaskId.trim() !== "") {
+            if (rawTaskId.trim() !== "0")
+                taskId = rawTaskId.trim();
+        }
+        else {
+            throw new RemoteProtocolError();
+        }
+    }
+    const rawResultIds = source.result_ids;
+    if (rawResultIds !== undefined && !Array.isArray(rawResultIds)) {
+        throw new RemoteProtocolError();
+    }
+    const resultIds = Array.isArray(rawResultIds)
+        ? rawResultIds.filter((item) => nonblank(item) !== undefined)
+        : [];
+    return {
+        ...(taskId === undefined ? {} : { task_id: taskId }),
+        ...(rawResultIds === undefined ? {} : { result_ids: resultIds })
+    };
+}
+function taskRows(response) {
+    if (Array.isArray(response))
+        return response;
+    const data = record(response)?.data;
+    if (Array.isArray(data))
+        return data;
+    throw new RemoteProtocolError();
+}
+function operationTask(response, taskId) {
+    const matches = taskRows(response).flatMap((candidate) => {
+        const item = record(candidate);
+        return nonblank(item?.id) === taskId ? [item] : [];
+    });
+    if (matches.length === 0)
+        return null;
+    if (matches.length !== 1)
+        throw new RemoteProtocolError();
+    const item = matches[0];
+    const status = item.status;
+    const progress = item.progress;
+    const totalCount = item.total_count;
+    const successCount = item.success_count;
+    const failCount = item.fail_count;
+    if (!Number.isInteger(status)
+        || typeof progress !== "number" || !Number.isFinite(progress) || progress < 0
+        || (totalCount !== null
+            && (!Number.isInteger(totalCount) || totalCount < 0))
+        || (successCount !== null
+            && (!Number.isInteger(successCount) || successCount < 0))
+        || (failCount !== null
+            && (!Number.isInteger(failCount) || failCount < 0))) {
+        throw new RemoteProtocolError();
+    }
+    return {
+        id: taskId,
+        status: status,
+        progress,
+        total_count: totalCount,
+        success_count: successCount,
+        fail_count: failCount
+    };
+}
+function operationChildren(response) {
+    const root = record(response);
+    const source = record(root?.data) ?? root;
+    if (source === undefined)
+        throw new RemoteProtocolError();
+    const rawResultIds = source.result_ids;
+    if (rawResultIds !== undefined && !Array.isArray(rawResultIds)) {
+        throw new RemoteProtocolError();
+    }
+    const repositoryId = nonblank(source.repository_id);
+    const targetRepositoryId = nonblank(source.target_repository_id);
+    const targetParentId = nonblank(source.target_parent_id);
+    return {
+        result_ids: Array.isArray(rawResultIds)
+            ? rawResultIds.filter((item) => nonblank(item) !== undefined)
+            : [],
+        ...(repositoryId === undefined ? {} : { repository_id: repositoryId }),
+        ...(targetRepositoryId === undefined ? {} : {
+            target_repository_id: targetRepositoryId
+        }),
+        ...(targetParentId === undefined ? {} : { target_parent_id: targetParentId })
+    };
+}
+function assertSingleOperationInput(input) {
+    if (nonblank(input.entryId) === undefined
+        || (input.kind !== "asset" && input.kind !== "folder")
+        || (input.operation !== "move" && input.operation !== "copy")
+        || nonblank(input.sourceRepositoryId) === undefined
+        || nonblank(input.targetRepositoryId) === undefined
+        || nonblank(input.targetFolderId) === undefined) {
+        throw new TypeError("Invalid DAM single-entry operation input.");
+    }
+}
 function assetId(response) {
     const root = record(response);
     const nested = record(root?.data);
@@ -120,13 +351,6 @@ function recycleBody(input) {
 }
 export function createDamApiAdapter(dependencies) {
     return {
-        async listRepositories(input) {
-            const response = await dependencies.transport.getJson({
-                path: "/tb-dam/repositories",
-                ...requestContext(input)
-            });
-            return repositories(response);
-        },
         async search(input) {
             const response = await dependencies.transport.postJson({
                 path: "/dam/asset/v2/search/simple",
@@ -137,18 +361,16 @@ export function createDamApiAdapter(dependencies) {
                     include_child_folder: input.includeChildFolder,
                     recycle: false,
                     page_size: input.pageSize,
-                    page_num: 1,
-                    page: 1,
                     sort: ["-top_time", "-updated_at"],
                     ...(input.cursor === undefined
                         ? {}
-                        : { query_id: input.cursor, cursor: input.cursor }),
+                        : { query_id: input.cursor }),
                     ...(input.type === undefined
                         ? {}
                         : { content_format_list: contentFormats[input.type] }),
                     ...(input.assetFormats === undefined || input.assetFormats.length === 0
                         ? {}
-                        : { format_list: input.assetFormats }),
+                        : { format: input.assetFormats }),
                     ...(input.tagIds === undefined || input.tagIds.length === 0
                         ? {}
                         : { tag_ids: input.tagIds })
@@ -157,6 +379,125 @@ export function createDamApiAdapter(dependencies) {
             });
             return searchResult(response, input);
         },
+        async listFolders(input) {
+            const response = await dependencies.transport.getJsonResponse({
+                path: "/tb-dam/folders",
+                query: {
+                    repository_ids: input.repositoryId,
+                    parent_id: input.parentId,
+                    keyword: input.query ?? "",
+                    page_num: String(input.page),
+                    page_size: String(input.pageSize),
+                    filter_no_permission: "true",
+                    include_children: String(input.query !== undefined),
+                    sort: "topTime:desc,updatedAt:desc"
+                },
+                ...requestContext(input)
+            });
+            const pagination = folderPagination(response.headers);
+            return {
+                repository_id: input.repositoryId,
+                parent_id: input.parentId,
+                page: pagination.page,
+                page_size: pagination.pageSize,
+                total: pagination.total,
+                folders: folderRows(response.body)
+            };
+        },
+        async listTags(input) {
+            const response = await dependencies.transport.getJson({
+                path: "/tb-dam/tags",
+                query: {
+                    repository_id: input.repositoryId,
+                    group_id: "",
+                    ...(input.query === undefined ? {} : { keyword: input.query })
+                },
+                ...requestContext(input)
+            });
+            return { repository_id: input.repositoryId, tags: tagRows(response) };
+        },
+        async getDownloadUrls(input) {
+            const response = await dependencies.transport.getJson({
+                path: `/dam/asset/files/download/${encodeURIComponent(input.assetId)}/url-list`,
+                query: { repository_id: input.repositoryId },
+                ...requestContext(input)
+            });
+            return downloadUrls(response);
+        },
+        async getFolder(input) {
+            let response;
+            try {
+                response = await dependencies.transport.getJson({
+                    path: `/dam/folders/${encodeURIComponent(input.folderId)}`,
+                    query: { repository_id: input.repositoryId },
+                    ...requestContext(input)
+                });
+            }
+            catch (error) {
+                if (error instanceof RemoteRequestError && error.status === 404) {
+                    throw new DamFolderNotFoundError();
+                }
+                throw error;
+            }
+            return folderDetail(response);
+        },
+        async renameEntry(input) {
+            await dependencies.transport.putJson({
+                path: input.kind === "asset"
+                    ? `/dam/asset/${encodeURIComponent(input.entryId)}/rename`
+                    : `/dam/folders/${encodeURIComponent(input.entryId)}/rename`,
+                body: {
+                    id: input.entryId,
+                    repository_id: input.repositoryId,
+                    title: input.title
+                },
+                ...requestContext(input)
+            });
+        },
+        async submitEntryOperation(input) {
+            assertSingleOperationInput(input);
+            const asset = input.kind === "asset";
+            const body = asset
+                ? {
+                    source_infos: [{
+                            source_repository_id: input.sourceRepositoryId,
+                            content_ids: [input.entryId]
+                        }],
+                    target_folder_id: input.targetFolderId,
+                    target_repository_id: input.targetRepositoryId,
+                    ...(input.operation === "copy" ? { expand: false } : {})
+                }
+                : {
+                    folder_ids: [input.entryId],
+                    parent_id: input.targetFolderId,
+                    repository_id: input.sourceRepositoryId,
+                    target_repository_id: input.targetRepositoryId,
+                    ...(input.operation === "copy" ? { expand: false } : {})
+                };
+            const response = await dependencies.transport.postJson({
+                path: asset
+                    ? `/dam/asset/multi-repository/${input.operation}`
+                    : `/dam/folders/v2/${input.operation}`,
+                body,
+                ...requestContext(input)
+            });
+            return operationSubmission(response);
+        },
+        async getOperationTask(input) {
+            const response = await dependencies.transport.getJson({
+                path: "/dam/task/list",
+                query: { ids: input.taskId },
+                ...requestContext(input)
+            });
+            return operationTask(response, input.taskId);
+        },
+        async getOperationChildren(input) {
+            const response = await dependencies.transport.getJson({
+                path: `/dam/task/children-detail/${encodeURIComponent(input.taskId)}`,
+                ...requestContext(input)
+            });
+            return operationChildren(response);
+        },
         async getAsset(input) {
             let response;
             try {

package/dist/src/features/dam/file-downloader.js

@@ -0,0 +1,242 @@
+import { createHash, randomUUID } from "node:crypto";
+import { access, mkdir, open, rename, rm } from "node:fs/promises";
+import { extname, resolve } from "node:path";
+import { parseSafeRemoteAssetUrl } from "../../platform/url-safety.js";
+export class DamDownloadError extends Error {
+    constructor() {
+        super("素材下载失败。");
+        this.name = "DamDownloadError";
+    }
+}
+export class DamDownloadDestinationExistsError extends Error {
+    constructor() {
+        super("目标文件已存在，未覆盖任何文件。");
+        this.name = "DamDownloadDestinationExistsError";
+    }
+}
+const redirectStatuses = new Set([301, 302, 303, 307, 308]);
+const maximumRedirects = 5;
+const maximumFilenameLength = 180;
+const nodeFileSystem = {
+    async mkdir(path, options) {
+        await mkdir(path, options);
+    },
+    async open(path, flags, mode) {
+        const handle = await open(path, flags, mode);
+        return {
+            write: async (data) => handle.write(data),
+            sync: async () => handle.sync(),
+            close: async () => handle.close()
+        };
+    },
+    access,
+    rename,
+    async rm(path, options) {
+        await rm(path, options);
+    }
+};
+function safeDownloadUrl(value) {
+    try {
+        const url = parseSafeRemoteAssetUrl(value);
+        if (url.protocol !== "https:")
+            throw new Error("HTTPS required");
+        return url;
+    }
+    catch {
+        throw new DamDownloadError();
+    }
+}
+function decodedFilename(value) {
+    const encoded = /(?:^|;)\s*filename\*\s*=\s*(?:UTF-8'')?("?)([^;"]*)\1/iu.exec(value);
+    if (encoded?.[2] !== undefined) {
+        try {
+            return decodeURIComponent(encoded[2].trim());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const plain = /(?:^|;)\s*filename\s*=\s*(?:"([^"]*)"|([^;]*))/iu.exec(value);
+    return plain?.[1]?.trim() ?? plain?.[2]?.trim();
+}
+function safeFormat(value) {
+    const format = value?.trim().replace(/^\.+/u, "").replace(/[^a-zA-Z0-9]+/gu, "");
+    return format === undefined || format === "" ? "bin" : format.toLowerCase();
+}
+function truncateFilename(value) {
+    if (value.length <= maximumFilenameLength)
+        return value;
+    const extension = extname(value);
+    const extensionLength = Math.min(extension.length, 20);
+    const safeExtension = extension.slice(0, extensionLength);
+    const stemLength = maximumFilenameLength - safeExtension.length;
+    return `${value.slice(0, Math.max(1, stemLength))}${safeExtension}`;
+}
+function safeFilename(candidate, fallback, format) {
+    const raw = (candidate === undefined || candidate.trim() === "") ? fallback : candidate;
+    const segments = raw.normalize("NFKC").replace(/[\u0000-\u001f\u007f]/gu, "")
+        .split(/[\\/]+/u);
+    let filename = (segments.at(-1) ?? "").trim().replace(/^\.+/u, "");
+    if (filename === "" || filename === "." || filename === "..")
+        filename = "asset";
+    if (extname(filename) === "")
+        filename = `${filename}.${format}`;
+    return truncateFilename(filename);
+}
+function withIndex(filename, index, total) {
+    if (total === 1)
+        return filename;
+    const extension = extname(filename);
+    const stem = extension === "" ? filename : filename.slice(0, -extension.length);
+    return truncateFilename(`${stem}-${index + 1}${extension}`);
+}
+async function fetchDownload(initial, fetch, signal) {
+    let url = safeDownloadUrl(initial);
+    for (let redirects = 0; redirects <= maximumRedirects; redirects += 1) {
+        signal.throwIfAborted();
+        let response;
+        try {
+            response = await fetch(url, { method: "GET", redirect: "manual", signal });
+        }
+        catch {
+            if (signal.aborted)
+                throw signal.reason;
+            throw new DamDownloadError();
+        }
+        signal.throwIfAborted();
+        if (!redirectStatuses.has(response.status)) {
+            if (!response.ok || response.body === null)
+                throw new DamDownloadError();
+            return response;
+        }
+        const location = response.headers.get("location");
+        if (location === null || redirects === maximumRedirects)
+            throw new DamDownloadError();
+        try {
+            url = safeDownloadUrl(new URL(location, url).href);
+        }
+        catch {
+            throw new DamDownloadError();
+        }
+        finally {
+            await response.body?.cancel().catch(() => undefined);
+        }
+    }
+    throw new DamDownloadError();
+}
+async function writeAll(handle, data) {
+    let offset = 0;
+    while (offset < data.byteLength) {
+        const { bytesWritten } = await handle.write(data.subarray(offset));
+        if (!Number.isInteger(bytesWritten) || bytesWritten <= 0)
+            throw new DamDownloadError();
+        offset += bytesWritten;
+    }
+}
+function isMissingFile(error) {
+    return error !== null
+        && typeof error === "object"
+        && "code" in error
+        && error.code === "ENOENT";
+}
+export function createDamFileDownloader(options = {}) {
+    const dependencies = {
+        fetch: options.fetch ?? globalThis.fetch,
+        fileSystem: options.fileSystem ?? nodeFileSystem,
+        randomId: options.randomId ?? randomUUID,
+        cwd: options.cwd ?? process.cwd
+    };
+    return {
+        async download(input) {
+            input.signal.throwIfAborted();
+            if (input.urls.length === 0)
+                throw new DamDownloadError();
+            const outputDirectory = resolve(dependencies.cwd(), input.outputDirectory);
+            const pending = [];
+            const createdFinalPaths = [];
+            try {
+                await dependencies.fileSystem.mkdir(outputDirectory, { recursive: true });
+                for (const [index, rawUrl] of input.urls.entries()) {
+                    input.signal.throwIfAborted();
+                    const response = await fetchDownload(rawUrl, dependencies.fetch, input.signal);
+                    const format = safeFormat(input.fallbackFormat);
+                    const fallback = safeFilename(input.fallbackTitle, "asset", format);
+                    const disposition = response.headers.get("content-disposition");
+                    const filename = withIndex(safeFilename(disposition === null ? undefined : decodedFilename(disposition), fallback, format), index, input.urls.length);
+                    const finalPath = resolve(outputDirectory, filename);
+                    if (!finalPath.startsWith(`${outputDirectory}/`) && finalPath !== outputDirectory) {
+                        throw new DamDownloadError();
+                    }
+                    const temporaryPath = resolve(outputDirectory, `.part-${dependencies.randomId()}-${index + 1}`);
+                    const handle = await dependencies.fileSystem.open(temporaryPath, "wx", 0o600);
+                    const item = {
+                        temporaryPath,
+                        finalPath,
+                        handle,
+                        open: true,
+                        bytes: 0,
+                        sha256: ""
+                    };
+                    pending.push(item);
+                    const hash = createHash("sha256");
+                    const reader = response.body.getReader();
+                    try {
+                        while (true) {
+                            input.signal.throwIfAborted();
+                            const chunk = await reader.read();
+                            if (chunk.done)
+                                break;
+                            await writeAll(handle, chunk.value);
+                            hash.update(chunk.value);
+                            item.bytes += chunk.value.byteLength;
+                        }
+                    }
+                    finally {
+                        reader.releaseLock();
+                    }
+                    item.sha256 = hash.digest("hex");
+                }
+                for (const item of pending) {
+                    try {
+                        await dependencies.fileSystem.access(item.finalPath);
+                        throw new DamDownloadDestinationExistsError();
+                    }
+                    catch (error) {
+                        if (error instanceof DamDownloadDestinationExistsError)
+                            throw error;
+                        if (!isMissingFile(error))
+                            throw new DamDownloadError();
+                    }
+                }
+                for (const item of pending) {
+                    await item.handle.sync();
+                    await item.handle.close();
+                    item.open = false;
+                }
+                for (const item of pending) {
+                    await dependencies.fileSystem.rename(item.temporaryPath, item.finalPath);
+                    createdFinalPaths.push(item.finalPath);
+                }
+                return pending.map((item) => ({
+                    path: item.finalPath,
+                    bytes: item.bytes,
+                    sha256: item.sha256
+                }));
+            }
+            catch (error) {
+                await Promise.all(pending.map(async (item) => {
+                    if (item.open)
+                        await item.handle.close().catch(() => undefined);
+                    await dependencies.fileSystem.rm(item.temporaryPath, { force: true }).catch(() => undefined);
+                }));
+                await Promise.all(createdFinalPaths.map((path) => (dependencies.fileSystem.rm(path, { force: true }).catch(() => undefined))));
+                if (input.signal.aborted)
+                    throw input.signal.reason;
+                if (error instanceof DamDownloadDestinationExistsError
+                    || error instanceof DamDownloadError)
+                    throw error;
+                throw new DamDownloadError();
+            }
+        }
+    };
+}