gaoding-cli 1.0.0-alpha.5

package/dist/src/api/dam-client.js

@@ -0,0 +1,897 @@
+import crypto from "node:crypto";
+import { access, readFile, stat } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+import OSS from "ali-oss";
+import sharp from "sharp";
+import { DirectApiClient, DirectApiError, unwrapEnvelope } from "./direct-client.js";
+import { isDebug, isVerbose } from "../utils/config.js";
+import { assertSafeUploadPath } from "../utils/sensitive-path.js";
+import { assertSafeHttpUrl } from "../utils/url-safety.js";
+import { redactSensitiveText } from "../utils/redact.js";
+const ANALYSIS_STATUS = {
+    NOT_START: 0,
+    PROCESSING: 1,
+    SUCCESS: 2,
+    FAILED: 3,
+    NOT_SUPPORT: 4,
+};
+const DEFAULT_ANALYSIS_TIMEOUT_MS = 180_000;
+const DEFAULT_ANALYSIS_INTERVAL_MS = 3_000;
+export class DamClient {
+    client;
+    constructor(client = new DirectApiClient()) {
+        this.client = client;
+    }
+    async createAssetId() {
+        const response = await this.client.post("/tb-dam/asset/id");
+        const data = unwrapEnvelope(response);
+        if (!data.id) {
+            throw new Error("创建 DAM content_id 失败：接口没有返回 id");
+        }
+        return data.id;
+    }
+    async uploadLocalAsset(file, options = {}) {
+        const filePath = assertSafeUploadPath(resolve(process.cwd(), file), {
+            allowSensitivePath: options.allowSensitivePath,
+            context: "上传文件",
+        });
+        await access(filePath);
+        const fileBuffer = await readFile(filePath);
+        const format = inferFormat(filePath, fileBuffer);
+        const mimeType = inferMimeType(format);
+        const fileStat = await stat(filePath);
+        const contentId = options.register ? await this.createAssetId() : undefined;
+        const token = await this.createUploadToken(format, contentId);
+        await putObjectWithFallback(token, filePath, mimeType);
+        const rawUrl = `${normalizeHost(token.host)}/${token.object_name}`;
+        const storageId = contentId ?? token.object_name;
+        const uploaded = {
+            id: storageId,
+            storage_id: storageId,
+            file_path: filePath,
+            filename: basename(filePath),
+            format,
+            mime_type: mimeType,
+            object_name: token.object_name,
+            auth_key: token.auth_key,
+            url: appendAuthKey(rawUrl, token.auth_key),
+            source: "cli",
+        };
+        if (!options.register)
+            return uploaded;
+        if (!contentId) {
+            throw new Error("DAM 入库失败：缺少 content_id");
+        }
+        const repositoryId = options.repositoryId ?? (await this.resolveDefaultRepositoryId());
+        if (!repositoryId) {
+            throw new Error(`DAM 入库失败：缺少 repository_id。对象已上传到存储，storage_id=${contentId}, object_name=${token.object_name}`);
+        }
+        const preview = await readPreviewInfo(filePath, mimeType, uploaded.url, format);
+        const registration = await this.registerAsset({
+            contentId,
+            repositoryId,
+            folderId: options.folderId ?? "0",
+            filePath,
+            filename: basename(filePath),
+            title: options.title,
+            mimeType,
+            format,
+            url: uploaded.url,
+            size: fileStat.size,
+            md5: hash("md5", fileBuffer),
+            sha1: hash("sha1", fileBuffer),
+            tagIds: options.tagIds,
+            preview,
+        });
+        const registeredAssetId = extractRegisteredAssetId(registration) ?? contentId;
+        const analysis = options.waitAnalysis
+            ? await this.waitForAssetAnalysis(registeredAssetId, normalizePositiveInteger(options.analysisTimeoutMs, DEFAULT_ANALYSIS_TIMEOUT_MS), normalizePositiveInteger(options.analysisIntervalMs, DEFAULT_ANALYSIS_INTERVAL_MS))
+            : undefined;
+        const assetInfo = analysis?.assetInfo ?? extractAssetInfo(registration);
+        const cover = coverFromAssetInfo(assetInfo, preview);
+        return {
+            ...uploaded,
+            id: registeredAssetId,
+            registered_asset_id: registeredAssetId,
+            registered: true,
+            registration,
+            cover_url: cover?.url,
+            cover,
+            asset_info: assetInfo,
+            analysis_status: extractAnalysisStatus(assetInfo),
+            analysis_fail_msg: extractString(assetInfo, ["analysis_fail_msg", "analysis_error", "message"]),
+            analysis_timed_out: analysis?.timedOut,
+        };
+    }
+    async getAsset(idOrUrl) {
+        if (/^https?:\/\//.test(idOrUrl)) {
+            const safeUrl = assertSafeHttpUrl(idOrUrl, { context: "DAM URL" });
+            return {
+                status: "unsupported_api",
+                message: "DAM 按 URL 查询接口尚未确认，暂不把 URL 查询视为已实现能力",
+                query: safeUrl,
+                expected_contract: "GET /tb-dam/dam/asset/by-url?url=... 或 POST /tb-dam/asset/search 支持 origin_url 精确查询",
+            };
+        }
+        return this.client.get(`/dam/asset/${encodeURIComponent(idOrUrl)}`);
+    }
+    async deleteAsset(assetId, options = {}) {
+        const repositoryId = options.repositoryId ?? (await this.resolveDefaultRepositoryId());
+        if (!repositoryId) {
+            throw new Error("DAM 删除失败：缺少 repository_id，请传 --repository-id 或配置 GD_DAM_REPOSITORY_ID");
+        }
+        const body = {
+            repository_id: repositoryId,
+            file_ids: [assetId],
+            folder_ids: [],
+        };
+        const recycle = await this.client.post("/dam/recycle-bin", body);
+        if (!options.permanent)
+            return recycle;
+        return this.client.post("/dam/recycle-bin/delete", body);
+    }
+    async searchAssets(keyword, options = {}) {
+        const query = keyword.trim();
+        if (!query && !options.allowEmptyKeyword && !options.folderId) {
+            throw new Error("DAM 搜索关键词不能为空；如需查看最近素材请使用 gd-cli dam list");
+        }
+        const repositoryIds = await this.resolveSearchRepositoryIds(options);
+        const payload = buildSearchPayload(query, repositoryIds, options);
+        try {
+            const response = await this.client.post("/dam/asset/v2/search/simple", payload);
+            return normalizeSearchResponse(response, {
+                endpoint: "/dam/asset/v2/search/simple",
+                query,
+                repositoryIds,
+                payload,
+                includeDebug: options.raw === true || isVerbose() || isDebug(),
+                includeRaw: options.raw === true,
+            });
+        }
+        catch (error) {
+            if (!shouldFallbackDamSearch(error))
+                throw error;
+            const response = await this.client.post("/dam/asset/search", payload);
+            return normalizeSearchResponse(response, {
+                endpoint: "/dam/asset/search",
+                query,
+                repositoryIds,
+                payload,
+                includeDebug: options.raw === true || isVerbose() || isDebug(),
+                includeRaw: options.raw === true,
+            });
+        }
+    }
+    async resolveDefaultRepositoryId() {
+        const explicit = process.env.GD_DAM_REPOSITORY_ID?.trim();
+        if (explicit)
+            return explicit;
+        const repositories = await this.listRepositories();
+        return repositories.find((repo) => repo.type === 1 && repo.repository_id)?.repository_id ?? repositories.find((repo) => repo.repository_id)?.repository_id;
+    }
+    async resolveSearchRepositoryIds(options) {
+        if (options.repositoryId)
+            return [options.repositoryId];
+        if (options.allRepositories) {
+            const ids = (await this.listRepositories())
+                .map((repo) => repo.repository_id)
+                .filter((id) => Boolean(id));
+            if (ids.length === 0) {
+                throw new Error("DAM 搜索失败：当前组织没有可访问的资源库");
+            }
+            return ids;
+        }
+        const repositoryId = await this.resolveDefaultRepositoryId();
+        if (!repositoryId) {
+            throw new Error("DAM 搜索失败：缺少 repository_id，请传 --repository-id 或配置 GD_DAM_REPOSITORY_ID");
+        }
+        return [repositoryId];
+    }
+    async listRepositories() {
+        const response = await this.client.get("/tb-dam/repositories");
+        const repositories = unwrapEnvelope(response);
+        return Array.isArray(repositories) ? repositories : [];
+    }
+    async registerAsset(input) {
+        const payload = {
+            folder_id: input.folderId,
+            repository_id: input.repositoryId,
+            second_transmission: false,
+            storage_format: toDamStorageFormat(input.format),
+            category_ids: [],
+            asset_info: {
+                id: input.contentId,
+                origin_url: input.url,
+                size: input.size,
+                title: input.title ?? stripExtension(input.filename),
+                md5: input.md5,
+                sha1: input.sha1,
+                mime_type: input.mimeType,
+                format: input.format,
+                preview: input.preview ?? {},
+            },
+            ...(input.tagIds?.length ? { tag_ids: input.tagIds } : {}),
+        };
+        try {
+            return await this.client.post("/dam/asset/createMaterial", payload);
+        }
+        catch (error) {
+            const existing = await this.findExistingAsset(input.repositoryId, stripExtension(input.filename));
+            if (existing)
+                return existing;
+            throw new Error(`DAM 入库失败。对象已上传到存储，storage_id=${input.contentId}。` +
+                ` /dam/asset/createMaterial: ${errorMessage(error)}`);
+        }
+    }
+    async waitForAssetAnalysis(assetId, timeoutMs, intervalMs) {
+        const deadline = Date.now() + timeoutMs;
+        let lastAssetInfo;
+        while (Date.now() <= deadline) {
+            const assetInfo = await this.fetchAnalysisAsset(assetId);
+            if (assetInfo) {
+                lastAssetInfo = assetInfo;
+                const status = extractAnalysisStatus(assetInfo);
+                if (isTerminalAnalysisStatus(status)) {
+                    return { assetInfo };
+                }
+            }
+            await sleep(Math.min(intervalMs, Math.max(0, deadline - Date.now())));
+        }
+        return { assetInfo: lastAssetInfo, timedOut: true };
+    }
+    async fetchAnalysisAsset(assetId) {
+        const response = await this.client.get("/dam/asset/batch-status", {
+            query: { ids: assetId },
+        });
+        return firstRecordFromResponse(response);
+    }
+    async findExistingAsset(repositoryId, title) {
+        const response = await this.client.post("/dam/asset/v2/search/simple", {
+            repository_ids: [repositoryId],
+            keyword: title,
+            page: 1,
+            page_size: 10,
+        });
+        const raw = response;
+        const result = (Array.isArray(raw) ? raw : raw.data ? raw : raw.data);
+        const items = Array.isArray(result) ? result : result?.data;
+        return items?.find((item) => item.title === title) ?? items?.[0];
+    }
+    async createUploadToken(format, contentId) {
+        const response = await this.client.post("/tb-dam/asset/upload/tokens", contentId ? { content_id: contentId, format } : { format });
+        return unwrapEnvelope(response);
+    }
+}
+function buildSearchPayload(keyword, repositoryIds, options) {
+    const pageSize = clampPositiveInteger(options.pageSize, 20, 100);
+    const page = clampPositiveInteger(options.page, 1, Number.MAX_SAFE_INTEGER);
+    const payload = {
+        keyword,
+        repository_ids: repositoryIds,
+        folder_ids: options.folderId ? [options.folderId] : [],
+        include_child_folder: options.includeChildFolder !== false,
+        recycle: false,
+        page_size: pageSize,
+        page_num: page,
+        page,
+        sort: ["-top_time", "-updated_at"],
+    };
+    if (options.cursor) {
+        payload.query_id = options.cursor;
+        payload.cursor = options.cursor;
+    }
+    const contentFormats = contentFormatsForType(options.type);
+    if (contentFormats.length)
+        payload.content_format_list = contentFormats;
+    if (options.format?.length)
+        payload.format_list = options.format;
+    if (options.tagIds?.length)
+        payload.tag_ids = options.tagIds;
+    return payload;
+}
+function normalizeSearchResponse(response, context) {
+    const container = extractSearchContainer(response);
+    const rawItems = container.items;
+    const page = numberFromUnknown(context.payload.page_num) ?? 1;
+    const pageSize = numberFromUnknown(context.payload.page_size) ?? 20;
+    const total = container.total ?? rawItems.length;
+    const finish = container.finish ?? page * pageSize >= total;
+    const nextCursor = container.queryId && !finish ? container.queryId : undefined;
+    return {
+        status: "completed",
+        query: context.query,
+        repository_ids: context.repositoryIds,
+        page,
+        page_size: pageSize,
+        total,
+        finish,
+        next_cursor: nextCursor,
+        assets: rawItems.map(normalizeSearchAsset).filter((item) => item.asset_id),
+        ...(context.includeDebug
+            ? {
+                debug: {
+                    source: {
+                        endpoint: context.endpoint,
+                        ...(context.includeRaw ? { raw: response } : {}),
+                    },
+                },
+            }
+            : {}),
+    };
+}
+function extractSearchContainer(value) {
+    const candidates = nestedCandidates(value);
+    for (const candidate of candidates) {
+        if (Array.isArray(candidate)) {
+            return { items: candidate.filter(isRecord) };
+        }
+        if (!isRecord(candidate))
+            continue;
+        const items = arrayField(candidate, "data") ?? arrayField(candidate, "list") ?? arrayField(candidate, "items");
+        if (items) {
+            return {
+                items: items.filter(isRecord),
+                total: numberFromUnknown(candidate.total) ?? numberFromUnknown(candidate.count),
+                finish: booleanFromUnknown(candidate.finish),
+                queryId: stringFromUnknown(candidate.query_id) ?? stringFromUnknown(candidate.cursor),
+            };
+        }
+    }
+    return { items: [] };
+}
+function nestedCandidates(value) {
+    const out = [value];
+    let current = value;
+    for (let i = 0; i < 3; i += 1) {
+        if (!isRecord(current) || current.data === undefined)
+            break;
+        current = current.data;
+        out.push(current);
+    }
+    return out;
+}
+function normalizeSearchAsset(item) {
+    const originInfo = recordField(item, "origin_info") ?? recordField(item, "originInfo");
+    const preview = recordField(item, "preview") ?? recordField(item, "preview_info") ?? recordField(item, "previewInfo");
+    const folderInfo = recordField(item, "folder_info") ?? recordField(item, "folderInfo");
+    const format = stringFromUnknown(originInfo?.format) ??
+        stringFromUnknown(item.format) ??
+        stringFromUnknown(item.storage_format);
+    const url = stringFromUnknown(originInfo?.url) ??
+        stringFromUnknown(item.origin_url) ??
+        stringFromUnknown(item.url);
+    const coverUrl = stringFromUnknown(preview?.url) ??
+        stringFromUnknown(item.cover_url) ??
+        stringFromUnknown(item.preview_url);
+    const assetId = stringFromUnknown(item.asset_id) ??
+        stringFromUnknown(item.id) ??
+        stringFromUnknown(item.content_id) ??
+        "";
+    return removeUndefined({
+        asset_id: assetId,
+        title: stringFromUnknown(item.title) ?? stringFromUnknown(item.name),
+        format,
+        type: inferAssetType(item, format),
+        size: numberFromUnknown(originInfo?.size) ?? numberFromUnknown(item.size),
+        url,
+        cover_url: coverUrl,
+        width: numberFromUnknown(preview?.width),
+        height: numberFromUnknown(preview?.height),
+        repository_id: stringFromUnknown(item.repository_id),
+        folder_id: stringFromUnknown(item.folder_id) ?? stringFromUnknown(folderInfo?.id),
+        folder_name: stringFromUnknown(folderInfo?.title) ?? stringFromUnknown(folderInfo?.name),
+        tags: stringArrayFromTags(item.tags),
+        tag_ids: idArrayFromTags(item.tags) ?? idArrayFromUnknown(item.tag_ids),
+        analysis_status: numberFromUnknown(item.analysis_result) ??
+            numberFromUnknown(item.analysis_status) ??
+            stringFromUnknown(item.analysis_result) ??
+            stringFromUnknown(item.analysis_status),
+        created_at: dateStringFromUnknown(item.created_at ?? item.create_time ?? item.created_time),
+        updated_at: dateStringFromUnknown(item.updated_at ?? item.update_time ?? item.updated_time),
+    });
+}
+function shouldFallbackDamSearch(error) {
+    if (error instanceof DirectApiError) {
+        return [404, 405, 501].includes(error.statusCode);
+    }
+    return /not found|unsupported|method not allowed/i.test(errorMessage(error));
+}
+function contentFormatsForType(type) {
+    const normalized = type?.trim().toLowerCase();
+    if (!normalized)
+        return [];
+    const map = {
+        image: ["gdpic", "gdimage"],
+        video: ["gdvideo"],
+        audio: ["gdaudio"],
+        font: ["gdfont"],
+        template: ["gdtemplate"],
+        file: ["gdfile", "gdimage", "gdslide"],
+    };
+    return map[normalized] ?? [normalized];
+}
+function inferAssetType(item, format) {
+    const contentFormat = stringFromUnknown(item.content_format) ??
+        stringFromUnknown(item.storage_format) ??
+        stringFromUnknown(item.type);
+    const normalized = contentFormat?.toLowerCase();
+    if (normalized?.includes("video"))
+        return "video";
+    if (normalized?.includes("audio"))
+        return "audio";
+    if (normalized?.includes("font"))
+        return "font";
+    if (normalized?.includes("template"))
+        return "template";
+    if (normalized?.includes("pic") || normalized?.includes("image"))
+        return "image";
+    const ext = format?.toLowerCase();
+    if (!ext)
+        return undefined;
+    if (["png", "jpg", "jpeg", "gif", "webp", "svg", "heic", "avif", "bmp"].includes(ext))
+        return "image";
+    if (["mp4", "mov", "webm", "avi", "mkv"].includes(ext))
+        return "video";
+    if (["mp3", "wav", "ogg", "flac"].includes(ext))
+        return "audio";
+    if (["ttf", "otf"].includes(ext))
+        return "font";
+    return "file";
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function recordField(record, key) {
+    const value = record[key];
+    return isRecord(value) ? value : undefined;
+}
+function arrayField(record, key) {
+    const value = record[key];
+    return Array.isArray(value) ? value : undefined;
+}
+function stringFromUnknown(value) {
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    return undefined;
+}
+function numberFromUnknown(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function booleanFromUnknown(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    return undefined;
+}
+function stringArrayFromTags(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = value
+        .map((item) => isRecord(item)
+        ? stringFromUnknown(item.title) ?? stringFromUnknown(item.name)
+        : stringFromUnknown(item))
+        .filter((item) => Boolean(item));
+    return out.length ? out : undefined;
+}
+function idArrayFromTags(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = value
+        .map((item) => (isRecord(item) ? item.id ?? item.tag_id : undefined))
+        .filter((item) => typeof item === "string" || typeof item === "number");
+    return out.length ? out : undefined;
+}
+function idArrayFromUnknown(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = value.filter((item) => typeof item === "string" || typeof item === "number");
+    return out.length ? out : undefined;
+}
+function dateStringFromUnknown(value) {
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    const millis = value < 10_000_000_000 ? value * 1000 : value;
+    const date = new Date(millis);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function removeUndefined(record) {
+    return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+function clampPositiveInteger(value, fallback, max) {
+    if (!Number.isInteger(value) || value === undefined || value <= 0)
+        return fallback;
+    return Math.min(value, max);
+}
+async function putObjectWithFallback(token, filePath, mimeType) {
+    let lastError;
+    for (const endpoint of resolveUploadEndpoints(token)) {
+        for (const authorizationV4 of [false, true]) {
+            try {
+                await putObjectWithRetry(token, endpoint, filePath, mimeType, authorizationV4);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                if (!shouldTryNextOssAuthOrEndpoint(error))
+                    throw error;
+            }
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+async function putObject(token, endpoint, filePath, mimeType, authorizationV4) {
+    if (isHuaweiObsEndpoint(endpoint)) {
+        await putObsObject(token, endpoint, filePath, mimeType);
+        return;
+    }
+    const oss = new OSS({
+        region: token.region,
+        bucket: token.bucket_name,
+        accessKeyId: token.access_key_id,
+        accessKeySecret: token.access_key_secret,
+        stsToken: token.security_token,
+        endpoint,
+        secure: true,
+        authorizationV4,
+        refreshSTSToken: async () => ({
+            accessKeyId: token.access_key_id,
+            accessKeySecret: token.access_key_secret,
+            stsToken: token.security_token,
+        }),
+        refreshSTSTokenInterval: 60 * 60 * 1000,
+    });
+    await oss.put(token.object_name, filePath, {
+        headers: {
+            "Content-Type": mimeType,
+        },
+    });
+}
+async function putObsObject(token, endpoint, filePath, mimeType) {
+    const endpointUrl = new URL(endpoint);
+    const objectPath = encodeObjectPath(token.object_name);
+    const resource = `/${token.bucket_name}/${token.object_name}`;
+    const uploadUrl = `${endpointUrl.protocol}//${token.bucket_name}.${endpointUrl.host}/${objectPath}`;
+    const date = new Date().toUTCString();
+    const canonicalObsHeaders = `x-obs-security-token:${token.security_token}\n`;
+    const stringToSign = [
+        "PUT",
+        "",
+        mimeType,
+        date,
+        `${canonicalObsHeaders}${resource}`,
+    ].join("\n");
+    const signature = crypto
+        .createHmac("sha1", token.access_key_secret)
+        .update(stringToSign)
+        .digest("base64");
+    const body = await readFile(filePath);
+    const response = await fetch(uploadUrl, {
+        method: "PUT",
+        headers: {
+            Authorization: `OBS ${token.access_key_id}:${signature}`,
+            Date: date,
+            "Content-Type": mimeType,
+            "Content-Length": String(body.byteLength),
+            "x-obs-security-token": token.security_token,
+        },
+        body,
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new Error(redactSensitiveText(`OBS 上传失败 [${response.status}] ${uploadUrl}: ${text || response.statusText}`));
+    }
+}
+async function putObjectWithRetry(token, endpoint, filePath, mimeType, authorizationV4) {
+    const maxAttempts = 2;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        try {
+            await putObject(token, endpoint, filePath, mimeType, authorizationV4);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            if (!isTransientOssUploadError(error) || attempt === maxAttempts - 1) {
+                throw error;
+            }
+            await sleep(300 * (attempt + 1));
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function resolveUploadEndpoints(token) {
+    // Some DAM tokens include CDN/static domains in accelerate_endpoint. Those
+    // domains can serve reads but may reject PUT, so prefer the canonical OSS
+    // endpoint and keep the others as fallbacks.
+    return uniqueStrings([
+        token.endpoint,
+        token.standby_endpoint,
+        token.accelerate_endpoint,
+    ]).map(normalizeEndpoint);
+}
+function isHuaweiObsEndpoint(endpoint) {
+    return /(^|\.)obs\.[^.]+\.myhuaweicloud\.com/i.test(new URL(endpoint).host);
+}
+function encodeObjectPath(objectName) {
+    return objectName.split("/").map(encodeURIComponent).join("/");
+}
+function shouldTryNextOssAuthOrEndpoint(error) {
+    return isUnsupportedAuthorizationType(error) || isTransientOssUploadError(error);
+}
+function isUnsupportedAuthorizationType(error) {
+    return /Unsupported Authorization Type/i.test(errorMessage(error));
+}
+function isTransientOssUploadError(error) {
+    const message = errorMessage(error);
+    return (/socket hang up/i.test(message) ||
+        /ECONNRESET/i.test(message) ||
+        /ETIMEDOUT/i.test(message) ||
+        /EPIPE/i.test(message));
+}
+function errorMessage(error) {
+    if (!error || typeof error !== "object")
+        return String(error);
+    return ("message" in error && typeof error.message === "string"
+        ? error.message
+        : String(error));
+}
+function hash(algorithm, body) {
+    return crypto.createHash(algorithm).update(body).digest("hex");
+}
+function stripExtension(filename) {
+    return filename.replace(/\.[^.]+$/, "");
+}
+function extractRegisteredAssetId(value) {
+    const data = unwrapEnvelope(value);
+    if (!data || typeof data !== "object")
+        return undefined;
+    const record = data;
+    const candidates = [
+        record.id,
+        record.asset_id,
+        record.content_id,
+        record.asset?.id,
+        record.asset?.asset_id,
+    ];
+    const found = candidates.find((item) => typeof item === "string" || typeof item === "number");
+    return found === undefined ? undefined : String(found);
+}
+export function toDamStorageFormat(format) {
+    const normalized = format.toLowerCase();
+    if ([
+        "png",
+        "jpg",
+        "jpeg",
+        "gif",
+        "svg",
+        "webp",
+        "jfif",
+        "bmp",
+        "tiff",
+        "tif",
+        "heic",
+        "avif",
+    ].includes(normalized)) {
+        return "gdpic";
+    }
+    if ([
+        "mp4",
+        "avi",
+        "flv",
+        "mov",
+        "3gp",
+        "m3u8",
+        "mpg",
+        "asf",
+        "wmv",
+        "mkv",
+        "ts",
+        "webm",
+        "mxf",
+    ].includes(normalized)) {
+        return "gdvideo";
+    }
+    if (["mp3", "wav", "ogg", "flac"].includes(normalized))
+        return "gdaudio";
+    if (["ttf", "otf"].includes(normalized))
+        return "gdfont";
+    if (["psd", "ai", "sketch", "pdf"].includes(normalized))
+        return "gdimage";
+    if (["ppt", "pptx"].includes(normalized))
+        return "gdslide";
+    return normalized;
+}
+async function readPreviewInfo(filePath, mimeType, url, format) {
+    if (!mimeType.startsWith("image/"))
+        return {};
+    try {
+        const metadata = await sharp(filePath).metadata();
+        return Object.fromEntries(Object.entries({
+            url,
+            width: metadata.width,
+            height: metadata.height,
+            format,
+        }).filter(([, value]) => value !== undefined));
+    }
+    catch {
+        return { url, format };
+    }
+}
+function firstRecordFromResponse(value) {
+    const data = unwrapEnvelope(value);
+    if (Array.isArray(data))
+        return firstRecord(data);
+    if (!data || typeof data !== "object")
+        return undefined;
+    const record = data;
+    if (Array.isArray(record.data))
+        return firstRecord(record.data);
+    return firstRecord([record]);
+}
+function firstRecord(values) {
+    const found = values.find((item) => item && typeof item === "object");
+    return found;
+}
+function extractAssetInfo(value) {
+    const data = unwrapEnvelope(value);
+    if (!data || typeof data !== "object")
+        return undefined;
+    const record = data;
+    const candidates = [
+        record.asset_info,
+        record.asset,
+        record,
+    ];
+    return candidates.find((item) => Boolean(item && typeof item === "object"));
+}
+function coverFromAssetInfo(assetInfo, fallbackPreview) {
+    const previewInfo = getRecord(assetInfo, "preview_info") ?? getRecord(assetInfo, "preview");
+    const sourcePreviewInfo = getRecord(assetInfo, "source_preview_info");
+    const fallback = fallbackPreview && Object.keys(fallbackPreview).length ? fallbackPreview : undefined;
+    const coverSource = previewInfo ?? sourcePreviewInfo ?? fallback;
+    if (!coverSource)
+        return undefined;
+    const url = extractString(coverSource, ["url", "origin_url"]);
+    const width = extractNumber(coverSource, "width");
+    const height = extractNumber(coverSource, "height");
+    const duration = extractNumber(coverSource, "duration");
+    if (!url && width === undefined && height === undefined && duration === undefined)
+        return undefined;
+    return Object.fromEntries(Object.entries({ url, width, height, duration }).filter(([, value]) => value !== undefined));
+}
+function getRecord(record, key) {
+    const value = record?.[key];
+    return value && typeof value === "object" ? value : undefined;
+}
+function extractAnalysisStatus(record) {
+    const value = record?.analysis_status;
+    if (typeof value === "number" || typeof value === "string")
+        return value;
+    return undefined;
+}
+function isTerminalAnalysisStatus(status) {
+    const normalized = typeof status === "string" ? Number(status) : status;
+    return (normalized === ANALYSIS_STATUS.SUCCESS ||
+        normalized === ANALYSIS_STATUS.FAILED ||
+        normalized === ANALYSIS_STATUS.NOT_SUPPORT);
+}
+function extractString(record, keys) {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === "string" && value.trim())
+            return value;
+    }
+    return undefined;
+}
+function extractNumber(record, key) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function normalizePositiveInteger(value, fallback) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0)
+        return value;
+    return fallback;
+}
+function uniqueStrings(values) {
+    const set = new Set();
+    for (const value of values) {
+        if (value?.trim())
+            set.add(value.trim());
+    }
+    return [...set];
+}
+function sleep(ms) {
+    return new Promise((resolve) => globalThis.setTimeout(resolve, ms));
+}
+function normalizeEndpoint(endpoint) {
+    if (!endpoint)
+        throw new Error("上传凭证缺少 endpoint");
+    return endpoint.startsWith("http") ? endpoint : `https://${endpoint}`;
+}
+function normalizeHost(host) {
+    const normalized = host.startsWith("http") ? host : `https://${host}`;
+    return normalized.replace(/\/$/, "");
+}
+function appendAuthKey(url, authKey) {
+    if (!authKey)
+        return url;
+    const parsed = new URL(url);
+    if (!parsed.searchParams.has("auth_key")) {
+        parsed.searchParams.set("auth_key", authKey);
+    }
+    return parsed.toString();
+}
+function inferFormat(filePath, buffer) {
+    const detected = buffer ? inferFormatFromBuffer(buffer) : undefined;
+    if (detected)
+        return detected;
+    const format = extname(filePath).replace(/^\./, "").toLowerCase();
+    if (!format)
+        throw new Error(`无法从文件名推断格式：${filePath}`);
+    return format === "jpg" ? "jpeg" : format;
+}
+function inferFormatFromBuffer(buffer) {
+    if (buffer.length >= 4 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return "jpeg";
+    }
+    if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+        return "png";
+    }
+    if (buffer.length >= 6 && buffer.subarray(0, 3).toString("ascii") === "GIF") {
+        return "gif";
+    }
+    if (buffer.length >= 12 &&
+        buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
+        buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+        return "webp";
+    }
+    if (buffer.length >= 12 && buffer.subarray(4, 8).toString("ascii") === "ftyp") {
+        const brand = buffer.subarray(8, 12).toString("ascii");
+        if (brand === "avif" || brand === "avis")
+            return "avif";
+        if (brand === "heic" || brand === "heix" || brand === "hevc" || brand === "hevx")
+            return "heic";
+    }
+    return undefined;
+}
+function inferMimeType(format) {
+    const map = {
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        webp: "image/webp",
+        avif: "image/avif",
+        svg: "image/svg+xml",
+        heic: "image/heic",
+        heif: "image/heif",
+        bmp: "image/bmp",
+        mp4: "video/mp4",
+        webm: "video/webm",
+        mov: "video/quicktime",
+        m4v: "video/x-m4v",
+        avi: "video/x-msvideo",
+        mkv: "video/x-matroska",
+    };
+    return map[format] ?? `application/${format}`;
+}