@gaoding/cli 0.0.0 → 1.0.0

package/dist/src/bootstrap/validators.js

@@ -0,0 +1,157 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import addFormatsImport, {} from "ajv-formats";
+import { contractSchema } from "../contracts/schema.js";
+const agentSendInputSchema = contractSchema("agent.send", "input");
+const agentSendOutputSchema = contractSchema("agent.send", "output");
+const authStatusSchema = contractSchema("auth.status", "output");
+const damDeleteInputSchema = contractSchema("dam.delete", "input");
+const damDeleteOutputSchema = contractSchema("dam.delete", "output");
+const damCopyInputSchema = contractSchema("dam.copy", "input");
+const damCopyOutputSchema = contractSchema("dam.copy", "output");
+const damDownloadInputSchema = contractSchema("dam.download", "input");
+const damDownloadOutputSchema = contractSchema("dam.download", "output");
+const damFolderListInputSchema = contractSchema("dam.folder.list", "input");
+const damFolderListOutputSchema = contractSchema("dam.folder.list", "output");
+const damGetInputSchema = contractSchema("dam.get", "input");
+const damGetOutputSchema = contractSchema("dam.get", "output");
+const damListInputSchema = contractSchema("dam.list", "input");
+const damListOutputSchema = contractSchema("dam.list", "output");
+const damMoveInputSchema = contractSchema("dam.move", "input");
+const damMoveOutputSchema = contractSchema("dam.move", "output");
+const damRepositoryListOutputSchema = contractSchema("dam.repository.list", "output");
+const damRenameInputSchema = contractSchema("dam.rename", "input");
+const damRenameOutputSchema = contractSchema("dam.rename", "output");
+const damSearchInputSchema = contractSchema("dam.search", "input");
+const damSearchOutputSchema = contractSchema("dam.search", "output");
+const damTagListInputSchema = contractSchema("dam.tag.list", "input");
+const damTagListOutputSchema = contractSchema("dam.tag.list", "output");
+const damUploadInputSchema = contractSchema("dam.upload", "input");
+const damUploadOutputSchema = contractSchema("dam.upload", "output");
+const editorApplyInputSchema = contractSchema("editor.apply", "input");
+const editorApplyOutputSchema = contractSchema("editor.apply", "output");
+const editorConnectInputSchema = contractSchema("editor.connect", "input");
+const editorConnectOutputSchema = contractSchema("editor.connect", "output");
+const editorDisconnectOutputSchema = contractSchema("editor.disconnect", "output");
+const editorSaveOutputSchema = contractSchema("editor.save", "output");
+const editorScreenshotOutputSchema = contractSchema("editor.screenshot", "output");
+const editorSnapshotOutputSchema = contractSchema("editor.snapshot", "output");
+const orgCurrentSchema = contractSchema("org.current", "output");
+const orgListSchema = contractSchema("org.list", "output");
+const modelGetInputSchema = contractSchema("model.get", "input");
+const modelGetOutputSchema = contractSchema("model.get", "output");
+const modelListInputSchema = contractSchema("model.list", "input");
+const modelListOutputSchema = contractSchema("model.list", "output");
+const toolCallInputSchema = contractSchema("tool.call", "input");
+const toolCallOutputSchema = contractSchema("tool.call", "output");
+const toolListOutputSchema = contractSchema("tool.list", "output");
+export class InputContractError extends Error {
+    constructor() {
+        super("输入不符合命令契约。");
+        this.name = "InputContractError";
+    }
+}
+export class OutputContractError extends Error {
+    constructor() {
+        super("命令结果不符合公开契约。");
+        this.name = "OutputContractError";
+    }
+}
+export function createContractValidators() {
+    const ajv = new Ajv2020({ allErrors: true, strict: true });
+    const addFormats = addFormatsImport;
+    addFormats(ajv);
+    const agentSendInput = ajv.compile(agentSendInputSchema);
+    const agentSendOutput = ajv.compile(agentSendOutputSchema);
+    const authStatus = ajv.compile(authStatusSchema);
+    const damFolderListInput = ajv.compile(damFolderListInputSchema);
+    const damFolderListOutput = ajv.compile(damFolderListOutputSchema);
+    const damListInput = ajv.compile(damListInputSchema);
+    const damListOutput = ajv.compile(damListOutputSchema);
+    const damRepositoryListOutput = ajv.compile(damRepositoryListOutputSchema);
+    const damRenameInput = ajv.compile(damRenameInputSchema);
+    const damRenameOutput = ajv.compile(damRenameOutputSchema);
+    const damMoveInput = ajv.compile(damMoveInputSchema);
+    const damMoveOutput = ajv.compile(damMoveOutputSchema);
+    const damCopyInput = ajv.compile(damCopyInputSchema);
+    const damCopyOutput = ajv.compile(damCopyOutputSchema);
+    const damSearchInput = ajv.compile(damSearchInputSchema);
+    const damSearchOutput = ajv.compile(damSearchOutputSchema);
+    const damTagListInput = ajv.compile(damTagListInputSchema);
+    const damTagListOutput = ajv.compile(damTagListOutputSchema);
+    const damGetInput = ajv.compile(damGetInputSchema);
+    const damGetOutput = ajv.compile(damGetOutputSchema);
+    const damUploadInput = ajv.compile(damUploadInputSchema);
+    const damUploadOutput = ajv.compile(damUploadOutputSchema);
+    const damDeleteInput = ajv.compile(damDeleteInputSchema);
+    const damDeleteOutput = ajv.compile(damDeleteOutputSchema);
+    const damDownloadInput = ajv.compile(damDownloadInputSchema);
+    const damDownloadOutput = ajv.compile(damDownloadOutputSchema);
+    const editorConnectInput = ajv.compile(editorConnectInputSchema);
+    const editorConnectOutput = ajv.compile(editorConnectOutputSchema);
+    const editorDisconnectOutput = ajv.compile(editorDisconnectOutputSchema);
+    const editorSnapshotOutput = ajv.compile(editorSnapshotOutputSchema);
+    const editorApplyInput = ajv.compile(editorApplyInputSchema);
+    const editorApplyOutput = ajv.compile(editorApplyOutputSchema);
+    const editorScreenshotOutput = ajv.compile(editorScreenshotOutputSchema);
+    const editorSaveOutput = ajv.compile(editorSaveOutputSchema);
+    const orgList = ajv.compile(orgListSchema);
+    const orgCurrent = ajv.compile(orgCurrentSchema);
+    const toolListOutput = ajv.compile(toolListOutputSchema);
+    const modelListInput = ajv.compile(modelListInputSchema);
+    const modelListOutput = ajv.compile(modelListOutputSchema);
+    const modelGetInput = ajv.compile(modelGetInputSchema);
+    const modelGetOutput = ajv.compile(modelGetOutputSchema);
+    const toolCallInput = ajv.compile(toolCallInputSchema);
+    const toolCallOutput = ajv.compile(toolCallOutputSchema);
+    return {
+        agentSendInput: assertion(agentSendInput, InputContractError),
+        agentSendOutput: assertion(agentSendOutput, OutputContractError),
+        authStatus: assertion(authStatus, OutputContractError),
+        damRepositoryListOutput: assertion(damRepositoryListOutput, OutputContractError),
+        damListInput: assertion(damListInput, InputContractError),
+        damListOutput: assertion(damListOutput, OutputContractError),
+        damSearchInput: assertion(damSearchInput, InputContractError),
+        damSearchOutput: assertion(damSearchOutput, OutputContractError),
+        damFolderListInput: assertion(damFolderListInput, InputContractError),
+        damFolderListOutput: assertion(damFolderListOutput, OutputContractError),
+        damTagListInput: assertion(damTagListInput, InputContractError),
+        damTagListOutput: assertion(damTagListOutput, OutputContractError),
+        damGetInput: assertion(damGetInput, InputContractError),
+        damGetOutput: assertion(damGetOutput, OutputContractError),
+        damUploadInput: assertion(damUploadInput, InputContractError),
+        damUploadOutput: assertion(damUploadOutput, OutputContractError),
+        damDeleteInput: assertion(damDeleteInput, InputContractError),
+        damDeleteOutput: assertion(damDeleteOutput, OutputContractError),
+        damDownloadInput: assertion(damDownloadInput, InputContractError),
+        damDownloadOutput: assertion(damDownloadOutput, OutputContractError),
+        damRenameInput: assertion(damRenameInput, InputContractError),
+        damRenameOutput: assertion(damRenameOutput, OutputContractError),
+        damMoveInput: assertion(damMoveInput, InputContractError),
+        damMoveOutput: assertion(damMoveOutput, OutputContractError),
+        damCopyInput: assertion(damCopyInput, InputContractError),
+        damCopyOutput: assertion(damCopyOutput, OutputContractError),
+        editorConnectInput: assertion(editorConnectInput, InputContractError),
+        editorConnectOutput: assertion(editorConnectOutput, OutputContractError),
+        editorDisconnectOutput: assertion(editorDisconnectOutput, OutputContractError),
+        editorSnapshotOutput: assertion(editorSnapshotOutput, OutputContractError),
+        editorApplyInput: assertion(editorApplyInput, InputContractError),
+        editorApplyOutput: assertion(editorApplyOutput, OutputContractError),
+        editorScreenshotOutput: assertion(editorScreenshotOutput, OutputContractError),
+        editorSaveOutput: assertion(editorSaveOutput, OutputContractError),
+        orgList: assertion(orgList, OutputContractError),
+        orgCurrent: assertion(orgCurrent, OutputContractError),
+        toolListOutput: assertion(toolListOutput, OutputContractError),
+        modelListInput: assertion(modelListInput, InputContractError),
+        modelListOutput: assertion(modelListOutput, OutputContractError),
+        modelGetInput: assertion(modelGetInput, InputContractError),
+        modelGetOutput: assertion(modelGetOutput, OutputContractError),
+        toolCallInput: assertion(toolCallInput, InputContractError),
+        toolCallOutput: assertion(toolCallOutput, OutputContractError)
+    };
+}
+function assertion(validate, ErrorType) {
+    return (value) => {
+        if (!validate(value))
+            throw new ErrorType();
+    };
+}

