gaoding-cli 1.0.0-alpha.10

package/dist/src/bootstrap/create-runtime.js

@@ -0,0 +1,222 @@
+import { randomUUID } from "node:crypto";
+import { dirname } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { createAccessPolicies } from "../features/auth/access-policy.js";
+import { createLocalCredentialStore } from "../features/auth/credential-store.js";
+import { createAuthUseCases } from "../features/auth/use-cases.js";
+import { createSsoService } from "../features/auth/sso-service.js";
+import { createCreativeAgentAdapter } from "../features/agent/creative-agent-adapter.js";
+import { createDamApiAdapter } from "../features/dam/dam-api-adapter.js";
+import { createDamRegisteredUploader } from "../features/dam/registered-uploader.js";
+import { createDamTransientUploader } from "../features/dam/transient-uploader.js";
+import { createDamStorageUploader } from "../features/dam/storage-upload.js";
+import { createDamUseCases } from "../features/dam/use-cases.js";
+import { createEditorSession } from "../features/editor/session.js";
+import { createEditorSessionStateStore } from "../features/editor/session-state.js";
+import { createEditorUseCases } from "../features/editor/use-cases.js";
+import { createObjectStorageUploader } from "../features/dam/object-storage.js";
+import { createAgentUseCases } from "../features/agent/use-cases.js";
+import { createMnsCatalogAdapter } from "../features/tool/mns-catalog-adapter.js";
+import { createToolApiAdapter } from "../features/tool/tool-api-adapter.js";
+import { createToolUseCases } from "../features/tool/use-cases.js";
+import { createOrgUseCases } from "../features/org/use-cases.js";
+import { createOrgService } from "../features/org/org-service.js";
+import { createBrowserOpener } from "../platform/open-browser.js";
+import { createSignedHttpTransport } from "../platform/signed-http-transport.js";
+import { createJsonInputReader } from "../platform/json-input.js";
+import { createOrganizationPrompt } from "../cli/prompt.js";
+import { createPresenter } from "../cli/presenter.js";
+import { createContractValidators } from "./validators.js";
+import { loadBundledSkills } from "../features/skill/bundled-skills.js";
+import { createUpdateService } from "../features/update/update-service.js";
+const productionEndpoints = {
+    orgApi: new URL("https://gdcli.gaoding.com/api"),
+    agentApi: new URL("https://gdcli.gaoding.com/api"),
+    mnsApi: new URL("https://gdcli.gaoding.com/api"),
+    toolApi: new URL("https://gdcli.gaoding.com/api"),
+    damApi: new URL("https://gdcli.gaoding.com/api"),
+    ssoApi: new URL("https://www.gaoding.com/api/sso"),
+    authPageOrigin: new URL("https://www.gaoding.com")
+};
+export function createProductionRuntime(options = {}) {
+    const bundledSkills = loadBundledSkills(fileURLToPath(import.meta.url));
+    const primarySkill = bundledSkills.find((skill) => skill.skill === "gd-cli");
+    if (!primarySkill)
+        throw new Error("Bundled gd-cli Skill is missing.");
+    const endpoints = options.endpoints ?? productionEndpoints;
+    const fetch = options.fetch ?? globalThis.fetch;
+    const now = options.now ?? (() => new Date());
+    const rawIo = options.io ?? {
+        input: process.stdin,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        inputTerminal: process.stdin.isTTY === true,
+        stderrTerminal: process.stderr.isTTY === true
+    };
+    const io = {
+        writeOut: (text) => { rawIo.stdout.write(text); },
+        writeError: (text) => { rawIo.stderr.write(text); },
+        inputTerminal: rawIo.inputTerminal ?? hasTerminal(rawIo.input),
+        stderrTerminal: rawIo.stderrTerminal ?? hasTerminal(rawIo.stderr)
+    };
+    const store = createLocalCredentialStore({
+        ...(options.homeDirectory ? { homeDirectory: options.homeDirectory } : {})
+    });
+    const orgTransport = createSignedHttpTransport({
+        baseUrl: endpoints.orgApi,
+        fetch,
+        now
+    });
+    const agentTransport = createSignedHttpTransport({
+        baseUrl: endpoints.agentApi,
+        fetch,
+        now
+    });
+    const mnsTransport = createSignedHttpTransport({
+        baseUrl: endpoints.mnsApi,
+        fetch,
+        now
+    });
+    const toolTransport = createSignedHttpTransport({
+        baseUrl: endpoints.toolApi,
+        fetch,
+        now
+    });
+    const damTransport = createSignedHttpTransport({
+        baseUrl: endpoints.damApi,
+        fetch,
+        now,
+        channelId: "32"
+    });
+    const sso = createSsoService({
+        ssoApi: endpoints.ssoApi,
+        fetch,
+        now
+    });
+    const org = createOrgUseCases({
+        store,
+        org: createOrgService({ transport: orgTransport }),
+        sso
+    });
+    const auth = createAuthUseCases({
+        store,
+        sso,
+        organizationBinder: org,
+        authPageOrigin: endpoints.authPageOrigin,
+        now,
+        sleep: async (milliseconds, signal) => {
+            await delay(milliseconds, undefined, { signal });
+        }
+    });
+    const storage = options.objectStorage ?? createObjectStorageUploader({ fetch, now });
+    const storageUpload = createDamStorageUploader({
+        transport: damTransport,
+        storage
+    });
+    const transientUploader = createDamTransientUploader({ storageUpload });
+    const presenter = createPresenter({
+        writeOut: io.writeOut,
+        writeError: io.writeError
+    });
+    const browser = createBrowserOpener();
+    const validators = createContractValidators();
+    const damApi = createDamApiAdapter({ transport: damTransport });
+    const dam = createDamUseCases({
+        api: damApi,
+        storage: storageUpload,
+        uploader: createDamRegisteredUploader({
+            api: damApi,
+            storage: storageUpload,
+            warn: (message) => { presenter.warning(message); },
+            now
+        }),
+        validate: {
+            list: validators.damListOutput,
+            search: validators.damSearchOutput,
+            get: validators.damGetOutput,
+            upload: validators.damUploadOutput,
+            delete: validators.damDeleteOutput
+        }
+    });
+    const agent = createAgentUseCases({
+        uploader: transientUploader,
+        completion: createCreativeAgentAdapter({
+            transport: agentTransport,
+            idFactory: randomUUID
+        })
+    });
+    const tool = createToolUseCases({
+        catalog: createMnsCatalogAdapter({ transport: mnsTransport }),
+        execution: createToolApiAdapter({ transport: toolTransport }),
+        uploader: transientUploader,
+        warn: (message) => { presenter.warning(message); }
+    });
+    const editor = createEditorUseCases({
+        session: createEditorSession({
+            store: createEditorSessionStateStore({
+                ...(options.homeDirectory === undefined
+                    ? {}
+                    : { homeDirectory: options.homeDirectory })
+            }),
+            browser,
+            defaultCreateUrl: new URL("https://www.gaoding.art/editor/canvas?mode=create&type=board"),
+            workUrl: new URL("https://www.gaoding.art/editor/canvas"),
+            ...(options.homeDirectory === undefined
+                ? {}
+                : { homeDirectory: options.homeDirectory })
+        }),
+        validate: {
+            connect: validators.editorConnectOutput,
+            disconnect: validators.editorDisconnectOutput,
+            snapshot: validators.editorSnapshotOutput,
+            apply: validators.editorApplyOutput,
+            screenshot: validators.editorScreenshotOutput,
+            save: validators.editorSaveOutput
+        }
+    });
+    const update = {
+        run(signal) {
+            const packageRoot = dirname(dirname(primarySkill.sourceDirectory));
+            return createUpdateService({
+                currentVersion: primarySkill.version,
+                packageRoot,
+                bundledSkills,
+                fetch,
+                ...(process.argv[1] ? { binaryPath: process.argv[1] } : {}),
+                ...(options.homeDirectory ? { homeDirectory: options.homeDirectory } : {})
+            }).run(signal);
+        }
+    };
+    return {
+        version: primarySkill.version,
+        accessPolicies: createAccessPolicies({
+            store,
+            now,
+            refreshCurrentOrganization: org.refreshCurrentOrganization
+        }),
+        auth,
+        org,
+        agent,
+        editor,
+        dam,
+        tool,
+        update,
+        jsonInput: createJsonInputReader({
+            cwd: process.cwd(),
+            stdin: rawIo.input
+        }),
+        validators,
+        presenter,
+        prompt: createOrganizationPrompt({
+            input: rawIo.input,
+            output: rawIo.stderr
+        }),
+        browser,
+        now,
+        io
+    };
+}
+function hasTerminal(value) {
+    return "isTTY" in value && value.isTTY === true;
+}

