@actiondock/cli 2.0.11 → 2.2.0

package/dist/commands/profile.js

@@ -0,0 +1,253 @@
+import { addProfile, checkRemoteHealth, filterWithFallbackInfo, getProfile, listProfiles, loadProfiles, maskSecretValue, removeProfile, resolveProfileToken, resolveTarget, toSnakeUpperCase, useProfile, } from "@actiondock/core";
+import { ArgumentError, CliError, ExecutionError, } from "../errors.js";
+import { renderResult, writeStdout } from "../renderer.js";
+import { getEffectiveOptions, resolveFallbackStrategy, resolveIntent } from "../utils/index.js";
+export function registerProfileCommands(program) {
+    const profileCmd = program
+        .command("profile")
+        .description("Manage multi-cloud and remote execution profiles");
+    // ad profile list
+    profileCmd
+        .command("list [patterns...]")
+        .description("List all configured profiles")
+        .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+        .option("--reveal, --show-secrets", "Reveal plain text values for tokens")
+        .option("--fallback", "Enable fallback to full list when no items match intent")
+        .option("--no-fallback", "Disable fallback to full list when no items match intent")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action((patterns, rawOptions, cmd) => {
+        try {
+            const options = getEffectiveOptions(rawOptions, cmd);
+            const effectiveIntent = resolveIntent(options.intent, patterns);
+            const { isMachine, shouldFallback } = resolveFallbackStrategy(options);
+            const reveal = Boolean(options.reveal || options.showSecrets);
+            const list = listProfiles();
+            const enriched = list.map((p) => {
+                const resolved = resolveProfileToken(p.name, p.entry);
+                return {
+                    name: p.name,
+                    isCurrent: p.isCurrent,
+                    serverUrl: p.entry.serverUrl,
+                    description: p.entry.description || "",
+                    tokenEnv: p.entry.tokenEnv,
+                    tokenConfigured: resolved.source !== "none",
+                    tokenSource: resolved.source,
+                    token: reveal ? resolved.token : (resolved.token ? maskSecretValue(resolved.token) : undefined),
+                };
+            });
+            const filterRes = filterWithFallbackInfo(enriched, effectiveIntent, [(p) => p.name, (p) => p.serverUrl, (p) => p.description, (p) => p.tokenSource], shouldFallback);
+            if (filterRes.isFallback && isMachine) {
+                renderResult({ items: filterRes.items, isFallback: true, matchedCount: 0 }, { json: options.json, envelope: options.envelope });
+                return;
+            }
+            renderResult(filterRes.items, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => {
+                    const lines = ["ActionDock Execution Profiles:\n"];
+                    if (filterRes.isFallback && effectiveIntent) {
+                        lines.push(`(No profiles matched intent '${effectiveIntent}', showing all profiles)\n`);
+                    }
+                    for (const item of filterRes.items) {
+                        const currentMarker = item.isCurrent ? "* " : "  ";
+                        let tokenInfo = "";
+                        if (item.tokenSource === "tokenEnv") {
+                            tokenInfo = ` [token: env(${item.tokenEnv})]`;
+                        }
+                        else if (item.tokenSource === "profileEnv") {
+                            tokenInfo = ` [token: env(ACTIONDOCK_${toSnakeUpperCase(item.name)}_TOKEN)]`;
+                        }
+                        else if (item.tokenSource === "profile") {
+                            tokenInfo = ` [token: stored in profile]`;
+                        }
+                        else if (item.tokenSource === "globalEnv") {
+                            tokenInfo = ` [token: env(ACTIONDOCK_TOKEN)]`;
+                        }
+                        if (reveal && item.token) {
+                            tokenInfo += ` = ${item.token}`;
+                        }
+                        const desc = item.description ? ` - ${item.description}` : "";
+                        lines.push(`${currentMarker}${item.name.padEnd(20)} ${item.serverUrl}${tokenInfo}${desc}`);
+                    }
+                    lines.push("\nUse 'ad profile use <name>' to switch or 'ad run <action> --profile <name>' to execute on a specific target.");
+                    return lines.join("\n");
+                },
+            });
+        }
+        catch (err) {
+            if (err instanceof ArgumentError || err instanceof CliError)
+                throw err;
+            throw new ExecutionError(err.message);
+        }
+    });
+    // ad profile add <name>
+    profileCmd
+        .command("add <name>")
+        .description("Add or update a remote execution profile")
+        .requiredOption("-s, --server <url>", "Remote ActionDock server URL (e.g. http://1.2.3.4:5177)")
+        .option("-t, --token <token>", "Authentication token for the remote server (deprecated; prefer --token-env)")
+        .option("--token-env <env>", "Environment variable name containing the authentication token")
+        .option("-d, --desc <description>", "Description of this profile/machine")
+        .action((name, options) => {
+        try {
+            if (options.token) {
+                console.warn("Warning: storing tokens directly in profiles.json is deprecated. Use --token-env or standard environment variables (e.g. ACTIONDOCK_<PROFILE>_TOKEN) instead.");
+            }
+            addProfile(name, {
+                serverUrl: options.server,
+                token: options.token,
+                tokenEnv: options.tokenEnv,
+                description: options.desc,
+            });
+            writeStdout(`[OK] Profile '${name}' configured for server: ${options.server}`);
+        }
+        catch (err) {
+            throw new ExecutionError(err.message);
+        }
+    });
+    // ad profile use <name>
+    profileCmd
+        .command("use <name>")
+        .description("Switch active default profile")
+        .action((name) => {
+        try {
+            useProfile(name);
+            writeStdout(`[OK] Active profile switched to '${name}'`);
+        }
+        catch (err) {
+            throw new ExecutionError(err.message);
+        }
+    });
+    // ad profile show [name]
+    profileCmd
+        .command("show [name]")
+        .description("Display details of a profile (defaults to active profile)")
+        .option("--reveal, --show-secrets", "Reveal plain text values for tokens")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action((name, rawOptions, cmd) => {
+        try {
+            const options = getEffectiveOptions(rawOptions, cmd);
+            const config = loadProfiles();
+            const targetName = name || config.currentProfile || "local";
+            const entry = getProfile(targetName);
+            const reveal = Boolean(options.reveal || options.showSecrets);
+            if (!entry && targetName !== "local") {
+                throw new ArgumentError(`Profile '${targetName}' not found.`);
+            }
+            const resolved = resolveProfileToken(targetName, entry);
+            const displayToken = reveal
+                ? resolved.token
+                : (resolved.token ? maskSecretValue(resolved.token) : undefined);
+            const data = {
+                name: targetName,
+                isCurrent: config.currentProfile === targetName,
+                serverUrl: entry?.serverUrl || "local",
+                tokenConfigured: resolved.source !== "none",
+                tokenSource: resolved.source,
+                tokenEnv: entry?.tokenEnv,
+                token: displayToken,
+                description: entry?.description || "",
+            };
+            renderResult(data, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => {
+                    const lines = [];
+                    lines.push(`Profile:      ${data.name}${data.isCurrent ? " (Active)" : ""}`);
+                    lines.push(`Server URL:   ${data.serverUrl}`);
+                    let sourceDetail = "None";
+                    if (data.tokenSource === "tokenEnv") {
+                        sourceDetail = `Environment Variable ($${data.tokenEnv})`;
+                    }
+                    else if (data.tokenSource === "profileEnv") {
+                        sourceDetail = `Profile Environment Variable ($ACTIONDOCK_${toSnakeUpperCase(data.name)}_TOKEN)`;
+                    }
+                    else if (data.tokenSource === "profile") {
+                        sourceDetail = "Stored in profiles.json (Deprecated)";
+                    }
+                    else if (data.tokenSource === "globalEnv") {
+                        sourceDetail = "Global Environment Variable ($ACTIONDOCK_TOKEN)";
+                    }
+                    lines.push(`Auth Source:  ${sourceDetail}`);
+                    if (data.tokenConfigured) {
+                        lines.push(`Token Value:  ${data.token}`);
+                    }
+                    if (data.description) {
+                        lines.push(`Description:  ${data.description}`);
+                    }
+                    return lines.join("\n");
+                },
+            });
+        }
+        catch (err) {
+            if (err instanceof ArgumentError || err instanceof CliError) {
+                throw err;
+            }
+            throw new ExecutionError(err.message);
+        }
+    });
+    // ad profile rm / remove <name>
+    profileCmd
+        .command("rm <name>")
+        .alias("remove")
+        .description("Remove a profile")
+        .action((name) => {
+        try {
+            if (name === "local") {
+                throw new ExecutionError("Cannot remove built-in 'local' profile");
+            }
+            const removed = removeProfile(name);
+            if (!removed) {
+                throw new ExecutionError(`Profile '${name}' not found`);
+            }
+            writeStdout(`[OK] Profile '${name}' removed`);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                throw err;
+            }
+            throw new ExecutionError(err.message);
+        }
+    });
+    // ad profile test [name]
+    profileCmd
+        .command("test [name]")
+        .description("Test connection latency and health of a profile")
+        .option("--json", "Output as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .action(async (name, rawOptions, cmd) => {
+        try {
+            const options = getEffectiveOptions(rawOptions, cmd);
+            const target = resolveTarget({ profile: name });
+            if (target.type === "local") {
+                renderResult({ ok: true, type: "local", message: "Local execution" }, {
+                    json: options.json,
+                    envelope: options.envelope,
+                    humanFormatter: () => `Target profile '${target.profileName || "local"}' is local (runs in local runtime).`,
+                });
+                return;
+            }
+            const health = await checkRemoteHealth(target.serverUrl, target.token);
+            renderResult(health, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => {
+                    if (health.ok) {
+                        return `[OK] Connected to ${target.serverUrl} (${health.latencyMs}ms) - Version: ${health.version}, Status: ${health.status}`;
+                    }
+                    return `[FAIL] Connection to ${target.serverUrl} failed (${health.latencyMs}ms): ${health.error}`;
+                },
+            });
+            if (!health.ok) {
+                process.exitCode = 1;
+            }
+        }
+        catch (err) {
+            if (err instanceof ArgumentError || err instanceof CliError)
+                throw err;
+            throw new ExecutionError(err.message);
+        }
+    });
+}

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

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