gaoding-cli 1.0.0-alpha.10

package/dist/src/features/dam/registered-uploader.js

@@ -0,0 +1,224 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
+import sharp from "sharp";
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { projectDamAssetDetail } from "./asset-projection.js";
+const imageFormats = new Set([
+    "png", "jpg", "jpeg", "gif", "svg", "webp", "jfif", "bmp", "tiff", "tif", "heic", "avif"
+]);
+const videoFormats = new Set([
+    "mp4", "avi", "flv", "mov", "3gp", "m3u8", "mpg", "asf", "wmv", "mkv", "ts", "webm", "mxf"
+]);
+const audioFormats = new Set(["mp3", "wav", "ogg", "flac"]);
+const fontFormats = new Set(["ttf", "otf"]);
+const designFormats = new Set(["psd", "ai", "sketch", "pdf"]);
+const slideFormats = new Set(["ppt", "pptx"]);
+function storageFormat(format) {
+    const normalized = format.toLowerCase();
+    if (imageFormats.has(normalized))
+        return "gdpic";
+    if (videoFormats.has(normalized))
+        return "gdvideo";
+    if (audioFormats.has(normalized))
+        return "gdaudio";
+    if (fontFormats.has(normalized))
+        return "gdfont";
+    if (designFormats.has(normalized))
+        return "gdimage";
+    if (slideFormats.has(normalized))
+        return "gdslide";
+    return normalized;
+}
+function publicType(format) {
+    if (format === "gdpic" || format === "gdimage")
+        return "image";
+    if (format === "gdvideo")
+        return "video";
+    if (format === "gdaudio")
+        return "audio";
+    if (format === "gdfont")
+        return "font";
+    if (format === "gdtemplate")
+        return "template";
+    return "file";
+}
+async function hashes(filePath, signal) {
+    signal.throwIfAborted();
+    const md5 = createHash("md5");
+    const sha1 = createHash("sha1");
+    const stream = createReadStream(filePath, { signal });
+    try {
+        for await (const chunk of stream) {
+            signal.throwIfAborted();
+            md5.update(chunk);
+            sha1.update(chunk);
+        }
+        signal.throwIfAborted();
+        return { md5: md5.digest("hex"), sha1: sha1.digest("hex") };
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw signal.reason;
+        throw error;
+    }
+}
+function filenameTitle(filename) {
+    const withoutExtension = filename.replace(/\.[^.]+$/u, "");
+    return withoutExtension === "" ? filename : withoutExtension;
+}
+function terminalAnalysisStatus(value) {
+    const normalized = typeof value === "string" ? Number(value) : value;
+    return normalized === 2 || normalized === 3 || normalized === 4;
+}
+async function defaultSleep(milliseconds, signal) {
+    signal.throwIfAborted();
+    try {
+        await delay(milliseconds, undefined, { signal });
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw signal.reason;
+        throw error;
+    }
+}
+export function createDamRegisteredUploader(dependencies) {
+    const now = dependencies.now ?? (() => new Date());
+    const sleep = dependencies.sleep ?? defaultSleep;
+    const imageMetadata = dependencies.imageMetadata
+        ?? (async (filePath) => {
+            const metadata = await sharp(filePath).metadata();
+            return { width: metadata.width, height: metadata.height };
+        });
+    async function localMetadata(file, signal) {
+        if (!file.mediaType.startsWith("image/"))
+            return {};
+        try {
+            const metadata = await imageMetadata(file.filePath);
+            signal.throwIfAborted();
+            return {
+                ...(typeof metadata.width === "number" && Number.isFinite(metadata.width)
+                    ? { width: metadata.width }
+                    : {}),
+                ...(typeof metadata.height === "number" && Number.isFinite(metadata.height)
+                    ? { height: metadata.height }
+                    : {})
+            };
+        }
+        catch {
+            if (signal.aborted)
+                throw signal.reason;
+            return {};
+        }
+    }
+    return {
+        async upload(input) {
+            try {
+                input.signal.throwIfAborted();
+                const [digest, metadata] = await Promise.all([
+                    hashes(input.file.filePath, input.signal),
+                    localMetadata(input.file, input.signal)
+                ]);
+                input.signal.throwIfAborted();
+                const contentId = await dependencies.api.createAssetId({
+                    access: input.access,
+                    signal: input.signal
+                });
+                const stored = await dependencies.storage.upload({
+                    file: input.file,
+                    contentId
+                }, input.access, input.signal);
+                const format = input.file.format.toLowerCase();
+                const damFormat = storageFormat(format);
+                const title = input.input.title ?? filenameTitle(input.file.filename);
+                const folderId = input.input.folderId ?? "0";
+                const preview = input.file.mediaType.startsWith("image/")
+                    ? {
+                        url: stored.url,
+                        ...metadata,
+                        format
+                    }
+                    : {};
+                const body = {
+                    folder_id: folderId,
+                    repository_id: input.repository.id,
+                    second_transmission: false,
+                    storage_format: damFormat,
+                    category_ids: [],
+                    asset_info: {
+                        id: contentId,
+                        origin_url: stored.url,
+                        size: input.file.size,
+                        title,
+                        md5: digest.md5,
+                        sha1: digest.sha1,
+                        mime_type: input.file.mediaType,
+                        format,
+                        preview
+                    },
+                    ...(input.input.tagIds === undefined
+                        ? {}
+                        : { tag_ids: [...input.input.tagIds] })
+                };
+                const fallback = projectDamAssetDetail({
+                    id: contentId,
+                    title,
+                    format,
+                    type: publicType(damFormat),
+                    origin_info: {
+                        url: stored.url,
+                        size: input.file.size,
+                        format
+                    },
+                    preview_info: preview,
+                    repository_info: {
+                        id: input.repository.id,
+                        ...(input.repository.name === undefined ? {} : { name: input.repository.name })
+                    },
+                    folder_info: { id: folderId },
+                    ...(input.input.tagIds === undefined
+                        ? {}
+                        : { tag_ids: [...input.input.tagIds] })
+                });
+                if (fallback === undefined)
+                    throw new RemoteRequestError();
+                let latest = await dependencies.api.createMaterial({
+                    body,
+                    fallback,
+                    access: input.access,
+                    signal: input.signal
+                });
+                if (input.input.waitAnalysis !== true || terminalAnalysisStatus(latest.analysis_status)) {
+                    return latest;
+                }
+                const deadline = now().getTime() + 180_000;
+                while (true) {
+                    input.signal.throwIfAborted();
+                    const current = await dependencies.api.getBatchStatus({
+                        assetId: latest.asset_id,
+                        fallback: latest,
+                        access: input.access,
+                        signal: input.signal
+                    });
+                    if (current !== null)
+                        latest = current;
+                    if (terminalAnalysisStatus(latest.analysis_status))
+                        return latest;
+                    const remaining = deadline - now().getTime();
+                    if (remaining <= 0) {
+                        dependencies.warn("素材分析仍在处理中，已返回当前结果。");
+                        return latest;
+                    }
+                    await sleep(Math.min(3000, remaining), input.signal);
+                }
+            }
+            catch (error) {
+                if (input.signal.aborted)
+                    throw input.signal.reason;
+                if (error instanceof RemoteRequestError)
+                    throw error;
+                throw new RemoteRequestError();
+            }
+        }
+    };
+}

