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

package/dist/src/features/update/update-service.js

@@ -57,20 +57,22 @@ export function createUpdateService(options) {
     return {
         async run(signal) {
             signal.throwIfAborted();
-            const latest = await fetchLatest(fetchPackage, signal);
+            const latest = await options.telemetry.stage("registry", () => (fetchLatest(fetchPackage, signal)));
             signal.throwIfAborted();
             const skillOptions = {
                 env,
                 ...(options.homeDirectory ? { homeDirectory: options.homeDirectory } : {})
             };
             if (!gt(latest, options.currentVersion)) {
-                try {
-                    await syncSkills(options.bundledSkills, skillOptions);
-                }
-                catch (error) {
-                    rethrowAbort(signal);
-                    throw new UpdateError("UPDATE_FAILED", `gd-cli ${options.currentVersion} 无需更新，但 Agent Skill 同步失败。`, ["请解决冲突后重新执行 gd-cli update。"]);
-                }
+                await options.telemetry.stage("sync", async () => {
+                    try {
+                        await syncSkills(options.bundledSkills, skillOptions);
+                    }
+                    catch (error) {
+                        rethrowAbort(signal);
+                        throw new UpdateError("UPDATE_FAILED", `gd-cli ${options.currentVersion} 无需更新，但 Agent Skill 同步失败。`, ["请解决冲突后重新执行 gd-cli update。"]);
+                    }
+                });
                 return { version: options.currentVersion, updated: false };
             }
             const binaryPath = options.binaryPath ?? process.argv[1] ?? "";
@@ -89,25 +91,29 @@ export function createUpdateService(options) {
             const args = source.manager === "npm"
                 ? ["install", "--global", "--allow-scripts=gaoding-cli", `gaoding-cli@${latest}`]
                 : ["add", "--global", "--allow-build=gaoding-cli", `gaoding-cli@${latest}`];
-            try {
-                await runProcess(command, args, signal);
-            }
-            catch (error) {
-                rethrowAbort(signal);
-                throw new UpdateError("UPDATE_FAILED", `gd-cli 更新到 ${latest} 失败。`, nextSteps);
-            }
+            await options.telemetry.stage("install", async () => {
+                try {
+                    await runProcess(command, args, signal);
+                }
+                catch (error) {
+                    rethrowAbort(signal);
+                    throw new UpdateError("UPDATE_FAILED", `gd-cli 更新到 ${latest} 失败。`, nextSteps);
+                }
+            });
             signal.throwIfAborted();
             const targetSkills = options.bundledSkills.map((skill) => ({
                 ...skill,
                 version: latest
             }));
-            try {
-                await verifySkills(targetSkills, skillOptions);
-            }
-            catch (error) {
-                rethrowAbort(signal);
-                throw new UpdateError("UPDATE_PARTIAL", `gd-cli 已更新到 ${latest}，但 Agent Skill 验收失败。`, ["请重新执行 gd-cli update。"]);
-            }
+            await options.telemetry.stage("verify", async () => {
+                try {
+                    await verifySkills(targetSkills, skillOptions);
+                }
+                catch (error) {
+                    rethrowAbort(signal);
+                    throw new UpdateError("UPDATE_PARTIAL", `gd-cli 已更新到 ${latest}，但 Agent Skill 验收失败。`, ["请重新执行 gd-cli update。"]);
+                }
+            });
             return { version: latest, updated: true };
         }
     };

package/dist/src/platform/json-input.js

@@ -52,6 +52,9 @@ function readStream(stream, signal) {
         };
         const onAbort = () => {
             cleanup();
+            const destroy = stream.destroy;
+            if (typeof destroy === "function")
+                destroy.call(stream);
             reject(signal.reason);
         };
         stream.on("data", onData);

package/dist/src/platform/remote-protocol.js

@@ -0,0 +1,6 @@
+export class RemoteProtocolError extends Error {
+    constructor() {
+        super("稿定服务响应与当前 CLI 不兼容。");
+        this.name = "RemoteProtocolError";
+    }
+}

package/dist/src/telemetry/invocation.js

@@ -0,0 +1,128 @@
+const detailedStages = {
+    "auth.login": new Set(["authorize", "wait", "identity", "bind"]),
+    "org.switch": new Set(["list", "bind"]),
+    "agent.send:execute": new Set(["upload", "execute", "result"]),
+    "tool.call:execute": new Set(["catalog", "upload", "intent", "submit", "wait"]),
+    "dam.upload": new Set(["inspect", "repository", "prepare", "upload", "persist", "wait"]),
+    update: new Set(["registry", "install", "sync", "verify"])
+};
+export function createTelemetryInvocation(options) {
+    const invocationId = options.idFactory();
+    const startedAt = options.now();
+    let definition;
+    const context = {};
+    const stages = [];
+    return {
+        invocationId,
+        get selected() {
+            return definition !== undefined;
+        },
+        select(nextDefinition) {
+            definition = nextDefinition;
+        },
+        annotate(annotation) {
+            if (annotation.account_id !== undefined)
+                context.account_id = annotation.account_id;
+            if (annotation.organization_id !== undefined) {
+                context.organization_id = annotation.organization_id;
+            }
+            if (annotation.tool_name !== undefined)
+                context.tool_name = annotation.tool_name;
+            if (annotation.model_id !== undefined)
+                context.model_id = annotation.model_id;
+            if (annotation.parameters !== undefined) {
+                context.parameters = { ...annotation.parameters };
+            }
+        },
+        async stage(name, run) {
+            const stageStartedAt = options.now();
+            try {
+                const result = await run();
+                stages.push({
+                    name,
+                    durationMs: elapsed(options.now(), stageStartedAt),
+                    outcome: "success"
+                });
+                return result;
+            }
+            catch (error) {
+                const classification = options.classifyError(error);
+                stages.push({
+                    name,
+                    durationMs: elapsed(options.now(), stageStartedAt),
+                    outcome: classification.outcome,
+                    error,
+                    ...(classification.errorCode === undefined
+                        ? {}
+                        : { errorCode: classification.errorCode }),
+                    ...(classification.httpStatus === undefined
+                        ? {}
+                        : { httpStatus: classification.httpStatus })
+                });
+                throw error;
+            }
+        },
+        finish(completion) {
+            if (!definition)
+                return [];
+            const selectedDefinition = definition;
+            const mode = selectedDefinition.mode?.();
+            const allowedStages = detailedStages[stageKey(selectedDefinition.operation, mode)];
+            const stageEvents = allowedStages
+                ? stages
+                    .filter((stage) => allowedStages.has(stage.name))
+                    .map((stage) => ({
+                    schema_version: "1",
+                    event_name: "stage_finished",
+                    invocation_id: invocationId,
+                    operation: selectedDefinition.operation,
+                    stage: stage.name,
+                    outcome: stage.outcome,
+                    duration_ms: stage.durationMs,
+                    ...(stage.errorCode === undefined ? {} : { error_code: stage.errorCode }),
+                    ...(stage.httpStatus === undefined ? {} : { http_status: stage.httpStatus })
+                }))
+                : [];
+            const command = {
+                schema_version: "1",
+                event_name: "command_finished",
+                invocation_id: invocationId,
+                operation: selectedDefinition.operation,
+                ...(mode === undefined ? {} : { mode }),
+                outcome: completion.outcome,
+                duration_ms: elapsed(options.now(), startedAt),
+                cli_version: options.cliVersion,
+                os: options.runtime.os,
+                arch: options.runtime.arch,
+                node_major: options.runtime.nodeMajor,
+                ...(context.account_id === undefined ? {} : { account_id: context.account_id }),
+                ...(context.organization_id === undefined
+                    ? {}
+                    : { organization_id: context.organization_id }),
+                ...(context.tool_name === undefined ? {} : { tool_name: context.tool_name }),
+                ...(context.model_id === undefined ? {} : { model_id: context.model_id }),
+                ...(context.parameters === undefined
+                    ? {}
+                    : { parameters: { ...context.parameters } }),
+                ...(completion.outcome === "failure"
+                    ? {
+                        error_code: completion.errorCode,
+                        error_message: completion.errorMessage,
+                        failure_stage: stages.find((stage) => stage.error === completion.error)?.name
+                            ?? "unknown",
+                        ...(completion.httpStatus === undefined
+                            ? {}
+                            : { http_status: completion.httpStatus })
+                    }
+                    : {})
+            };
+            return [...stageEvents, command];
+        }
+    };
+}
+function stageKey(operation, mode) {
+    return mode === undefined ? operation : `${operation}:${mode}`;
+}
+function elapsed(now, startedAt) {
+    return Math.max(0, now - startedAt);
+}

package/dist/src/telemetry/sls-sink.js

@@ -0,0 +1,31 @@
+const trackingUrl = new URL("https://gaoding-log-ai-gpu.cn-hangzhou.log.aliyuncs.com/logstores/gd-cli/track?APIVersion=0.6.0");
+const TIMEOUT_MS = 2_000;
+export function createSlsTelemetrySink(options) {
+    return {
+        async send(events) {
+            if (events.length === 0)
+                return;
+            try {
+                await options.fetch(trackingUrl, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ __logs__: events.map(wireEvent) }),
+                    redirect: "error",
+                    signal: AbortSignal.timeout(TIMEOUT_MS)
+                });
+            }
+            catch {
+                // Telemetry must never change command behavior.
+            }
+        }
+    };
+}
+function wireEvent(event) {
+    const wire = {};
+    for (const [key, value] of Object.entries(event)) {
+        if (value === undefined)
+            continue;
+        wire[key] = key === "parameters" ? JSON.stringify(value) : String(value);
+    }
+    return wire;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaoding-cli",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.14",
   "description": "Gaoding command-line interface for agents and people.",
   "type": "module",
   "license": "MIT",

package/skills/gd-cli/references/creation.md

@@ -25,11 +25,13 @@ gd-cli agent send --input request.json
 gd-cli tool list
 gd-cli model list --tool <tool>
 gd-cli model get <model>
-gd-cli tool call <tool> --schema
+gd-cli model get <model> --schema
 gd-cli tool call <tool> --input request.json
 ```
 
-`tool list` 给出可用 Tool；`model list` 和 `model get` 给出当前可用 Model、费用与预估耗时等信息；`tool call --schema` 给出所选 Tool 的实时输入要求。不要把列表值固化在提示或脚本中。
+`tool list` 给出可用 Tool；`model list` 和 `model get` 给出当前可用 Model、说明、费用与预估耗时；`model get --schema` 给出所选 Model 的实时运行时输入 Schema。不要把列表值固化在提示或脚本中。
+
+按所选 Model Schema 构造 JSON：提供全部 required 字段；SELECT 参数使用 `options[].value`；required 字段带 default 且用户未指定时，在输入中显式使用该 default。存在 width、height、resolution 等专用字段时，将用户要求写入对应结构化参数，不要只写在 prompt 中。`tool call <tool> --schema` 返回整个 Tool 下所有 Model 的参数并集，只用于 Tool 级发现，不替代选定 Model 的 Schema。
 
 成功结果包含 `content` 和 `usage`。`content` 是文本或资源链接；`usage` 包含所选模型及模型目录公布的稿豆价格区间，不表示实际扣费。
 

package/skills/gd-cli/references/errors.md

@@ -3,8 +3,10 @@
 - `stdout` 只承载命令结果；结构化命令的 JSON 可直接解析。
 - `stderr` 承载警告、授权提示和错误；不要把警告混入结果。
 - 退出码 `0` 表示成功。
-- 退出码 `1` 表示运行、服务或状态失败；读取错误码与“下一步”，处理后再重试。
+- 退出码 `1` 表示运行、服务或状态失败；只执行错误中 `error.details.next_steps` 明确给出的恢复步骤，缺失时停止并报告。
 - 退出码 `2` 表示命令或参数错误；执行对应命令的 `--help` 后修正调用。
 - 退出码 `130` 表示用户中断；立即停止，不自动重试。
 
+Agent 或 Tool 等可能消耗稿豆的请求如果可能已经提交、但完成状态未知，停止并报告，不自动重试原调用。
+
 不要从未知错误中推断内部实现，也不要输出本地凭证、请求签名或带敏感查询参数的 URL。命令失败且没有安全恢复步骤时，保留原始 stderr 的公开错误码并向用户说明。