@gaoding/cli 0.0.0 → 1.0.0-alpha.25

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();
+            }
+        }
+    };
+}

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

@@ -0,0 +1,193 @@
+import { createHmac } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import OSS from "ali-oss";
+export class ObjectStorageUploadError extends Error {
+    constructor() {
+        super("素材上传失败。");
+        this.name = "ObjectStorageUploadError";
+    }
+}
+function normalizeEndpoint(value) {
+    try {
+        const url = new URL(value.includes("://") ? value : `https://${value}`);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            throw new Error("unsupported protocol");
+        }
+        return url;
+    }
+    catch {
+        throw new ObjectStorageUploadError();
+    }
+}
+function endpointOrigin(value) {
+    return normalizeEndpoint(value).origin;
+}
+function endpointOrder(token) {
+    return [...new Set([
+            token.endpoint,
+            token.standbyEndpoint,
+            token.accelerateEndpoint
+        ].filter((value) => value !== undefined).map(endpointOrigin))];
+}
+function errorText(error) {
+    if (!(error instanceof Error))
+        return "";
+    const code = "code" in error && typeof error.code === "string" ? error.code : "";
+    return `${code} ${error.message}`;
+}
+function isTransient(error) {
+    const text = errorText(error);
+    return text.includes("socket hang up")
+        || text.includes("ECONNRESET")
+        || text.includes("ETIMEDOUT")
+        || text.includes("EPIPE");
+}
+function isUnsupportedAuthorization(error) {
+    return errorText(error).includes("Unsupported Authorization Type");
+}
+function sleepWithSignal(milliseconds, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, milliseconds);
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+const defaultPutOss = async (input) => {
+    input.signal.throwIfAborted();
+    const client = new OSS({
+        accessKeyId: input.token.accessKeyId,
+        accessKeySecret: input.token.accessKeySecret,
+        stsToken: input.token.securityToken,
+        // DAM issues one-shot credentials without a refresh endpoint.
+        refreshSTSTokenInterval: Number.MAX_SAFE_INTEGER,
+        endpoint: input.endpoint,
+        region: input.token.region,
+        bucket: input.token.bucketName,
+        secure: true,
+        authorizationV4: input.authorizationV4
+    });
+    await client.put(input.token.objectName, input.filePath, {
+        headers: { "Content-Type": input.mediaType }
+    });
+    input.signal.throwIfAborted();
+};
+async function attemptOss(input, dependencies) {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        input.signal.throwIfAborted();
+        try {
+            await dependencies.putOss(input);
+            input.signal.throwIfAborted();
+            return "success";
+        }
+        catch (error) {
+            if (input.signal.aborted)
+                throw input.signal.reason;
+            if (!input.authorizationV4 && isUnsupportedAuthorization(error)) {
+                return "unsupported-authorization";
+            }
+            if (!isTransient(error))
+                throw new ObjectStorageUploadError();
+            if (attempt === 1)
+                return "transient-exhausted";
+            await dependencies.sleep(300, input.signal);
+        }
+    }
+    return "transient-exhausted";
+}
+function isHuaweiObs(endpoint) {
+    const hostname = normalizeEndpoint(endpoint).hostname;
+    return /(^|\.)obs\.[^.]+\.myhuaweicloud\.com$/i.test(hostname);
+}
+function encodedObjectPath(objectName) {
+    return objectName.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
+}
+async function uploadObs(input, dependencies) {
+    input.signal.throwIfAborted();
+    const file = await stat(input.filePath);
+    input.signal.throwIfAborted();
+    const endpoint = normalizeEndpoint(input.endpoint);
+    const objectName = input.token.objectName.replace(/^\/+/, "");
+    endpoint.hostname = `${input.token.bucketName}.${endpoint.hostname}`;
+    endpoint.pathname = `/${encodedObjectPath(objectName)}`;
+    const date = dependencies.now().toUTCString();
+    const stringToSign = [
+        "PUT",
+        "",
+        input.mediaType,
+        date,
+        `x-obs-security-token:${input.token.securityToken}`,
+        `/${input.token.bucketName}/${objectName}`
+    ].join("\n");
+    const signature = createHmac("sha1", input.token.accessKeySecret)
+        .update(stringToSign)
+        .digest("base64");
+    const stream = createReadStream(input.filePath);
+    try {
+        const response = await dependencies.fetch(endpoint, {
+            method: "PUT",
+            headers: {
+                Authorization: `OBS ${input.token.accessKeyId}:${signature}`,
+                Date: date,
+                "Content-Type": input.mediaType,
+                "Content-Length": String(file.size),
+                "x-obs-security-token": input.token.securityToken
+            },
+            body: stream,
+            signal: input.signal,
+            duplex: "half"
+        });
+        input.signal.throwIfAborted();
+        if (!response.ok) {
+            stream.destroy();
+            throw new ObjectStorageUploadError();
+        }
+    }
+    catch (error) {
+        stream.destroy();
+        if (input.signal.aborted)
+            throw input.signal.reason;
+        if (error instanceof ObjectStorageUploadError)
+            throw error;
+        throw new ObjectStorageUploadError();
+    }
+}
+export function createObjectStorageUploader(options = {}) {
+    const dependencies = {
+        putOss: options.putOss ?? defaultPutOss,
+        fetch: options.fetch ?? globalThis.fetch,
+        sleep: options.sleep ?? sleepWithSignal,
+        now: options.now ?? (() => new Date())
+    };
+    return {
+        async upload(input) {
+            input.signal.throwIfAborted();
+            const endpoints = endpointOrder(input.token);
+            if (endpoints.length === 0)
+                throw new ObjectStorageUploadError();
+            if (isHuaweiObs(endpoints[0])) {
+                await uploadObs({ ...input, endpoint: endpoints[0] }, dependencies);
+                return;
+            }
+            for (const endpoint of endpoints) {
+                const base = { ...input, endpoint, authorizationV4: false };
+                const v1 = await attemptOss(base, dependencies);
+                if (v1 === "success")
+                    return;
+                if (v1 !== "unsupported-authorization")
+                    continue;
+                const v4 = await attemptOss({ ...base, authorizationV4: true }, dependencies);
+                if (v4 === "success")
+                    return;
+            }
+            throw new ObjectStorageUploadError();
+        }
+    };
+}

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);
+            }
+        }
+    };
+}