package/dist/src/cli/action-binding.js

@@ -0,0 +1,109 @@
+const environments = new WeakMap();
+const boundPolicies = new WeakMap();
+export function configureActionEnvironment(program, environment) {
+    environments.set(program, environment);
+}
+export function bindAction(command, policy, handler, telemetry) {
+    if (boundPolicies.has(command))
+        throw new Error(`Action already bound: ${commandPath(command)}`);
+    boundPolicies.set(command, policy);
+    bindTelemetrySelection(command, telemetry);
+    command.action(async () => {
+        const environment = environments.get(rootCommand(command));
+        if (!environment)
+            throw new Error("CLI action environment is missing.");
+        await checkUpdateNotification(environment, telemetry);
+        const context = await environment.telemetry.stage("access", async () => {
+            const authorized = await environment.policies[policy].authorize(environment.signal);
+            if (authorized.policy !== policy) {
+                throw new Error("Access policy returned the wrong context.");
+            }
+            return authorized;
+        });
+        annotateAccessContext(environment.telemetry, context);
+        await handler(context, environment.signal);
+    });
+}
+export function bindPreparedAction(command, policy, prepare, run, telemetry) {
+    if (boundPolicies.has(command))
+        throw new Error(`Action already bound: ${commandPath(command)}`);
+    boundPolicies.set(command, policy);
+    bindTelemetrySelection(command, telemetry);
+    command.action(async () => {
+        const environment = environments.get(rootCommand(command));
+        if (!environment)
+            throw new Error("CLI action environment is missing.");
+        await checkUpdateNotification(environment, telemetry);
+        const prepared = await environment.telemetry.stage("input", () => prepare(environment.signal));
+        if (prepared.handled)
+            return;
+        const context = await environment.telemetry.stage("access", async () => {
+            const authorized = await environment.policies[policy].authorize(environment.signal);
+            if (authorized.policy !== policy) {
+                throw new Error("Access policy returned the wrong context.");
+            }
+            return authorized;
+        });
+        annotateAccessContext(environment.telemetry, context);
+        await run(context, prepared.input, environment.signal);
+    });
+}
+async function checkUpdateNotification(environment, telemetry) {
+    if (telemetry?.operation === "update")
+        return;
+    try {
+        await environment.updateNotification.check(environment.signal);
+    }
+    catch {
+        // Version availability must never change the requested command outcome.
+    }
+}
+export function assertAllLeafCommandsBound(program) {
+    for (const command of leafCommands(program)) {
+        if (!boundPolicies.has(command)) {
+            throw new Error(`Leaf command is missing an access policy: ${commandPath(command)}`);
+        }
+    }
+}
+function leafCommands(command) {
+    if (command.commands.length === 0)
+        return [command];
+    return command.commands.flatMap(leafCommands);
+}
+function rootCommand(command) {
+    let current = command;
+    while (current.parent)
+        current = current.parent;
+    return current;
+}
+function bindTelemetrySelection(command, definition) {
+    if (!definition)
+        return;
+    if (!command.parent)
+        throw new Error(`Telemetry command has no parent: ${command.name()}`);
+    command.parent.hook("preSubcommand", (parent, selected) => {
+        if (selected !== command)
+            return;
+        const environment = environments.get(rootCommand(parent));
+        if (!environment)
+            throw new Error("CLI action environment is missing.");
+        environment.telemetry.select(definition);
+    });
+}
+function annotateAccessContext(telemetry, context) {
+    if (context.policy === "none")
+        return;
+    telemetry.annotate({
+        account_id: context.state.account?.id,
+        organization_id: context.state.organization?.id
+    });
+}
+function commandPath(command) {
+    const names = [];
+    let current = command;
+    while (current) {
+        names.unshift(current.name());
+        current = current.parent;
+    }
+    return names.join(" ");
+}

