@actiondock/cli 2.0.11 → 2.2.0

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

@@ -0,0 +1,9 @@
+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;

package/dist/commands/serve.js

@@ -0,0 +1,129 @@
+import { resolve } from "node:path";
+import { findProjectRoot, formatHostForUrl, loadProjectConfig, startActionDockServer } from "@actiondock/core";
+import { createActionDockMcpServer } from "@actiondock/mcp";
+import { createMcpHandler } from "@modelcontextprotocol/server";
+import { ArgumentError, ExecutionError } from "../errors.js";
+import { writeStderr, writeStdout } from "../renderer.js";
+import { getEffectiveOptions, parseByteSize } from "../utils/index.js";
+/**
+ * 注册 serve HTTP 服务启动命令。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export function registerServeCommand(program, context) {
+    program
+        .command("serve")
+        .description("Start the ActionDock lightweight HTTP Runner server for remote execution")
+        .option("-p, --port <port>", "Port to listen on (default: 5177)", "5177")
+        .option("-H, --host <host>", "Host address to bind to (default: 127.0.0.1)", "127.0.0.1")
+        .option("-t, --token <token>", "Authentication token for securing the endpoint (or set ACTIONDOCK_TOKEN)")
+        .option("--allow-insecure-no-auth", "Allow non-loopback host binding without authentication token (INSECURE)")
+        .option("--cors-origin <origin>", "Allowed CORS origin (can be specified multiple times)", (val, prev = []) => [...prev, val], [])
+        .option("--max-body <size>", "Maximum allowed JSON request body size (e.g. 1mb, 500kb)", "1mb")
+        .option("--expose-debug-info", "Expose project root path in health and info responses")
+        .option("--no-mcp", "Disable unified MCP protocol endpoint at /mcp")
+        .option("--allow-query-token", "Allow passing authentication token via URL query parameter (?token=xxx)")
+        .option("-d, --dir <path>", "Project root directory (default: current working directory)")
+        .action(async (rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const port = parseInt(options.port, 10) || 5177;
+        const host = options.host || "127.0.0.1";
+        const token = options.token || (typeof process !== "undefined" ? process.env?.ACTIONDOCK_TOKEN : undefined);
+        const allowInsecureNoAuth = Boolean(options.allowInsecureNoAuth);
+        const allowQueryToken = Boolean(options.allowQueryToken);
+        const corsOrigins = options.corsOrigin && options.corsOrigin.length > 0 ? options.corsOrigin : undefined;
+        const exposeDebugInfo = Boolean(options.exposeDebugInfo);
+        let maxBodyBytes;
+        if (options.maxBody) {
+            try {
+                maxBodyBytes = parseByteSize(options.maxBody);
+            }
+            catch (err) {
+                throw new ArgumentError(`Invalid max-body format: ${err.message}`);
+            }
+        }
+        const projectRoot = options.dir
+            ? resolve(options.dir)
+            : findProjectRoot(process.cwd());
+        let projectName = "Global Registry Mode";
+        if (projectRoot) {
+            try {
+                const config = loadProjectConfig(projectRoot);
+                projectName = `${config.name} (${config.id})`;
+            }
+            catch {
+                // 降级处理
+            }
+        }
+        let mcpHandler;
+        const enableMcp = options.mcp !== false;
+        if (enableMcp) {
+            // MCP 处理器创建失败时直接终止启动，避免横幅宣称不存在的端点
+            try {
+                const handler = createMcpHandler(() => {
+                    return createActionDockMcpServer({
+                        projectRoot: projectRoot || undefined,
+                    });
+                }, {
+                    onerror: (err) => {
+                        writeStderr(`[MCP HTTP Error] ${err?.message || String(err)}`, context);
+                    },
+                });
+                mcpHandler = async (req) => {
+                    return handler.fetch(req);
+                };
+            }
+            catch (err) {
+                throw new ExecutionError(`Failed to initialize MCP endpoint: ${err?.message || String(err)}`, err);
+            }
+        }
+        try {
+            const server = await startActionDockServer({
+                port,
+                host,
+                token,
+                allowInsecureNoAuth,
+                allowQueryToken,
+                corsOrigins,
+                maxBodyBytes,
+                exposeDebugInfo,
+                enableMcp,
+                mcpHandler,
+                projectRoot: projectRoot || undefined,
+            });
+            const displayHost = formatHostForUrl(host);
+            const actualEndpointHost = formatHostForUrl(host === "0.0.0.0" ? "127.0.0.1" : host);
+            writeStdout(`\n======================================================`, context);
+            writeStdout(`  ActionDock 2.0 HTTP Runner Server`, context);
+            writeStdout(`======================================================`, context);
+            writeStdout(`  * Listening on:    http://${displayHost}:${server.port}`, context);
+            writeStdout(`  * Project:         ${projectName}`, context);
+            if (projectRoot && exposeDebugInfo) {
+                writeStdout(`  * Root Path:       ${projectRoot}`, context);
+            }
+            const authDesc = token
+                ? (allowQueryToken ? "Bearer Token / Query Token Enabled" : "Bearer Token Enabled (Query Token Disabled)")
+                : "Disabled (Public/Local)";
+            writeStdout(`  * Authentication:  ${authDesc}`, context);
+            writeStdout(`  * CORS Origins:    ${corsOrigins ? corsOrigins.join(", ") : "Disabled (Default)"}`, context);
+            writeStdout(`  * Max Body Size:   ${options.maxBody || "1mb"}`, context);
+            writeStdout(`  * Health Endpoint: http://${actualEndpointHost}:${server.port}/api/v1/health`, context);
+            if (enableMcp) {
+                writeStdout(`  * MCP Endpoint:    http://${actualEndpointHost}:${server.port}/mcp`, context);
+            }
+            writeStdout(`======================================================\n`, context);
+            writeStdout(`Server is ready to accept remote requests.`, context);
+            writeStdout(`Press Ctrl+C to terminate.\n`, context);
+            const stopSignalHandler = () => {
+                writeStdout("\nStopping ActionDock server...", context);
+                server.stop();
+            };
+            process.once("SIGINT", stopSignalHandler);
+            process.once("SIGTERM", stopSignalHandler);
+        }
+        catch (err) {
+            throw new ExecutionError(`Failed to start ActionDock server: ${err.message}`, err);
+        }
+    });
+}

package/dist/commands/state-list.d.ts

@@ -0,0 +1,24 @@
+import type { ActionDockTarget } from "@actiondock/core";
+import type { CliContext } from "../types.js";
+/**
+ * 状态键列表渲染参数视图。
+ */
+export interface StateListRenderArgs {
+    target: ActionDockTarget;
+    actionId: string;
+    prefix: string;
+    options: any;
+    effectiveIntent?: string;
+    shouldFallback: boolean;
+    context?: CliContext;
+}
+/**
+ * 渲染单个项目作用域的状态键列表（含 --detail JSON 明细分支）。
+ */
+export declare function renderProjectScopedStateList(args: StateListRenderArgs & {
+    targetRoot: string;
+}): Promise<void>;
+/**
+ * 渲染全部链接包聚合的状态键列表（跳过磁盘失效与清单损坏的链接项）。
+ */
+export declare function renderLinkedPackagesStateList(args: StateListRenderArgs): Promise<void>;