package/dist/src/features/dam/storage-upload.js

@@ -0,0 +1,141 @@
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+import { inspectUploadFile } from "../../platform/safe-upload-file.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requiredString(record, key) {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim() === "")
+        throw new RemoteRequestError();
+    return value;
+}
+function optionalString(record, key) {
+    const value = record[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim() === "")
+        throw new RemoteRequestError();
+    return value;
+}
+function parseToken(response) {
+    if (!isRecord(response))
+        throw new RemoteRequestError();
+    const record = "data" in response ? response.data : response;
+    if (!isRecord(record))
+        throw new RemoteRequestError();
+    const standbyEndpoint = optionalString(record, "standby_endpoint");
+    const accelerateEndpoint = optionalString(record, "accelerate_endpoint");
+    const authKey = optionalString(record, "auth_key");
+    return {
+        securityToken: requiredString(record, "security_token"),
+        accessKeyId: requiredString(record, "access_key_id"),
+        accessKeySecret: requiredString(record, "access_key_secret"),
+        endpoint: requiredString(record, "endpoint"),
+        ...(standbyEndpoint === undefined ? {} : { standbyEndpoint }),
+        ...(accelerateEndpoint === undefined ? {} : { accelerateEndpoint }),
+        region: requiredString(record, "region"),
+        bucketName: requiredString(record, "bucket_name"),
+        objectName: requiredString(record, "object_name"),
+        host: requiredString(record, "host"),
+        ...(authKey === undefined ? {} : { authKey })
+    };
+}
+function publicAssetUrl(token) {
+    try {
+        const normalizedHost = token.host.includes("://") ? token.host : `https://${token.host}`;
+        const url = new URL(normalizedHost);
+        if ((url.protocol !== "http:" && url.protocol !== "https:")
+            || url.username !== ""
+            || url.password !== "") {
+            throw new RemoteRequestError();
+        }
+        url.search = "";
+        url.hash = "";
+        if (!url.pathname.endsWith("/"))
+            url.pathname += "/";
+        url.pathname += token.objectName
+            .replace(/^\/+/, "")
+            .split("/")
+            .map(encodeURIComponent)
+            .join("/");
+        if (token.authKey !== undefined)
+            url.searchParams.set("auth_key", token.authKey);
+        return url.href;
+    }
+    catch (error) {
+        if (error instanceof RemoteRequestError)
+            throw error;
+        throw new RemoteRequestError();
+    }
+}
+function storageToken(token) {
+    return {
+        securityToken: token.securityToken,
+        accessKeyId: token.accessKeyId,
+        accessKeySecret: token.accessKeySecret,
+        endpoint: token.endpoint,
+        ...(token.standbyEndpoint === undefined
+            ? {}
+            : { standbyEndpoint: token.standbyEndpoint }),
+        ...(token.accelerateEndpoint === undefined
+            ? {}
+            : { accelerateEndpoint: token.accelerateEndpoint }),
+        region: token.region,
+        bucketName: token.bucketName,
+        objectName: token.objectName
+    };
+}
+export function createDamStorageUploader(dependencies) {
+    return {
+        inspect(input, signal) {
+            return inspectUploadFile({ ...input, signal });
+        },
+        async upload(input, access, signal) {
+            signal.throwIfAborted();
+            let token;
+            let url;
+            try {
+                const response = await dependencies.transport.postJson({
+                    path: "/tb-dam/asset/upload/tokens",
+                    body: {
+                        ...(input.contentId === undefined ? {} : { content_id: input.contentId }),
+                        format: input.file.format
+                    },
+                    credential: access.credential,
+                    organizationId: access.organizationId,
+                    signal
+                });
+                signal.throwIfAborted();
+                token = parseToken(response);
+                url = publicAssetUrl(token);
+            }
+            catch (error) {
+                if (signal.aborted)
+                    throw signal.reason;
+                if (error instanceof RemoteRequestError)
+                    throw error;
+                throw new RemoteRequestError();
+            }
+            try {
+                await dependencies.storage.upload({
+                    token: storageToken(token),
+                    filePath: input.file.filePath,
+                    mediaType: input.file.mediaType,
+                    signal
+                });
+                signal.throwIfAborted();
+                return {
+                    ...input.file,
+                    url
+                };
+            }
+            catch (error) {
+                if (signal.aborted)
+                    throw signal.reason;
+                if (error instanceof RemoteRequestError)
+                    throw error;
+                throw new RemoteRequestError();
+            }
+        }
+    };
+}