package/dist/src/cli/agent-commands.js

@@ -0,0 +1,49 @@
+import { contractSchema } from "../contracts/schema.js";
+import { bindPreparedAction } from "./action-binding.js";
+import { CliUsageError } from "./errors.js";
+const agentSendInputSchema = contractSchema("agent.send", "input");
+export function registerAgentCommands(program, runtime) {
+    const agent = program.command("agent")
+        .description("稿定 Agent")
+        .helpCommand(false);
+    const send = agent.command("send")
+        .description("发送结构化创作消息")
+        .option("--schema", "输出输入 Schema")
+        .option("--input <file|->", "从文件或标准输入读取 JSON")
+        .allowExcessArguments(false);
+    bindPreparedAction(send, "organization", async (signal) => {
+        signal.throwIfAborted();
+        const options = send.opts();
+        const modes = Number(options.schema === true) + Number(options.input !== undefined);
+        if (modes !== 1)
+            throw new CliUsageError();
+        if (options.schema === true) {
+            await runtime.telemetry.stage("output", async () => {
+                runtime.io.writeOut(`${JSON.stringify(agentSendInputSchema)}\n`);
+            });
+            return { handled: true };
+        }
+        const input = await runtime.jsonInput.read(options.input, signal);
+        runtime.validators.agentSendInput(input);
+        runtime.telemetry.annotate({ parameters: { ...input } });
+        return { handled: false, input };
+    }, async (context, input, signal) => {
+        const result = await runtime.agent.send({
+            input,
+            access: {
+                credential: context.state.credential,
+                organizationId: context.state.organization.id
+            },
+            signal
+        });
+        await runtime.telemetry.stage("output", async () => {
+            runtime.validators.agentSendOutput(result);
+            runtime.io.writeOut(`${JSON.stringify(result)}\n`);
+        });
+    }, {
+        operation: "agent.send",
+        mode: () => send.opts().schema === true
+            ? "schema"
+            : "execute"
+    });
+}

