@actiondock/cli 2.0.12 → 2.2.0

package/dist/commands/remove.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册 ad remove 依赖移除命令。
+ * 遵循规范：移除依赖并更新锁文件，保留该包的历史存储数据，检查反向引用防止误删。
+ */
+export declare function registerRemoveCommand(program: Command, context?: CliContext): void;

package/dist/commands/remove.js

@@ -0,0 +1,118 @@
+import { resolve } from "node:path";
+import { beginTransaction, findProjectRoot, getInstallCommand, loadLockfile, loadManifest, saveLockfile, saveManifest, } from "@actiondock/core";
+import { ArgumentError, ExecutionError } from "../errors.js";
+import { renderResult } from "../renderer.js";
+import { getEffectiveOptions, spawnAsync } from "../utils/index.js";
+/**
+ * 注册 ad remove 依赖移除命令。
+ * 遵循规范：移除依赖并更新锁文件，保留该包的历史存储数据，检查反向引用防止误删。
+ */
+export function registerRemoveCommand(program, context) {
+    program
+        .command("remove <package>")
+        .description("Remove an Action package dependency and update actiondock.lock.json")
+        .option("-P, --package <path>", "Target project directory path")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action(async (packageIdentifier, rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const root = options.package ? resolve(options.package) : findProjectRoot();
+        if (!root) {
+            throw new ArgumentError("Not in an ActionDock project (actiondock.json not found).\nPlease specify -P, --package <path> or cd into a project directory.");
+        }
+        const manifest = loadManifest(root);
+        if (!manifest) {
+            throw new ArgumentError(`actiondock.json not found in ${root}`);
+        }
+        // 寻址逻辑包标识
+        let targetPackageId = null;
+        let npmPackageName = packageIdentifier;
+        if (manifest.dependencies?.[packageIdentifier]) {
+            targetPackageId = packageIdentifier;
+            npmPackageName = manifest.dependencies[packageIdentifier];
+        }
+        else if (manifest.dependencies) {
+            for (const [id, spec] of Object.entries(manifest.dependencies)) {
+                if (spec === packageIdentifier || id === packageIdentifier) {
+                    targetPackageId = id;
+                    npmPackageName = spec;
+                    break;
+                }
+            }
+        }
+        if (!targetPackageId) {
+            throw new ArgumentError(`Package '${packageIdentifier}' is not a declared dependency in actiondock.json`);
+        }
+        // 检查当前工程中 Action 的反向 uses 依赖声明
+        if (manifest.actions) {
+            for (const [actionId, actionEntry] of Object.entries(manifest.actions)) {
+                if (actionEntry.uses && Array.isArray(actionEntry.uses)) {
+                    const hasRef = actionEntry.uses.some((u) => u === targetPackageId ||
+                        u === `${targetPackageId}/*` ||
+                        u.startsWith(`${targetPackageId}/`));
+                    if (hasRef) {
+                        throw new ExecutionError(`Cannot remove package '${targetPackageId}': action '${actionId}' declares dependency on it in 'uses'. Please remove the 'uses' declaration first.`, undefined, "DEPENDENCY_CONFLICT");
+                    }
+                }
+            }
+        }
+        // 检查当前工程中 Playbook 的反向动作引用
+        if (manifest.playbooks) {
+            for (const [pbId, pbEntry] of Object.entries(manifest.playbooks)) {
+                if (pbEntry.actions && Array.isArray(pbEntry.actions)) {
+                    const hasRef = pbEntry.actions.some((a) => a === targetPackageId ||
+                        a === `${targetPackageId}/*` ||
+                        a.startsWith(`${targetPackageId}/`));
+                    if (hasRef) {
+                        throw new ExecutionError(`Cannot remove package '${targetPackageId}': playbook '${pbId}' references it in 'actions'. Please update the playbook first.`, undefined, "DEPENDENCY_CONFLICT");
+                    }
+                }
+            }
+        }
+        // 获取排他锁与事务快照保护
+        const tx = await beginTransaction(root, `ad remove ${packageIdentifier}`);
+        try {
+            // 从 actiondock.json 中移除依赖声明
+            if (manifest.dependencies) {
+                delete manifest.dependencies[targetPackageId];
+                if (Object.keys(manifest.dependencies).length === 0) {
+                    delete manifest.dependencies;
+                }
+                saveManifest(root, manifest);
+            }
+            // 从 actiondock.lock.json 中移除锁定记录
+            const lockfile = loadLockfile(root);
+            if (lockfile && lockfile.packages[targetPackageId]) {
+                delete lockfile.packages[targetPackageId];
+                saveLockfile(root, lockfile);
+            }
+            // 调用包管理器执行卸载
+            const installCmd = getInstallCommand(root);
+            const pm = installCmd[0];
+            const args = pm === "bun" ? ["remove", npmPackageName] : ["uninstall", npmPackageName, "--ignore-scripts"];
+            const uninstallProc = await spawnAsync(pm, args, {
+                cwd: root,
+                stdio: "pipe",
+            });
+            // 卸载失败不阻断事务提交（与原同步实现一致：忽略退出码）
+            void uninstallProc;
+            // 提交事务
+            await tx.commit();
+            const resultPayload = {
+                packageId: targetPackageId,
+                npmPackage: npmPackageName,
+                retainedNamespace: targetPackageId,
+            };
+            renderResult(resultPayload, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => `Successfully removed '${resultPayload.packageId}'.\n[INFO] Retained configuration and state namespace for package '${resultPayload.packageId}'.`,
+                context,
+            });
+        }
+        catch (err) {
+            await tx.rollback({ frozenInstall: false });
+            throw new ExecutionError(err.message, err, err.code || "REMOVE_DEPENDENCY_FAILED");
+        }
+    });
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 统一执行 Action 核心逻辑（使用 ActionDockTarget 门面）。
+ */
+export declare function executeAction(id: string, options: any, context?: CliContext): Promise<void>;
+/**
+ * 注册顶层统一 run 命令：执行指定 Action。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export declare function registerRunCommand(program: Command, context?: CliContext): void;

package/dist/commands/run.js

@@ -0,0 +1,146 @@
+import { readFileSync } from "node:fs";
+import { parseDuration, resolveTarget } from "@actiondock/core";
+import { ArgumentError, ExecutionError, SigintError } from "../errors.js";
+import { writeStdout } from "../renderer.js";
+import { getEffectiveOptions, resolveLocalPackageRoot, withTarget } from "../utils/index.js";
+/**
+ * 统一执行 Action 核心逻辑（使用 ActionDockTarget 门面）。
+ */
+export async function executeAction(id, options, context) {
+    if (!id) {
+        throw new ArgumentError("Action ID is required for run");
+    }
+    let input = {};
+    if (options.input) {
+        try {
+            input = JSON.parse(options.input);
+        }
+        catch (err) {
+            throw new ArgumentError(`Error parsing --input JSON: ${err.message}`);
+        }
+    }
+    else if (options.inputFile) {
+        try {
+            input = JSON.parse(readFileSync(options.inputFile, "utf-8"));
+        }
+        catch (err) {
+            throw new ArgumentError(`Error reading --input-file: ${err.message}`);
+        }
+    }
+    let timeoutMs;
+    if (options.timeout) {
+        try {
+            timeoutMs = parseDuration(options.timeout);
+        }
+        catch (err) {
+            throw new ArgumentError(`Invalid timeout format: ${err.message}`);
+        }
+    }
+    const configOverrides = {};
+    if (options.config) {
+        const list = Array.isArray(options.config) ? options.config : [options.config];
+        for (const item of list) {
+            const [k, ...v] = item.split("=");
+            if (k)
+                configOverrides[k] = v.join("=");
+        }
+    }
+    const controller = new AbortController();
+    let receivedSigint = false;
+    const sigintHandler = () => {
+        receivedSigint = true;
+        controller.abort(new Error("Interrupted by SIGINT"));
+    };
+    process.once("SIGINT", sigintHandler);
+    try {
+        // 异步执行仅支持远端目标，本地模式直接拒绝
+        const resolvedTopology = resolveTarget({
+            profile: options.profile,
+            server: options.server,
+            token: options.token,
+        }, context?.customHome);
+        if (resolvedTopology.type === "local" && options.async) {
+            throw new ExecutionError("Async execution requires a long-running ActionDock server.\nUse --profile, --server, or start 'ad serve'.");
+        }
+        // 目标拓扑解析（仅 local 分支需要包寻址）
+        const targetPackageRoot = resolveLocalPackageRoot(options.package);
+        if (options.package && !targetPackageRoot) {
+            throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
+        }
+        let targetRef = id;
+        if (options.package && !id.includes("/") && !id.includes(":")) {
+            targetRef = `${options.package}/${id}`;
+        }
+        // 通过 Target 统一执行
+        await withTarget(options, context, async (target) => {
+            if (options.async) {
+                const ticket = await target.startAction(targetRef, input, {
+                    signal: controller.signal,
+                    timeoutMs,
+                    config: configOverrides,
+                    requestId: options.requestId,
+                });
+                const asyncOutput = {
+                    ok: ticket.status !== "failed",
+                    runId: ticket.runId,
+                    status: ticket.status,
+                };
+                writeStdout(JSON.stringify(asyncOutput, null, 2), context);
+                if (ticket.status === "failed") {
+                    process.exitCode = 1;
+                    return;
+                }
+            }
+            else {
+                const result = await target.runAction(targetRef, input, {
+                    signal: controller.signal,
+                    timeoutMs,
+                    config: configOverrides,
+                    requestId: options.requestId,
+                });
+                writeStdout(JSON.stringify(result, null, 2), context);
+                if (!result.ok) {
+                    process.exitCode = 1;
+                    return;
+                }
+            }
+        }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true });
+    }
+    catch (err) {
+        if (receivedSigint || err?.name === "AbortError" || err?.message?.includes("SIGINT")) {
+            throw new SigintError();
+        }
+        throw err;
+    }
+    finally {
+        process.removeListener("SIGINT", sigintHandler);
+    }
+}
+/**
+ * 注册顶层统一 run 命令：执行指定 Action。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export function registerRunCommand(program, context) {
+    program
+        .command("run <id>")
+        .description("Execute an action (from current project, linked packages, or remote profile)")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("-i, --input <json>", "Input as JSON string")
+        .option("-f, --input-file <path>", "Input from JSON file")
+        .option("-c, --config <key=value...>", "Temporary config override (repeatable)")
+        .option("-p, --profile <name>", "Execute against a specific profile")
+        .option("-s, --server <url>", "Remote server URL")
+        .option("-t, --token <token>", "Auth token for remote server")
+        .option("--timeout <duration>", "Execution timeout (e.g. 30s, 5m, 500ms)")
+        .option("--request-id <id>", "Idempotency request ID for deduplication")
+        .option("--async", "Execute asynchronously in background (requires remote server or profile)")
+        .option("--data-dir <path>", "Custom database directory")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action(async (id, rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        await executeAction(id, options, context);
+    });
+}

package/dist/commands/runs.d.ts

@@ -1,2 +1,9 @@
-import type { Command } from "commander";
-export declare function registerRunsCommands(program: Command): void;
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册 runs 动作执行历史管理命令（list、show、clear、cancel）。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export declare function registerRunsCommands(program: Command, context?: CliContext): void;

package/dist/commands/runs.js

@@ -0,0 +1,245 @@
+import { filterWithFallbackInfo, findProjectRoot, listLinkedPackages, loadProjectConfig, resolvePackageRoot, resolveTarget, } from "@actiondock/core";
+import { ArgumentError, ExecutionError } from "../errors.js";
+import { renderResult, renderRunDetail, renderRunsList } from "../renderer.js";
+import { getEffectiveOptions, resolveIntent, withRemoteTarget, withTarget } from "../utils/index.js";
+/**
+ * 解析本地目标包根目录与工程配置（仅在 local 分支调用）。
+ * 显式指定包且寻址失败时抛出参数错误；工程清单损坏时降级为链接包视图。
+ */
+function resolveLocalRunScope(packageOption) {
+    if (packageOption) {
+        const root = resolvePackageRoot(packageOption);
+        if (!root) {
+            throw new ArgumentError(`Package '${packageOption}' not found in linked packages or path`);
+        }
+        try {
+            return { targetPackageRoot: root, projConfig: loadProjectConfig(root) };
+        }
+        catch {
+            // 工程清单损坏时降级为链接包作用域视图
+            return { targetPackageRoot: root, projConfig: null };
+        }
+    }
+    const root = findProjectRoot();
+    if (!root) {
+        return { targetPackageRoot: undefined, projConfig: null };
+    }
+    try {
+        return { targetPackageRoot: root, projConfig: loadProjectConfig(root) };
+    }
+    catch {
+        // 工程清单损坏时降级为链接包作用域视图
+        return { targetPackageRoot: root, projConfig: null };
+    }
+}
+/**
+ * 注册 runs 动作执行历史管理命令（list、show、clear、cancel）。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export function registerRunsCommands(program, context) {
+    const runsCmd = program
+        .command("runs")
+        .description("Inspect action execution history");
+    // runs list
+    runsCmd
+        .command("list [patterns...]")
+        .description("List recent execution records")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+        .option("-a, --action <actionId>", "Filter by action ID")
+        .option("-n, --limit <count>", "Maximum number of records to return", "20")
+        .option("-p, --profile <name>", "Query against a specific profile")
+        .option("-s, --server <url>", "Remote server URL")
+        .option("-t, --token <token>", "Auth token for remote server")
+        .option("--no-fallback", "Disable fallback to full list when no items match intent")
+        .option("--data-dir <path>", "Custom database storage directory")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action(async (patterns = [], rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const effectiveIntent = resolveIntent(options.intent, patterns);
+        const shouldFallback = options.fallback !== false;
+        const limit = Number.parseInt(options.limit, 10) || 20;
+        const scope = resolveLocalRunScope(options.package);
+        // 通过 Target 门面统一访问
+        await withTarget(options, context, async (target, resolved) => {
+            const records = await target.listRuns({
+                packageId: scope.projConfig?.id || options.package,
+                actionId: options.action,
+                intent: effectiveIntent,
+                limit,
+            });
+            // 若处于本地无项目环境且无任何软链接包，则直接输出友好提示
+            if (resolved.type === "local" && !scope.targetPackageRoot) {
+                const linked = listLinkedPackages(context?.customHome);
+                if (linked.length === 0) {
+                    renderResult([], {
+                        json: options.json,
+                        envelope: options.envelope,
+                        humanFormatter: () => "No ActionDock project in current directory, and no packages linked.",
+                        context,
+                    });
+                    return;
+                }
+            }
+            const filterRes = filterWithFallbackInfo(records, effectiveIntent, [(r) => r.id, (r) => r.actionId, (r) => r.packageId, (r) => r.status, (r) => r.error?.message], shouldFallback);
+            const capped = filterRes.items.slice(0, limit);
+            renderResult(capped, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => {
+                    let title = "Execution Runs";
+                    if (resolved.type === "remote") {
+                        title = `Execution Runs on remote server ${resolved.serverUrl}${resolved.profileName ? ` (Profile: ${resolved.profileName})` : ""}`;
+                    }
+                    else if (scope.projConfig) {
+                        title = `Execution Runs in ${scope.projConfig.name} (${scope.projConfig.id})`;
+                    }
+                    else {
+                        title = "Execution Runs (Linked Packages)";
+                    }
+                    return renderRunsList(capped, title, filterRes.isFallback, effectiveIntent);
+                },
+                context,
+            });
+        }, { localRoot: scope.targetPackageRoot, scanLinkedPackages: true });
+    });
+    // runs show <id>
+    runsCmd
+        .command("show <id>")
+        .description("Show details of a specific execution run")
+        .option("-p, --profile <name>", "Query run against a specific profile")
+        .option("-s, --server <url>", "Remote server URL")
+        .option("-t, --token <token>", "Auth token for remote server")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("--data-dir <path>", "Custom database storage directory")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action(async (id, rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        if (!id) {
+            throw new ArgumentError("Run ID is required");
+        }
+        const scope = resolveLocalRunScope(options.package);
+        // 通过 Target 门面统一查询
+        await withTarget(options, context, async (target, resolved) => {
+            const run = await target.getRun(id);
+            if (!run) {
+                if (resolved.type === "remote") {
+                    throw new ExecutionError(`Run record '${id}' not found on remote server`);
+                }
+                else if (options.package) {
+                    throw new ExecutionError(`Run record '${id}' not found in package '${scope.projConfig?.id || options.package}'`);
+                }
+                else {
+                    throw new ExecutionError(`Run record '${id}' not found in current project or any linked packages`);
+                }
+            }
+            renderResult(run, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => renderRunDetail(run),
+                context,
+            });
+        }, { localRoot: scope.targetPackageRoot, scanLinkedPackages: true });
+    });
+    // runs cancel
+    runsCmd
+        .command("cancel <id>")
+        .description("Cancel a running action execution on a remote server")
+        .option("-p, --profile <name>", "Execute cancel against a specific profile")
+        .option("-s, --server <url>", "Remote server URL")
+        .option("-t, --token <token>", "Auth token for remote server")
+        .option("-r, --reason <reason>", "Reason for cancellation")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action(async (id, rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        if (!id) {
+            throw new ArgumentError("Run ID is required for cancel");
+        }
+        const resolved = resolveTarget({
+            profile: options.profile,
+            server: options.server,
+            token: options.token,
+        }, context?.customHome);
+        if (resolved.type === "local") {
+            throw new ArgumentError("'ad runs cancel' is only supported for remote execution targets. Use --profile <name> or --server <url>.");
+        }
+        await withRemoteTarget(options, context, async (target) => {
+            const result = await target.cancelRun(id, options.reason);
+            const isErrorOutcome = result.outcome === "not_found" || result.outcome === "not_owner";
+            renderResult(result, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => {
+                    if (result.outcome === "not_found") {
+                        return `Error: Run record '${id}' not found on remote server.`;
+                    }
+                    if (result.outcome === "not_owner") {
+                        return `Error: Cannot cancel run '${id}': not the owner.`;
+                    }
+                    return `Run '${id}' cancellation requested (Status: ${result.status || result.outcome}).`;
+                },
+                context,
+            });
+            if (isErrorOutcome) {
+                process.exitCode = 1;
+            }
+        });
+    });
+    // runs clear
+    runsCmd
+        .command("clear")
+        .description("Clear execution run records")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("-a, --action <actionId>", "Filter by action ID")
+        .option("-p, --profile <name>", "Target profile")
+        .option("-s, --server <url>", "Remote server URL")
+        .option("-t, --token <token>", "Auth token for remote server")
+        .option("--data-dir <path>", "Custom database storage directory")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action(async (rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        let targetPackageRoot;
+        let packageId = options.package;
+        if (!options.profile && !options.server) {
+            if (options.package) {
+                const root = resolvePackageRoot(options.package);
+                if (!root) {
+                    throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
+                }
+                targetPackageRoot = root;
+            }
+            else {
+                targetPackageRoot = findProjectRoot() || undefined;
+                if (!targetPackageRoot) {
+                    throw new ArgumentError("Not in an ActionDock project. Please specify -P, --package <id> or cd into a project directory.");
+                }
+            }
+            try {
+                packageId = loadProjectConfig(targetPackageRoot).id;
+            }
+            catch {
+                // 清单损坏时保留原始 -P 参数作为包标识
+            }
+        }
+        await withTarget(options, context, async (target, resolved) => {
+            const count = target.clearRuns
+                ? await target.clearRuns({ packageId, actionId: options.action })
+                : 0;
+            const payload = { ok: true, clearedCount: count };
+            renderResult(payload, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => resolved.type === "remote"
+                    ? `Cleared ${count} execution run(s) on remote server.`
+                    : `Cleared ${count} execution run(s) in package '${packageId}'.`,
+                context,
+            });
+        }, { localRoot: targetPackageRoot });
+    });
+}

package/dist/commands/serve.d.ts

@@ -1,2 +1,9 @@
-import type { Command } from "commander";
-export declare function registerServeCommand(program: Command): void;
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册 serve HTTP 服务启动命令。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export declare function registerServeCommand(program: Command, context?: CliContext): void;