package/dist/src/features/dam/transient-uploader.js

@@ -0,0 +1,17 @@
+export function createDamTransientUploader(dependencies) {
+    return {
+        async upload(input, access, signal) {
+            const file = await dependencies.storageUpload.inspect({
+                url: input.url,
+                ...(input.mediaType === undefined ? {} : { claimedMediaType: input.mediaType })
+            }, signal);
+            const stored = await dependencies.storageUpload.upload({ file }, access, signal);
+            return {
+                url: stored.url,
+                mediaType: stored.mediaType,
+                filename: input.filename ?? stored.filename,
+                fromUserUpload: true
+            };
+        }
+    };
+}

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

@@ -0,0 +1,151 @@
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+export class DamInputError extends Error {
+    constructor() {
+        super("DAM 输入不可用。");
+        this.name = "DamInputError";
+    }
+}
+function invalid() {
+    throw new DamInputError();
+}
+function nonblank(value) {
+    return value !== undefined && value.trim() !== "";
+}
+function assertPageSize(value) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 1 || value > 100))
+        invalid();
+}
+function assertAssetId(value) {
+    if (value.trim() === "" || /^https?:\/\//iu.test(value))
+        invalid();
+}
+function assertRepositorySelection(input) {
+    if (input.repositoryId !== undefined && !nonblank(input.repositoryId))
+        invalid();
+    if (input.repositoryId !== undefined && input.allRepositories === true)
+        invalid();
+}
+function searchRequest(input, keyword, repositoryIds) {
+    return {
+        keyword,
+        repositoryIds,
+        includeChildFolder: input.includeChildFolder ?? true,
+        pageSize: input.pageSize ?? 20,
+        ...(input.folderId === undefined ? {} : { folderId: input.folderId }),
+        ...(input.type === undefined ? {} : { type: input.type }),
+        ...(input.assetFormats === undefined ? {} : { assetFormats: [...input.assetFormats] }),
+        ...(input.tagIds === undefined ? {} : { tagIds: [...input.tagIds] }),
+        ...(input.cursor === undefined ? {} : { cursor: input.cursor })
+    };
+}
+export function createDamUseCases(dependencies) {
+    const validate = dependencies.validate;
+    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 });
+        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];
+    }
+    return {
+        async list({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertPageSize(input.pageSize);
+            const repositories = await resolveRepositories(input, access, signal);
+            const result = await dependencies.api.search({
+                ...searchRequest(input, "", repositories.map((repository) => repository.id)),
+                access,
+                signal
+            });
+            signal.throwIfAborted();
+            validate.list(result);
+            return result;
+        },
+        async search({ input, access, signal }) {
+            signal.throwIfAborted();
+            if (!nonblank(input.query))
+                invalid();
+            assertPageSize(input.pageSize);
+            const repositories = await resolveRepositories(input, access, signal);
+            const result = await dependencies.api.search({
+                ...searchRequest(input, input.query, repositories.map((repository) => repository.id)),
+                access,
+                signal
+            });
+            signal.throwIfAborted();
+            validate.search(result);
+            return result;
+        },
+        async get({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertAssetId(input.asset_id);
+            const result = await dependencies.api.getAsset({
+                assetId: input.asset_id,
+                access,
+                signal
+            });
+            signal.throwIfAborted();
+            validate.get(result);
+            return result;
+        },
+        async upload({ input, access, signal }) {
+            signal.throwIfAborted();
+            if (!nonblank(input.file))
+                invalid();
+            const file = await dependencies.storage.inspect({
+                url: pathToFileURL(resolve(process.cwd(), input.file)).href,
+                ...(input.allowSensitivePath === undefined
+                    ? {}
+                    : { allowSensitivePath: input.allowSensitivePath })
+            }, signal);
+            signal.throwIfAborted();
+            const [repository] = await resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal);
+            if (repository === undefined)
+                throw new RemoteRequestError();
+            const result = await dependencies.uploader.upload({
+                input,
+                file,
+                repository,
+                access,
+                signal
+            });
+            signal.throwIfAborted();
+            validate.upload(result);
+            return result;
+        },
+        async delete({ input, access, signal }) {
+            signal.throwIfAborted();
+            assertAssetId(input.asset_id);
+            const [repository] = await resolveRepositories({
+                ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
+            }, access, signal);
+            if (repository === undefined)
+                throw new RemoteRequestError();
+            const request = {
+                repositoryId: repository.id,
+                assetId: input.asset_id,
+                access,
+                signal
+            };
+            await dependencies.api.recycle(request);
+            signal.throwIfAborted();
+            if (input.permanent === true)
+                await dependencies.api.deleteRecycled(request);
+            signal.throwIfAborted();
+            validate.delete(null);
+        }
+    };
+}

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