package/dist/src/bootstrap/validators.js

@@ -0,0 +1,118 @@
+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 damGetInputSchema = contractSchema("dam.get", "input");
+const damGetOutputSchema = contractSchema("dam.get", "output");
+const damListInputSchema = contractSchema("dam.list", "input");
+const damListOutputSchema = contractSchema("dam.list", "output");
+const damSearchInputSchema = contractSchema("dam.search", "input");
+const damSearchOutputSchema = contractSchema("dam.search", "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 damListInput = ajv.compile(damListInputSchema);
+    const damListOutput = ajv.compile(damListOutputSchema);
+    const damSearchInput = ajv.compile(damSearchInputSchema);
+    const damSearchOutput = ajv.compile(damSearchOutputSchema);
+    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 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),
+        damListInput: assertion(damListInput, InputContractError),
+        damListOutput: assertion(damListOutput, OutputContractError),
+        damSearchInput: assertion(damSearchInput, InputContractError),
+        damSearchOutput: assertion(damSearchOutput, 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),
+        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,63 @@
+const environments = new WeakMap();
+const boundPolicies = new WeakMap();
+export function configureActionEnvironment(program, environment) {
+    environments.set(program, environment);
+}
+export function bindAction(command, policy, handler) {
+    if (boundPolicies.has(command))
+        throw new Error(`Action already bound: ${commandPath(command)}`);
+    boundPolicies.set(command, policy);
+    command.action(async () => {
+        const environment = environments.get(rootCommand(command));
+        if (!environment)
+            throw new Error("CLI action environment is missing.");
+        const context = await environment.policies[policy].authorize(environment.signal);
+        if (context.policy !== policy)
+            throw new Error("Access policy returned the wrong context.");
+        await handler(context, environment.signal);
+    });
+}
+export function bindPreparedAction(command, policy, prepare, run) {
+    if (boundPolicies.has(command))
+        throw new Error(`Action already bound: ${commandPath(command)}`);
+    boundPolicies.set(command, policy);
+    command.action(async () => {
+        const environment = environments.get(rootCommand(command));
+        if (!environment)
+            throw new Error("CLI action environment is missing.");
+        const prepared = await prepare(environment.signal);
+        if (prepared.handled)
+            return;
+        const context = await environment.policies[policy].authorize(environment.signal);
+        if (context.policy !== policy)
+            throw new Error("Access policy returned the wrong context.");
+        await run(context, prepared.input, environment.signal);
+    });
+}
+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 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,39 @@
+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) {
+            runtime.io.writeOut(`${JSON.stringify(agentSendInputSchema)}\n`);
+            return { handled: true };
+        }
+        const input = await runtime.jsonInput.read(options.input, signal);
+        runtime.validators.agentSendInput(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
+        });
+        runtime.validators.agentSendOutput(result);
+        runtime.io.writeOut(`${JSON.stringify(result)}\n`);
+    });
+}

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

