@actiondock/cli 2.0.12 → 2.2.1

package/dist/commands/mcp.js

@@ -0,0 +1,173 @@
+import { resolve } from "node:path";
+import { findProjectRoot, formatHostForUrl, loadProjectConfig, parseDuration } from "@actiondock/core";
+import { ArgumentError, ExecutionError } from "../errors.js";
+import { writeStdout } from "../renderer.js";
+import { getEffectiveOptions, parseByteSize, parseListOption } from "../utils/index.js";
+/**
+ * 注册 mcp 命令（STDIO 与 HTTP 传输服务模式）。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export function registerMcpCommands(program, context) {
+    const mcpCommand = program
+        .command("mcp")
+        .description("Model Context Protocol (MCP) server for ActionDock Actions (STDIO default)")
+        .option("-d, --dir <path>", "Project root directory or directories (can be specified multiple times or comma-separated)", parseListOption, [])
+        .option("--package <package-id>", "Specific linked package ID(s) to serve (can be specified multiple times or comma-separated)", parseListOption, [])
+        .option("--all", "Serve all linked packages from global registry")
+        .option("--timeout <duration>", "Execution timeout (e.g. 30s, 5m, 500ms)")
+        .option("--allow-insecure-http", "Allow insecure HTTP connections with auth token (INSECURE)")
+        .action(async (rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        let timeoutMs;
+        if (options.timeout) {
+            try {
+                timeoutMs = parseDuration(options.timeout);
+            }
+            catch (err) {
+                throw new ArgumentError(`Invalid timeout format: ${err.message}`);
+            }
+        }
+        const projectRoots = options.dir && options.dir.length > 0
+            ? options.dir.map((d) => resolve(d))
+            : undefined;
+        const packageIds = options.package && options.package.length > 0 ? options.package : undefined;
+        const all = Boolean(options.all);
+        try {
+            const { startMcpStdio } = await import("@actiondock/mcp");
+            await startMcpStdio({
+                projectRoots,
+                packageIds,
+                all,
+                timeoutMs,
+            });
+        }
+        catch (err) {
+            throw new ExecutionError(`Failed to start MCP STDIO server: ${err.message}`, err);
+        }
+    });
+    mcpCommand
+        .command("serve")
+        .description("Start the ActionDock MCP server over HTTP transport")
+        .option("-p, --port <port>", "Port to listen on (default: 5178)", "5178")
+        .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("--token-env <env>", "Environment variable name containing the authentication token")
+        .option("--allow-insecure-no-auth", "Allow non-loopback host binding without authentication token (INSECURE)")
+        .option("--allow-insecure-http", "Allow insecure HTTP connections with auth token (INSECURE)")
+        .option("--allow-query-token", "Allow passing authentication token via URL query parameter (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("-d, --dir <path>", "Project root directory or directories (can be specified multiple times or comma-separated)", parseListOption, [])
+        .option("--package <package-id>", "Specific linked package ID(s) to serve (can be specified multiple times or comma-separated)", parseListOption, [])
+        .option("--all", "Serve all linked packages from global registry")
+        .option("--timeout <duration>", "Execution timeout (e.g. 30s, 5m, 500ms)")
+        .action(async (rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const port = parseInt(options.port, 10) || 5178;
+        const host = options.host || "127.0.0.1";
+        const token = options.token ||
+            (options.tokenEnv && typeof process !== "undefined" ? process.env?.[options.tokenEnv] : undefined) ||
+            (typeof process !== "undefined" ? process.env?.ACTIONDOCK_TOKEN : undefined);
+        const allowInsecureNoAuth = Boolean(options.allowInsecureNoAuth);
+        const allowInsecureHttp = Boolean(options.allowInsecureHttp);
+        const allowQueryToken = Boolean(options.allowQueryToken);
+        const corsOrigins = options.corsOrigin && options.corsOrigin.length > 0 ? options.corsOrigin : undefined;
+        let maxBodyBytes;
+        if (options.maxBody) {
+            try {
+                maxBodyBytes = parseByteSize(options.maxBody);
+            }
+            catch (err) {
+                throw new ArgumentError(`Invalid max-body format: ${err.message}`);
+            }
+        }
+        let timeoutMs;
+        if (options.timeout) {
+            try {
+                timeoutMs = parseDuration(options.timeout);
+            }
+            catch (err) {
+                throw new ArgumentError(`Invalid timeout format: ${err.message}`);
+            }
+        }
+        const projectRoots = options.dir && options.dir.length > 0
+            ? options.dir.map((d) => resolve(d))
+            : undefined;
+        const packageIds = options.package && options.package.length > 0 ? options.package : undefined;
+        const all = Boolean(options.all);
+        let targetDescription = "ActionDock MCP Server";
+        if (all) {
+            targetDescription = "All Linked Packages (Global Registry Mode)";
+        }
+        else if (packageIds && packageIds.length > 1) {
+            targetDescription = `Packages: ${packageIds.join(", ")}`;
+        }
+        else if (projectRoots && projectRoots.length > 1) {
+            targetDescription = `Directories: ${projectRoots.join(", ")}`;
+        }
+        else if (projectRoots && projectRoots.length === 1) {
+            try {
+                const config = loadProjectConfig(projectRoots[0]);
+                targetDescription = `${config.name} (${config.id})`;
+            }
+            catch {
+                targetDescription = projectRoots[0];
+            }
+        }
+        else if (packageIds && packageIds.length === 1) {
+            targetDescription = `Package: ${packageIds[0]}`;
+        }
+        else {
+            const currentRoot = findProjectRoot(process.cwd());
+            if (currentRoot) {
+                try {
+                    const config = loadProjectConfig(currentRoot);
+                    targetDescription = `${config.name} (${config.id})`;
+                }
+                catch {
+                    targetDescription = currentRoot;
+                }
+            }
+        }
+        try {
+            const { startMcpHttpServer } = await import("@actiondock/mcp");
+            const server = await startMcpHttpServer({
+                port,
+                host,
+                token,
+                allowInsecureNoAuth,
+                allowInsecureHttp,
+                allowQueryToken,
+                corsOrigins,
+                maxBodyBytes,
+                projectRoots,
+                packageIds,
+                all,
+                timeoutMs,
+            });
+            const displayHost = formatHostForUrl(host);
+            const actualMcpHost = formatHostForUrl(host === "0.0.0.0" ? "127.0.0.1" : host);
+            writeStdout(`\n======================================================`, context);
+            writeStdout(`  ActionDock 2.0 MCP HTTP Server`, context);
+            writeStdout(`======================================================`, context);
+            writeStdout(`  * Listening on:    http://${displayHost}:${server.port}`, context);
+            writeStdout(`  * MCP Endpoint:    http://${actualMcpHost}:${server.port}/mcp`, context);
+            writeStdout(`  * Target:          ${targetDescription}`, context);
+            writeStdout(`  * Authentication:  ${token ? "Bearer Token Enabled" : "Disabled (Local)"}`, context);
+            writeStdout(`  * CORS Origins:    ${corsOrigins ? corsOrigins.join(", ") : "Disabled (Default)"}`, context);
+            writeStdout(`======================================================\n`, context);
+            writeStdout(`Press Ctrl+C to terminate.\n`, context);
+            const stopSignalHandler = () => {
+                writeStdout("\nStopping MCP HTTP server...", context);
+                server.stop();
+            };
+            process.once("SIGINT", stopSignalHandler);
+            process.once("SIGTERM", stopSignalHandler);
+        }
+        catch (err) {
+            throw new ExecutionError(`Failed to start ActionDock MCP HTTP server: ${err.message}`, err);
+        }
+    });
+}

package/dist/commands/new.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册顶层 new 脚手架命令（new action, new playbook）。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export declare function registerNewCommands(program: Command, context?: CliContext): void;

package/dist/commands/new.js

@@ -0,0 +1,33 @@
+import { handleActionCreate } from "./action/create.js";
+import { handlePlaybookCreate } from "./playbook.js";
+/**
+ * 注册顶层 new 脚手架命令（new action, new playbook）。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export function registerNewCommands(program, context) {
+    const newCmd = program
+        .command("new")
+        .description("Scaffold a new Action or Playbook in current project");
+    // new action <id>
+    newCmd
+        .command("action <id>")
+        .alias("create")
+        .description("Scaffold a new Action definition file")
+        .option("-d, --desc <description>", "Action description")
+        .option("-f, --file <filePath>", "Target file path relative to actions dir")
+        .action(async (id, options) => {
+        await handleActionCreate(id, options, context);
+    });
+    // new playbook <id>
+    newCmd
+        .command("playbook <id>")
+        .description("Scaffold a new Playbook markdown file")
+        .option("-d, --desc <description>", "Playbook description")
+        .option("-a, --actions <actions...>", "Referenced action IDs")
+        .option("-f, --file <filePath>", "Target file path relative to playbooks dir")
+        .action((id, options) => {
+        handlePlaybookCreate(id, options, context);
+    });
+}

package/dist/commands/pack.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+export declare function registerPackCommand(program: Command, context?: CliContext): void;

package/dist/commands/pack.js

@@ -0,0 +1,63 @@
+import { findProjectRoot, resolvePackageRoot } from "@actiondock/core";
+import { ExecutionError } from "../errors.js";
+import { renderResult, writeStdout } from "../renderer.js";
+import { getEffectiveOptions } from "../utils/index.js";
+export function registerPackCommand(program, context) {
+    program
+        .command("pack")
+        .description("Pack Action package into a standard npm tarball (.tgz) for distribution")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("-o, --out <path>", "Output directory for the .tgz package")
+        .option("--dry-run", "Validate and show package summary without creating .tgz")
+        .option("--json", "Output as JSON")
+        .action(async (rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const root = options.package
+            ? resolvePackageRoot(options.package)
+            : findProjectRoot();
+        if (!root) {
+            if (options.package) {
+                throw new ExecutionError(`Package '${options.package}' not found in linked packages or path`);
+            }
+            throw new ExecutionError("Not in an ActionDock project (actiondock.json not found).\nPlease specify -P, --package <id> or cd into a project directory.");
+        }
+        const isMachine = Boolean(options.json || options.envelope);
+        if (!isMachine && !options.dryRun) {
+            writeStdout("Packing Action package...");
+        }
+        let result;
+        try {
+            const { packProject } = await import("@actiondock/builder");
+            result = await packProject({
+                projectRoot: root,
+                outDir: options.out,
+                dryRun: options.dryRun,
+            });
+        }
+        catch (err) {
+            throw new ExecutionError(`Pack failed: ${err.message}`);
+        }
+        renderResult(result, {
+            json: isMachine,
+            envelope: options.envelope,
+            humanFormatter: () => {
+                const lines = [];
+                if (options.dryRun) {
+                    lines.push(`[OK] Pack dry-run passed for ${result.packageId} (v${result.version})`);
+                    lines.push(`  Tarball Name: ${result.tarballName}`);
+                    lines.push(`  Actions:      ${result.manifestSummary.actions.join(", ")}`);
+                    lines.push(`  Files Count:  ${result.manifestSummary.filesCount}`);
+                    lines.push("  Notice: Dry-run mode enabled, no tarball was generated.");
+                    return lines.join("\n");
+                }
+                lines.push(`[OK] Successfully packed ${result.packageId} (v${result.version})`);
+                lines.push(`  Tarball:   ${result.tarballPath}`);
+                lines.push(`  Size:      ${result.sizeBytes} bytes`);
+                lines.push(`  SHA-256:   ${result.sha256}`);
+                lines.push(`  Actions:   ${result.manifestSummary.actions.join(", ")}`);
+                return lines.join("\n");
+            },
+            context,
+        });
+    });
+}

package/dist/commands/playbook.d.ts

@@ -1,6 +1,10 @@
 import { Command } from "commander";
+import type { CliContext } from "../types.js";
 /**
- * 注册 Playbook 命令集合。
- * 委托 list, show, validate 至 @actiondock/runtime-cli，保留开发者专用的 create 命令。
+ * 注册 Playbook 命令集合（list, show, validate, create）。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
  */
-export declare function registerPlaybookCommands(program: Command): void;
+export declare function registerPlaybookCommands(program: Command, context?: CliContext): void;
+export declare function handlePlaybookCreate(id: string, options: any, context?: CliContext): void;