gaoding-cli 1.0.0-alpha.13 → 1.0.0-alpha.15

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

@@ -7,9 +7,13 @@ export class DeviceAuthorizationExpiredError extends Error {
 export function createAuthUseCases(dependencies) {
     return {
         async status(input) {
-            const state = await dependencies.store.read();
+            const state = await dependencies.telemetry.stage("state", () => dependencies.store.read());
             if (!state)
                 return { logged_in: false, next_steps: ["gd-cli auth login"] };
+            dependencies.telemetry.annotate({
+                account_id: state.account?.id,
+                organization_id: state.organization?.id
+            });
             const valid = Date.parse(state.credential.expiresAt) > input.now.getTime();
             return {
                 logged_in: true,
@@ -33,86 +37,99 @@ export function createAuthUseCases(dependencies) {
             };
         },
         async logout() {
-            await dependencies.store.remove();
+            await dependencies.telemetry.stage("state", () => dependencies.store.remove());
         },
         async login(input) {
             input.signal.throwIfAborted();
-            const existing = await dependencies.store.read();
+            const existing = await dependencies.telemetry.stage("state", () => dependencies.store.read());
             if (existing && Date.parse(existing.credential.expiresAt) > dependencies.now().getTime()) {
+                dependencies.telemetry.annotate({
+                    account_id: existing.account?.id,
+                    organization_id: existing.organization?.id
+                });
                 return {
                     status: "already_logged_in",
                     organizationSelected: existing.organization !== undefined
                 };
             }
-            const authorization = await dependencies.sso.startDeviceAuthorization(input.signal);
-            const deadline = dependencies.now().getTime() + authorization.expiresInSeconds * 1000;
-            const authorizationUrl = new URL("/cli/device-authorization", dependencies.authPageOrigin);
-            authorizationUrl.searchParams.set("code", authorization.authorizeCode);
-            await input.interaction.showAuthorization(authorizationUrl);
-            if (!input.noBrowser) {
-                try {
-                    await input.interaction.openBrowser(authorizationUrl);
-                }
-                catch {
-                    input.interaction.warn("无法自动打开浏览器，请手动访问授权链接。");
+            const authorization = await dependencies.telemetry.stage("authorize", async () => {
+                const authorization = await dependencies.sso.startDeviceAuthorization(input.signal);
+                const authorizationUrl = new URL("/cli/device-authorization", dependencies.authPageOrigin);
+                authorizationUrl.searchParams.set("code", authorization.authorizeCode);
+                await input.interaction.showAuthorization(authorizationUrl);
+                if (!input.noBrowser) {
+                    try {
+                        await input.interaction.openBrowser(authorizationUrl);
+                    }
+                    catch {
+                        input.interaction.warn("无法自动打开浏览器，请手动访问授权链接。");
+                    }
                 }
-            }
+                return authorization;
+            });
+            const deadline = dependencies.now().getTime() + authorization.expiresInSeconds * 1000;
             let interval = authorization.intervalSeconds * 1000;
-            while (true) {
-                if (dependencies.now().getTime() + interval > deadline) {
-                    throw new DeviceAuthorizationExpiredError();
-                }
-                await dependencies.sleep(interval, input.signal);
-                input.signal.throwIfAborted();
-                const token = await dependencies.sso.pollDeviceToken(authorization.deviceCode, input.signal);
-                if (token.status === "pending")
-                    continue;
-                if (token.status === "slow_down") {
-                    interval += 5_000;
-                    continue;
-                }
-                let state = {
-                    version: 1,
-                    credential: token.credential,
-                    ...(token.account ? { account: token.account } : {})
-                };
-                await dependencies.store.write(state);
-                let organizationId = token.organizationId;
-                try {
-                    const identity = await dependencies.sso.getIdentity(token.credential.accessKey, input.signal);
-                    organizationId = identity.organizationId ?? organizationId;
-                    if (!state.account && identity.account) {
-                        state = { ...state, account: identity.account };
-                        await dependencies.store.write(state);
+            const token = await dependencies.telemetry.stage("wait", async () => {
+                while (true) {
+                    if (dependencies.now().getTime() + interval > deadline) {
+                        throw new DeviceAuthorizationExpiredError();
                     }
-                }
-                catch {
-                    if (input.signal.aborted)
-                        throw input.signal.reason;
-                }
-                if (!organizationId) {
-                    input.interaction.warn("登录成功，请执行 gd-cli org switch 选择组织。");
-                    return { status: "logged_in", organizationSelected: false };
-                }
-                try {
-                    const organization = await dependencies.organizationBinder.bindAuthorizedOrganization({
-                        credential: token.credential,
-                        organizationId,
-                        signal: input.signal
-                    });
-                    if (!organization) {
-                        input.interaction.warn("登录成功，但未能选择组织；请执行 gd-cli org switch。");
-                        return { status: "logged_in", organizationSelected: false };
+                    await dependencies.sleep(interval, input.signal);
+                    input.signal.throwIfAborted();
+                    const result = await dependencies.sso.pollDeviceToken(authorization.deviceCode, input.signal);
+                    if (result.status === "pending")
+                        continue;
+                    if (result.status === "slow_down") {
+                        interval += 5_000;
+                        continue;
                     }
-                    await dependencies.store.write({ ...state, organization });
-                    return { status: "logged_in", organizationSelected: true };
+                    return result;
+                }
+            });
+            let state = {
+                version: 1,
+                credential: token.credential,
+                ...(token.account ? { account: token.account } : {})
+            };
+            await dependencies.telemetry.stage("state", () => dependencies.store.write(state));
+            dependencies.telemetry.annotate({ account_id: state.account?.id });
+            let organizationId = token.organizationId;
+            try {
+                const identity = await dependencies.telemetry.stage("identity", () => (dependencies.sso.getIdentity(token.credential.accessKey, input.signal)));
+                organizationId = identity.organizationId ?? organizationId;
+                if (!state.account && identity.account) {
+                    state = { ...state, account: identity.account };
+                    await dependencies.telemetry.stage("state", () => dependencies.store.write(state));
+                    dependencies.telemetry.annotate({ account_id: identity.account.id });
                 }
-                catch {
-                    if (input.signal.aborted)
-                        throw input.signal.reason;
-                    input.interaction.warn("登录成功，但组织绑定失败；请执行 gd-cli org switch。");
+            }
+            catch {
+                if (input.signal.aborted)
+                    throw input.signal.reason;
+            }
+            if (!organizationId) {
+                input.interaction.warn("登录成功，请执行 gd-cli org switch 选择组织。");
+                return { status: "logged_in", organizationSelected: false };
+            }
+            try {
+                const organization = await dependencies.telemetry.stage("bind", () => (dependencies.organizationBinder.bindAuthorizedOrganization({
+                    credential: token.credential,
+                    organizationId,
+                    signal: input.signal
+                })));
+                if (!organization) {
+                    input.interaction.warn("登录成功，但未能选择组织；请执行 gd-cli org switch。");
                     return { status: "logged_in", organizationSelected: false };
                 }
+                await dependencies.telemetry.stage("state", () => dependencies.store.write({ ...state, organization }));
+                dependencies.telemetry.annotate({ organization_id: organization.id });
+                return { status: "logged_in", organizationSelected: true };
+            }
+            catch {
+                if (input.signal.aborted)
+                    throw input.signal.reason;
+                input.interaction.warn("登录成功，但组织绑定失败；请执行 gd-cli org switch。");
+                return { status: "logged_in", organizationSelected: false };
             }
         }
     };

package/dist/src/features/dam/asset-projection.js

@@ -8,6 +8,16 @@ const publicAssetTypes = new Set([
     "template",
     "file"
 ]);
+const internalAssetTypes = new Map([
+    ["gdpic", "image"],
+    ["gdimage", "image"],
+    ["gdvideo", "video"],
+    ["gdaudio", "audio"],
+    ["gdfont", "font"],
+    ["gdtemplate", "template"],
+    ["gdfile", "file"],
+    ["gdslide", "file"]
+]);
 const recognizableAssetKeys = new Set([
     "asset_id",
     "id",
@@ -39,6 +49,12 @@ function record(value) {
 function nonblank(value) {
     return typeof value === "string" && value.trim() !== "" ? value : undefined;
 }
+function publicSourceFormat(value) {
+    const format = nonblank(value);
+    return format !== undefined && !internalAssetTypes.has(format.toLowerCase())
+        ? format
+        : undefined;
+}
 function finiteNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
@@ -114,19 +130,11 @@ function assetType(item, format, mediaType) {
     const explicit = nonblank(item.type)?.toLowerCase();
     if (explicit !== undefined && publicAssetTypes.has(explicit))
         return explicit;
-    const contentFormat = (nonblank(item.content_format) ?? nonblank(item.storage_format))?.toLowerCase();
-    if (contentFormat === "gdpic" || contentFormat === "gdimage")
-        return "image";
-    if (contentFormat === "gdvideo")
-        return "video";
-    if (contentFormat === "gdaudio")
-        return "audio";
-    if (contentFormat === "gdfont")
-        return "font";
-    if (contentFormat === "gdtemplate")
-        return "template";
-    if (contentFormat === "gdfile" || contentFormat === "gdslide")
-        return "file";
+    for (const candidate of [item.content_format, item.storage_format, item.format]) {
+        const internalType = internalAssetTypes.get(nonblank(candidate)?.toLowerCase() ?? "");
+        if (internalType !== undefined)
+            return internalType;
+    }
     const mediaCategory = mediaType?.split("/", 1)[0]?.toLowerCase();
     if (mediaCategory !== undefined && publicAssetTypes.has(mediaCategory))
         return mediaCategory;
@@ -160,7 +168,7 @@ function normalizeAsset(value, fallback) {
         ?? record(item.cover);
     const repository = record(item.repository_info) ?? record(item.repositoryInfo);
     const folder = record(item.folder_info) ?? record(item.folderInfo);
-    const format = nonblank(origin?.format) ?? nonblank(item.format);
+    const format = publicSourceFormat(origin?.format) ?? publicSourceFormat(item.format);
     const mediaType = nonblank(origin?.mime_type)
         ?? nonblank(item.mime_type)
         ?? nonblank(item.mimeType);

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

@@ -1,5 +1,11 @@
 import { RemoteRequestError } from "../../platform/signed-http-transport.js";
 import { projectDamAssetDetail, projectDamAssetSummary } from "./asset-projection.js";
+export class DamAssetNotFoundError extends Error {
+    constructor() {
+        super("DAM 素材不存在。");
+        this.name = "DamAssetNotFoundError";
+    }
+}
 const contentFormats = {
     image: ["gdpic", "gdimage"],
     video: ["gdvideo"],
@@ -152,10 +158,19 @@ export function createDamApiAdapter(dependencies) {
             return searchResult(response, input);
         },
         async getAsset(input) {
-            const response = await dependencies.transport.getJson({
-                path: `/dam/asset/${encodeURIComponent(input.assetId)}`,
-                ...requestContext(input)
-            });
+            let response;
+            try {
+                response = await dependencies.transport.getJson({
+                    path: `/dam/asset/${encodeURIComponent(input.assetId)}`,
+                    ...requestContext(input)
+                });
+            }
+            catch (error) {
+                if (error instanceof RemoteRequestError && error.status === 404) {
+                    throw new DamAssetNotFoundError();
+                }
+                throw error;
+            }
             const asset = projectDamAssetDetail(response, input.assetId);
             if (asset === undefined)
                 throw new RemoteRequestError();

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

@@ -66,6 +66,8 @@ const defaultPutOss = async (input) => {
         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,

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

@@ -114,24 +114,45 @@ export function createDamRegisteredUploader(dependencies) {
     return {
         async upload(input) {
             try {
+                const stage = (name, run) => (dependencies.telemetry.stage(name, async () => {
+                    try {
+                        return await run();
+                    }
+                    catch (error) {
+                        if (input.signal.aborted)
+                            throw input.signal.reason;
+                        if (error instanceof RemoteRequestError)
+                            throw error;
+                        throw new RemoteRequestError();
+                    }
+                }));
                 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 prepared = await stage("prepare", async () => {
+                    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 format = input.file.format.toLowerCase();
+                    return {
+                        digest,
+                        metadata,
+                        contentId,
+                        format,
+                        damFormat: storageFormat(format),
+                        title: input.input.title ?? filenameTitle(input.file.filename),
+                        folderId: input.input.folderId ?? "0"
+                    };
                 });
-                const stored = await dependencies.storage.upload({
+                const { digest, metadata, contentId, format, damFormat, title, folderId } = prepared;
+                const stored = await stage("upload", () => 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";
+                }, input.access, input.signal));
                 const preview = input.file.mediaType.startsWith("image/")
                     ? {
                         url: stored.url,
@@ -182,35 +203,37 @@ export function createDamRegisteredUploader(dependencies) {
                 });
                 if (fallback === undefined)
                     throw new RemoteRequestError();
-                let latest = await dependencies.api.createMaterial({
+                let latest = await stage("persist", () => 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;
+                return stage("wait", async () => {
+                    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);
                     }
-                    await sleep(Math.min(3000, remaining), input.signal);
-                }
+                });
             }
             catch (error) {
                 if (input.signal.aborted)

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

@@ -62,57 +62,63 @@ export function createDamUseCases(dependencies) {
         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
+            const repositories = await dependencies.telemetry.stage("repository", () => (resolveRepositories(input, access, signal)));
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.search({
+                    ...searchRequest(input, "", repositories.map((repository) => repository.id)),
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.list(result);
+                return result;
             });
-            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
+            const repositories = await dependencies.telemetry.stage("repository", () => (resolveRepositories(input, access, signal)));
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.search({
+                    ...searchRequest(input, input.query, repositories.map((repository) => repository.id)),
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.search(result);
+                return result;
             });
-            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
+            return dependencies.telemetry.stage("request", async () => {
+                const result = await dependencies.api.getAsset({
+                    assetId: input.asset_id,
+                    access,
+                    signal
+                });
+                signal.throwIfAborted();
+                validate.get(result);
+                return result;
             });
-            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({
+            const file = await dependencies.telemetry.stage("inspect", () => (dependencies.storage.inspect({
                 url: pathToFileURL(resolve(process.cwd(), input.file)).href,
                 ...(input.allowSensitivePath === undefined
                     ? {}
                     : { allowSensitivePath: input.allowSensitivePath })
-            }, signal);
+            }, signal)));
             signal.throwIfAborted();
-            const [repository] = await resolveRepositories({
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
                 ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
-            }, access, signal);
+            }, access, signal)));
             if (repository === undefined)
                 throw new RemoteRequestError();
             const result = await dependencies.uploader.upload({
@@ -129,9 +135,9 @@ export function createDamUseCases(dependencies) {
         async delete({ input, access, signal }) {
             signal.throwIfAborted();
             assertAssetId(input.asset_id);
-            const [repository] = await resolveRepositories({
+            const [repository] = await dependencies.telemetry.stage("repository", () => (resolveRepositories({
                 ...(input.repositoryId === undefined ? {} : { repositoryId: input.repositoryId })
-            }, access, signal);
+            }, access, signal)));
             if (repository === undefined)
                 throw new RemoteRequestError();
             const request = {
@@ -140,10 +146,11 @@ export function createDamUseCases(dependencies) {
                 access,
                 signal
             };
-            await dependencies.api.recycle(request);
+            await dependencies.telemetry.stage("recycle", () => dependencies.api.recycle(request));
             signal.throwIfAborted();
-            if (input.permanent === true)
-                await dependencies.api.deleteRecycled(request);
+            if (input.permanent === true) {
+                await dependencies.telemetry.stage("delete", () => dependencies.api.deleteRecycled(request));
+            }
             signal.throwIfAborted();
             validate.delete(null);
         }

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

@@ -38,7 +38,11 @@ export function createOrgUseCases(dependencies) {
     }
     return {
         async list(input) {
-            const records = await dependencies.org.list(input.state.credential, input.signal);
+            dependencies.telemetry.annotate({
+                account_id: input.state.account?.id,
+                organization_id: input.state.organization?.id
+            });
+            const records = await dependencies.telemetry.stage("list", () => dependencies.org.list(input.state.credential, input.signal));
             return {
                 orgs: records.map((record) => ({
                     id: record.id,
@@ -53,7 +57,13 @@ export function createOrgUseCases(dependencies) {
             };
         },
         async current() {
-            const state = await dependencies.store.read();
+            const state = await dependencies.telemetry.stage("state", () => dependencies.store.read());
+            if (state) {
+                dependencies.telemetry.annotate({
+                    account_id: state.account?.id,
+                    organization_id: state.organization?.id
+                });
+            }
             return {
                 organization: state?.organization
                     ? { id: state.organization.id, name: state.organization.name }
@@ -65,15 +75,21 @@ export function createOrgUseCases(dependencies) {
         },
         async switchOrganization(input) {
             input.signal.throwIfAborted();
-            const records = await dependencies.org.list(input.state.credential, input.signal);
-            const selectedId = input.organizationId === undefined
-                ? await selectOrganization(records, input.select)
-                : requiredSelection(input.organizationId);
-            const record = records.find((candidate) => candidate.id === selectedId);
-            if (!record)
-                throw new OrganizationInvalidError();
-            const organization = await bind(input.state.credential, record, input.signal);
-            await dependencies.store.write({ ...input.state, organization });
+            dependencies.telemetry.annotate({ account_id: input.state.account?.id });
+            const records = await dependencies.telemetry.stage("list", () => dependencies.org.list(input.state.credential, input.signal));
+            const { record, selectedId } = await dependencies.telemetry.stage("select", async () => {
+                const selectedId = input.organizationId === undefined
+                    ? await selectOrganization(records, input.select)
+                    : requiredSelection(input.organizationId);
+                const record = records.find((candidate) => candidate.id === selectedId);
+                if (!record)
+                    throw new OrganizationInvalidError();
+                return { record, selectedId };
+            });
+            dependencies.telemetry.annotate({ parameters: { organizationId: selectedId } });
+            const organization = await dependencies.telemetry.stage("bind", () => bind(input.state.credential, record, input.signal));
+            await dependencies.telemetry.stage("state", () => dependencies.store.write({ ...input.state, organization }));
+            dependencies.telemetry.annotate({ organization_id: organization.id });
             return record;
         },
         async bindAuthorizedOrganization(input) {

package/dist/src/features/tool/catalog.js

@@ -56,10 +56,14 @@ export function projectModelList(catalog, tool) {
             .map(summary)
     };
 }
-export function projectModelDetail(catalog, model) {
+export function findModel(catalog, model) {
     const found = catalog.models.find((candidate) => candidate.model === model);
     if (found === undefined)
         throw new ToolInputError();
+    return found;
+}
+export function projectModelDetail(catalog, model) {
+    const found = findModel(catalog, model);
     return {
         ...summary(found),
         ...(found.usageDescription === undefined
@@ -72,8 +76,8 @@ export function projectModelDetail(catalog, model) {
     };
 }
 export function findToolModel(catalog, tool, model) {
-    const found = catalog.models.find((candidate) => candidate.tool === tool && candidate.model === model);
-    if (found === undefined)
+    const found = findModel(catalog, model);
+    if (found.tool !== tool)
         throw new ToolInputError();
     return found;
 }