gaoding-cli 1.0.0-alpha.5

package/dist/src/core/output/live-display.js

@@ -0,0 +1,111 @@
+import chalk from "chalk";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export class LiveDisplay {
+    steps = [];
+    frameIndex = 0;
+    timer = null;
+    isTTY;
+    startedAt = 0;
+    constructor(tty) {
+        this.isTTY = tty ?? !!process.stderr.isTTY;
+    }
+    addStep(label) {
+        const idx = this.steps.length;
+        this.steps.push({ label, status: "pending" });
+        return idx;
+    }
+    startStep(idx) {
+        if (idx < this.steps.length) {
+            this.steps[idx].status = "running";
+            this.steps[idx].startedAt = Date.now();
+        }
+        if (!this.timer && this.isTTY) {
+            this.startedAt = this.startedAt || Date.now();
+            this.timer = setInterval(() => this.render(), 80);
+        }
+        if (!this.isTTY) {
+            this.emitProgress(idx);
+        }
+    }
+    completeStep(idx) {
+        if (idx < this.steps.length) {
+            this.steps[idx].status = "done";
+        }
+        if (!this.isTTY) {
+            this.emitProgress(idx);
+        }
+    }
+    failStep(idx) {
+        if (idx < this.steps.length) {
+            this.steps[idx].status = "failed";
+        }
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (this.isTTY) {
+            this.render();
+            process.stderr.write("\n");
+        }
+    }
+    render() {
+        if (!this.isTTY)
+            return;
+        this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+        const spinner = SPINNER_FRAMES[this.frameIndex];
+        const elapsed = ((Date.now() - this.startedAt) / 1000).toFixed(1);
+        const lines = [];
+        for (let i = 0; i < this.steps.length; i++) {
+            const step = this.steps[i];
+            let icon;
+            let text;
+            switch (step.status) {
+                case "pending":
+                    icon = chalk.dim("○");
+                    text = chalk.dim(step.label);
+                    break;
+                case "running": {
+                    icon = chalk.cyan(spinner);
+                    const stepElapsed = step.startedAt ? ((Date.now() - step.startedAt) / 1000).toFixed(0) : "0";
+                    text = chalk.cyan(`${step.label} (${stepElapsed}s)`);
+                    break;
+                }
+                case "done":
+                    icon = chalk.green("✓");
+                    text = chalk.green(step.label);
+                    break;
+                case "failed":
+                    icon = chalk.red("✗");
+                    text = chalk.red(step.label);
+                    break;
+            }
+            lines.push(`  ${icon} ${text}`);
+        }
+        lines.push(chalk.dim(`  ⏱ ${elapsed}s`));
+        const output = `\x1b[${this.steps.length + 1}A\x1b[0J` + lines.join("\n") + "\n";
+        if (this.frameIndex <= 1) {
+            process.stderr.write(lines.join("\n") + "\n");
+        }
+        else {
+            process.stderr.write(output);
+        }
+    }
+    emitProgress(idx) {
+        const step = this.steps[idx];
+        if (!step)
+            return;
+        const total = this.steps.length;
+        const completed = this.steps.filter((s) => s.status === "done").length;
+        const progress = {
+            type: "progress",
+            current: completed,
+            total,
+            step: step.label,
+            status: step.status,
+            percent: Math.round((completed / total) * 100),
+        };
+        process.stderr.write(JSON.stringify(progress) + "\n");
+    }
+}

package/dist/src/core/output/result-card.d.ts

@@ -0,0 +1,18 @@
+interface CommandResult {
+    title?: string;
+    status: "success" | "error" | "info";
+    data: Record<string, unknown>;
+    nextSteps?: string[];
+}
+export declare class ResultCard {
+    static render(result: CommandResult): void;
+    static success(data: Record<string, unknown>, opts?: {
+        title?: string;
+        nextSteps?: string[];
+    }): void;
+    static error(data: Record<string, unknown>, opts?: {
+        title?: string;
+        nextSteps?: string[];
+    }): void;
+}
+export {};