package/dist/src/cli/auth-commands.js

@@ -0,0 +1,55 @@
+import { bindAction } from "./action-binding.js";
+import { authStatusView } from "./presenter.js";
+export function registerAuthCommands(program, runtime) {
+    const auth = program.command("auth")
+        .description("登录与本机凭证")
+        .helpCommand(false);
+    const login = leaf(auth.command("login"))
+        .description("登录稿定")
+        .option("--no-browser", "不自动打开浏览器");
+    bindAction(login, "none", async (_context, signal) => {
+        const noBrowser = login.opts().browser === false;
+        runtime.telemetry.annotate({ parameters: { noBrowser } });
+        const result = await runtime.auth.login({
+            noBrowser,
+            signal,
+            interaction: {
+                showAuthorization: (url) => runtime.presenter.authorization({
+                    url,
+                    terminal: runtime.io.stderrTerminal
+                }),
+                openBrowser: (url) => runtime.browser.open(url),
+                warn: (message) => runtime.presenter.warning(message)
+            }
+        });
+        await runtime.telemetry.stage("output", async () => {
+            runtime.presenter.success(result.status === "already_logged_in" ? "已登录。" : "登录成功。");
+            if (result.status === "already_logged_in" && !result.organizationSelected) {
+                runtime.presenter.warning("尚未选择组织，请执行 gd-cli org switch。");
+            }
+        });
+    }, { operation: "auth.login" });
+    const status = leaf(auth.command("status"))
+        .description("查看登录状态")
+        .option("--json", "输出 JSON");
+    bindAction(status, "none", async () => {
+        const result = await runtime.auth.status({ now: runtime.now() });
+        await runtime.telemetry.stage("output", async () => {
+            runtime.validators.authStatus(result);
+            runtime.presenter.result(result, {
+                json: status.opts().json === true,
+                view: authStatusView
+            });
+        });
+    }, { operation: "auth.status" });
+    const logout = leaf(auth.command("logout")).description("退出登录");
+    bindAction(logout, "none", async () => {
+        await runtime.auth.logout();
+        await runtime.telemetry.stage("output", async () => {
+            runtime.presenter.success("已退出登录。");
+        });
+    }, { operation: "auth.logout" });
+}
+function leaf(command) {
+    return command.allowExcessArguments(false);
+}