@@ -0,0 +1,96 @@
+export class EditorBridgeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "EditorBridgeError";
+        this.code = code;
+    }
+}
+export function createEditorBridgeClient(options) {
+    const fetch = options.fetch ?? globalThis.fetch;
+    const baseUrl = `http://127.0.0.1:${options.state.port}`;
+    return {
+        async health(signal) {
+            const value = await request("/health", "GET", undefined, signal);
+            if (!isRecord(value) ||
+                !hasExactKeys(value, ["status", "pageConnected", "protocolVersion"]) ||
+                value.status !== "ok" ||
+                typeof value.pageConnected !== "boolean" ||
+                typeof value.protocolVersion !== "number") {
+                throw invalidResponse();
+            }
+            return {
+                status: "ok",
+                pageConnected: value.pageConnected,
+                protocolVersion: value.protocolVersion
+            };
+        },
+        async rpc(method, payload, signal) {
+            const value = await request("/rpc", "POST", { method, ...(payload === undefined ? {} : { payload }) }, signal);
+            if (!isRecord(value) ||
+                !hasExactKeys(value, ["result"]) ||
+                !("result" in value)) {
+                throw invalidResponse();
+            }
+            return value.result;
+        },
+        async disconnect(signal) {
+            const value = await request("/disconnect", "POST", {}, signal);
+            if (!isRecord(value) ||
+                !hasExactKeys(value, ["status"]) ||
+                value.status !== "disconnected") {
+                throw invalidResponse();
+            }
+        }
+    };
+    async function request(pathname, method, body, signal) {
+        const response = await fetch(`${baseUrl}${pathname}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${options.state.token}`,
+                ...(body === undefined ? {} : { "Content-Type": "application/json" })
+            },
+            redirect: "error",
+            signal,
+            ...(body === undefined ? {} : { body: JSON.stringify(body) })
+        });
+        let value;
+        try {
+            value = await response.json();
+        }
+        catch {
+            throw invalidResponse();
+        }
+        if (!response.ok) {
+            const error = readStructuredError(value);
+            if (!error)
+                throw invalidResponse();
+            throw new EditorBridgeError(error.code, error.message);
+        }
+        return value;
+    }
+}
+function readStructuredError(value) {
+    if (!isRecord(value) || !isRecord(value.error))
+        return null;
+    const { code, message } = value.error;
+    if (typeof code !== "string" ||
+        !/^[A-Z][A-Z0-9_]*$/.test(code) ||
+        typeof message !== "string" ||
+        message.trim().length === 0) {
+        return null;
+    }
+    return { code, message };
+}
+function invalidResponse() {
+    return new EditorBridgeError("EDITOR_BRIDGE_INVALID_RESPONSE", "Editor Bridge 返回了无效响应。");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length &&
+        actual.every((key, index) => key === expected[index]);
+}