package/dist/src/core/output/result-card.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+export class ResultCard {
+    static render(result) {
+        const statusIcon = result.status === "success" ? chalk.green("✓") :
+            result.status === "error" ? chalk.red("✗") :
+                chalk.blue("ℹ");
+        const title = result.title ?? (result.status === "success" ? "完成" : result.status === "error" ? "失败" : "信息");
+        console.log("");
+        console.log(`${statusIcon} ${chalk.bold(title)}`);
+        console.log(chalk.dim("─".repeat(40)));
+        for (const [key, value] of Object.entries(result.data)) {
+            if (value === undefined || value === null)
+                continue;
+            if (typeof value === "string" && (value.startsWith("http://") || value.startsWith("https://"))) {
+                console.log(`  ${chalk.dim(key + ":")} ${chalk.cyan.underline(value)}`);
+            }
+            else if (typeof value === "object") {
+                console.log(`  ${chalk.dim(key + ":")} ${JSON.stringify(value)}`);
+            }
+            else {
+                console.log(`  ${chalk.dim(key + ":")} ${String(value)}`);
+            }
+        }
+        if (result.nextSteps && result.nextSteps.length > 0) {
+            console.log("");
+            console.log(chalk.dim("  下一步:"));
+            for (const step of result.nextSteps) {
+                console.log(`    ${chalk.dim("→")} ${step}`);
+            }
+        }
+        console.log("");
+    }
+    static success(data, opts) {
+        this.render({ status: "success", data, ...opts });
+    }
+    static error(data, opts) {
+        this.render({ status: "error", data, ...opts });
+    }
+}

package/dist/src/core/prompt/index.d.ts

@@ -0,0 +1,31 @@
+declare class ValidationError extends Error {
+    constructor(message: string);
+}
+export declare class Prompt {
+    private static guard;
+    static select<T>(opts: {
+        message: string;
+        choices: {
+            name: string;
+            value: T;
+            description?: string;
+        }[];
+    }): Promise<T>;
+    static multiSelect<T>(opts: {
+        message: string;
+        choices: {
+            name: string;
+            value: T;
+            description?: string;
+            checked?: boolean;
+            disabled?: boolean | string;
+        }[];
+    }): Promise<T[]>;
+    static confirm(message: string, defaultValue?: boolean): Promise<boolean>;
+    static text(opts: {
+        message: string;
+        default?: string;
+        validate?: (value: string) => string | true;
+    }): Promise<string>;
+}
+export { ValidationError };

package/dist/src/core/prompt/index.js

@@ -0,0 +1,36 @@
+import { select, checkbox, confirm, input } from "@inquirer/prompts";
+class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ValidationError";
+    }
+}
+export class Prompt {
+    static guard(actionDesc) {
+        if (!process.stdout.isTTY) {
+            throw new ValidationError(`此操作需要交互式输入（${actionDesc}），请通过参数直接指定。\n` +
+                `  示例: gd-cli auth login --org <org-id>`);
+        }
+    }
+    static async select(opts) {
+        this.guard(opts.message);
+        return select(opts);
+    }
+    static async multiSelect(opts) {
+        this.guard(opts.message);
+        return checkbox(opts);
+    }
+    static async confirm(message, defaultValue = true) {
+        this.guard(message);
+        return confirm({ message, default: defaultValue });
+    }
+    static async text(opts) {
+        this.guard(opts.message);
+        return input({
+            message: opts.message,
+            default: opts.default,
+            validate: opts.validate,
+        });
+    }
+}
+export { ValidationError };

package/dist/src/io.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 统一 TTY / 输出流检测（借鉴 gh IOStreams 思路，轻量实现）。
+ */
+export declare class IOStreams {
+    readonly stdinIsTTY: boolean;
+    readonly stdoutIsTTY: boolean;
+    readonly stderrIsTTY: boolean;
+    constructor();
+    /** Agent / CI：stdout 非 TTY 时默认 JSON */
+    prefersJsonOutput(explicitFormat?: string): boolean;
+    /** 授权等人机交互场景 */
+    isInteractiveAuth(): boolean;
+}
+export declare function getIO(): IOStreams;

package/dist/src/io.js