package/dist/commands/state-list.js

@@ -0,0 +1,82 @@
+import { filterWithFallbackInfo, listLinkedPackages, loadProjectConfig, } from "@actiondock/core";
+import { existsSync } from "node:fs";
+import { renderResult, renderStateList } from "../renderer.js";
+/**
+ * 渲染单个项目作用域的状态键列表（含 --detail JSON 明细分支）。
+ */
+export async function renderProjectScopedStateList(args) {
+    const { target, targetRoot, actionId, prefix, options, effectiveIntent, shouldFallback, context } = args;
+    const projConfig = loadProjectConfig(targetRoot);
+    const allKeys = await target.listStateKeys(projConfig.id, actionId, {
+        namespace: options.namespace !== undefined ? options.namespace : null,
+        prefix,
+    });
+    if (options.detail && options.json) {
+        const entries = [];
+        for (const k of allKeys) {
+            const entry = await target.getState(projConfig.id, actionId, k, {
+                namespace: options.namespace,
+                detail: true,
+            });
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        const filterRes = filterWithFallbackInfo(entries, effectiveIntent, [(e) => e.fullKey, (e) => e.key, (e) => e.namespace], shouldFallback);
+        renderResult(filterRes.items, {
+            json: true,
+            envelope: options.envelope,
+            context,
+        });
+        return;
+    }
+    const filterRes = filterWithFallbackInfo(allKeys, effectiveIntent, [(k) => k], shouldFallback);
+    renderResult(filterRes.items, {
+        json: options.json,
+        envelope: options.envelope,
+        humanFormatter: () => renderStateList(filterRes.items, `${projConfig.name} (${projConfig.id})`, filterRes.isFallback, effectiveIntent),
+        context,
+    });
+}
+/**
+ * 渲染全部链接包聚合的状态键列表（跳过磁盘失效与清单损坏的链接项）。
+ */
+export async function renderLinkedPackagesStateList(args) {
+    const { target, actionId, prefix, options, effectiveIntent, shouldFallback, context } = args;
+    // 扫描所有链接的包状态
+    const linked = listLinkedPackages();
+    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 aggregatedKeys = [];
+    for (const pkg of linked) {
+        if (!existsSync(pkg.path))
+            continue;
+        try {
+            const config = loadProjectConfig(pkg.path);
+            const keys = await target.listStateKeys(config.id, actionId, {
+                namespace: options.namespace !== undefined ? options.namespace : null,
+                prefix,
+            });
+            for (const k of keys) {
+                aggregatedKeys.push(`${config.id}/${k}`);
+            }
+        }
+        catch {
+            // 单个链接包清单损坏或状态读取失败时跳过，继续聚合其余包
+        }
+    }
+    const filterRes = filterWithFallbackInfo(aggregatedKeys, effectiveIntent, [(k) => k], shouldFallback);
+    renderResult(filterRes.items, {
+        json: options.json,
+        envelope: options.envelope,
+        humanFormatter: () => renderStateList(filterRes.items, "Linked Packages State Store", filterRes.isFallback, effectiveIntent),
+        context,
+    });
+}

package/dist/commands/state.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册 state 状态管理命令（get、set、delete、clear、keys、list）。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export declare function registerStateCommands(program: Command, context?: CliContext): void;