@@ -0,0 +1,47 @@
+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 result = await runtime.auth.login({
+            noBrowser: login.opts().browser === false,
+            signal,
+            interaction: {
+                showAuthorization: (url) => runtime.presenter.authorization({
+                    url,
+                    terminal: runtime.io.stderrTerminal
+                }),
+                openBrowser: (url) => runtime.browser.open(url),
+                warn: (message) => runtime.presenter.warning(message)
+            }
+        });
+        runtime.presenter.success(result.status === "already_logged_in" ? "已登录。" : "登录成功。");
+        if (result.status === "already_logged_in" && !result.organizationSelected) {
+            runtime.presenter.warning("尚未选择组织，请执行 gd-cli org switch。");
+        }
+    });
+    const status = leaf(auth.command("status"))
+        .description("查看登录状态")
+        .option("--json", "输出 JSON");
+    bindAction(status, "none", async () => {
+        const result = await runtime.auth.status({ now: runtime.now() });
+        runtime.validators.authStatus(result);
+        runtime.presenter.result(result, {
+            json: status.opts().json === true,
+            view: authStatusView
+        });
+    });
+    const logout = leaf(auth.command("logout")).description("退出登录");
+    bindAction(logout, "none", async () => {
+        await runtime.auth.logout();
+        runtime.presenter.success("已退出登录。");
+    });
+}
+function leaf(command) {
+    return command.allowExcessArguments(false);
+}