@@ -0,0 +1,31 @@
+/**
+ * 统一 TTY / 输出流检测（借鉴 gh IOStreams 思路，轻量实现）。
+ */
+export class IOStreams {
+    stdinIsTTY;
+    stdoutIsTTY;
+    stderrIsTTY;
+    constructor() {
+        this.stdinIsTTY = !!process.stdin.isTTY;
+        this.stdoutIsTTY = !!process.stdout.isTTY;
+        this.stderrIsTTY = !!process.stderr.isTTY;
+    }
+    /** Agent / CI：stdout 非 TTY 时默认 JSON */
+    prefersJsonOutput(explicitFormat) {
+        if (explicitFormat && explicitFormat !== "json")
+            return false;
+        if (explicitFormat === "json")
+            return true;
+        return !this.stdoutIsTTY;
+    }
+    /** 授权等人机交互场景 */
+    isInteractiveAuth() {
+        return this.stdoutIsTTY && this.stdinIsTTY;
+    }
+}
+let _io = null;
+export function getIO() {
+    if (!_io)
+        _io = new IOStreams();
+    return _io;
+}

package/dist/src/middleware/auth.d.ts

@@ -0,0 +1,3 @@
+type ActionHandler = (...args: any[]) => Promise<void>;
+export declare function withAuth(handler: ActionHandler): ActionHandler;
+export {};

package/dist/src/middleware/auth.js

@@ -0,0 +1,74 @@
+import { CredentialStoreV2 } from "../auth/credential-store-v2.js";
+import { OrgManager } from "../core/auth/org-manager.js";
+function commandPath(cmd) {
+    const names = [];
+    let c = cmd;
+    while (c) {
+        const n = c.name();
+        if (n && !n.startsWith("-"))
+            names.unshift(n);
+        c = c.parent;
+    }
+    return names;
+}
+function shouldSkipAuth(cmd) {
+    const path = commandPath(cmd);
+    if (path.length === 0)
+        return false;
+    if (path[0] === "config")
+        return true;
+    if (path.includes("auth")) {
+        const sub = path[path.length - 1];
+        return sub === "login" || sub === "logout";
+    }
+    return false;
+}
+function isDirectBusinessCommand(cmd) {
+    const path = commandPath(cmd);
+    return path.includes("tools") || path.includes("workflows") || path.includes("dam");
+}
+export function withAuth(handler) {
+    return async (...args) => {
+        const command = args[args.length - 1];
+        if (shouldSkipAuth(command)) {
+            return handler(...args);
+        }
+        const v2Store = new CredentialStoreV2();
+        const v2 = v2Store.read();
+        if (v2) {
+            if (v2Store.isAkExpired()) {
+                console.error("Error: AK/SK 已过期");
+                console.error("\n  请重新登录：\n    gd-cli auth login\n");
+                process.exit(1);
+            }
+            if (v2Store.isBindExpired() && v2.current_org?.id) {
+                try {
+                    const orgMgr = new OrgManager();
+                    await orgMgr.switchOrg(v2.current_org.id);
+                }
+                catch {
+                    console.error("Error: 组织绑定已过期");
+                    console.error("\n  请切换组织：\n    gd-cli org switch\n");
+                    process.exit(1);
+                }
+            }
+            if (isDirectBusinessCommand(command) && !v2Store.read()?.current_org?.id) {
+                console.error("Error: 当前未绑定组织");
+                console.error("\n  请先切换组织：");
+                console.error("    gd-cli org switch\n");
+                process.exit(1);
+            }
+            return handler(...args);
+        }
+        if (isDirectBusinessCommand(command)) {
+            console.error("Error: 未找到 AK/SK 凭证");
+            console.error("\n  请先登录并绑定组织：");
+            console.error("    gd-cli auth login\n");
+            process.exit(1);
+        }
+        console.error("Error: 未找到 AK/SK 凭证");
+        console.error("\n  请先登录：");
+        console.error("    gd-cli auth login\n");
+        process.exit(1);
+    };
+}

package/dist/src/middleware/error-handler.d.ts

@@ -0,0 +1,3 @@
+type ActionHandler = (...args: any[]) => Promise<void>;
+export declare function withErrorHandler(handler: ActionHandler): ActionHandler;
+export {};