@actiondock/cli 2.0.11 → 2.2.0

package/dist/commands/info.js

@@ -0,0 +1,210 @@
+import { fetchRemoteInfo, filterWithFallbackInfo, getRegistryStatus, resolvePackageRoot, resolveTarget, } from "@actiondock/core";
+import { ArgumentError, ExecutionError } from "../errors.js";
+import { projectDetailToJson, renderAggregatedPackages, renderProjectDetail, renderRegistryTree, renderResult, } from "../renderer.js";
+import { getProjectDetailInfo, scanLocalAggregatedPackages } from "../services/index.js";
+import { getEffectiveOptions, resolveFallbackStrategy, resolveIntent } from "../utils/index.js";
+/**
+ * 将远端信息响应归一为本地工程详情视图。
+ */
+function remoteInfoToDetail(remoteInfo) {
+    return {
+        id: remoteInfo.id,
+        name: remoteInfo.name || remoteInfo.id,
+        version: remoteInfo.version || "unknown",
+        description: remoteInfo.description,
+        projectRoot: remoteInfo.path || remoteInfo.projectRoot || "",
+        actionsDir: "remote",
+        playbooksDir: "remote",
+        actionsCount: remoteInfo.actionsCount || (remoteInfo.actions ? remoteInfo.actions.length : 0),
+        playbooksCount: remoteInfo.playbooksCount || (remoteInfo.playbooks ? remoteInfo.playbooks.length : 0),
+        actions: (remoteInfo.actionsDetail || remoteInfo.actions || []).map((a) => typeof a === "string" ? a : a.id),
+        playbooks: (remoteInfo.playbooksDetail || remoteInfo.playbooks || []).map((pb) => typeof pb === "string" ? pb : pb.id),
+        configDeclared: Object.keys(remoteInfo.configDeclared || {}),
+        configDef: remoteInfo.configDeclared,
+    };
+}
+/**
+ * 渲染工程详情输出（机器模式输出视图转换结果，人类模式渲染详情）。
+ */
+function renderProjectDetailOutput(detail, options) {
+    renderResult(projectDetailToJson(detail), {
+        json: options.json,
+        envelope: options.envelope,
+        humanFormatter: () => renderProjectDetail(detail),
+        context: options.context,
+    });
+}
+/**
+ * 注册 info 命令。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export function registerInfoCommand(program, context) {
+    program
+        .command("info [patterns...]")
+        .description("Display information about current project, linked package, or remote target")
+        .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("--tree", "Display packages in hierarchical tree view grouped by workspace")
+        .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("--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 information as JSON")
+        .option("--envelope", "Wrap JSON output in standard envelope")
+        .option("--data-dir <path>", "Custom database storage directory")
+        .action(async (patterns = [], rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const effectiveIntent = resolveIntent(options.intent, patterns);
+        const { isMachine, shouldFallback } = resolveFallbackStrategy(options);
+        const outOpts = { json: options.json, envelope: options.envelope, context };
+        // 远端服务目标分支
+        const target = resolveTarget({
+            profile: options.profile,
+            server: options.server,
+            token: options.token,
+        }, context?.customHome);
+        if (target.type === "remote") {
+            const remoteInfo = await fetchRemoteInfo(target.serverUrl, target.token, {
+                intent: effectiveIntent,
+                package: options.package,
+                tree: Boolean(options.tree),
+            });
+            if (isMachine) {
+                renderResult(remoteInfo, outOpts);
+                return;
+            }
+            if (remoteInfo.type === "tree" || (options.tree && remoteInfo.workspaces)) {
+                renderResult(remoteInfo, {
+                    humanFormatter: () => renderRegistryTree(remoteInfo),
+                    context,
+                });
+                return;
+            }
+            if (remoteInfo.type === "package_detail" || (remoteInfo.id && !remoteInfo.packages)) {
+                const detail = remoteInfoToDetail(remoteInfo);
+                renderResult(detail, {
+                    humanFormatter: () => renderProjectDetail(detail),
+                    context,
+                });
+                return;
+            }
+            const packages = remoteInfo.packages || remoteInfo.linkedPackages || [];
+            renderResult(packages, {
+                humanFormatter: () => renderAggregatedPackages(packages),
+                context,
+            });
+            return;
+        }
+        // 本地注册表树状图分支
+        if (options.tree) {
+            const status = getRegistryStatus(context?.customHome);
+            renderResult(status, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => renderRegistryTree(status),
+                context,
+            });
+            return;
+        }
+        // 显式指定 Package 参数分支
+        if (options.package) {
+            const directRoot = resolvePackageRoot(options.package);
+            if (directRoot) {
+                const detail = await getProjectDetailInfo(directRoot);
+                renderProjectDetailOutput(detail, outOpts);
+                return;
+            }
+            throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
+        }
+        // 扫描本地候选包（当前工程根目录 + 全局已链接包）
+        const { currentRoot, aggregated } = scanLocalAggregatedPackages(context);
+        // 无关键字过滤场景
+        if (!effectiveIntent) {
+            if (currentRoot) {
+                const detail = await getProjectDetailInfo(currentRoot);
+                renderProjectDetailOutput(detail, outOpts);
+                return;
+            }
+            if (aggregated.length === 0) {
+                renderResult({ linkedPackages: [] }, {
+                    ...outOpts,
+                    humanFormatter: () => "No ActionDock project in current directory, and no packages linked.\nRun 'ad link' inside an Action package to register it.",
+                });
+                return;
+            }
+            renderResult({ linkedPackages: aggregated }, {
+                ...outOpts,
+                humanFormatter: () => renderAggregatedPackages(aggregated),
+            });
+            return;
+        }
+        // 有关键字过滤场景：单一位置参数且非显式 --intent 时优先尝试包寻址
+        if (patterns.length === 1 && !options.intent) {
+            const directRoot = resolvePackageRoot(patterns[0]);
+            if (directRoot) {
+                const detail = await getProjectDetailInfo(directRoot);
+                renderProjectDetailOutput(detail, outOpts);
+                return;
+            }
+        }
+        if (aggregated.length === 0) {
+            if (isMachine) {
+                renderResult({ linkedPackages: [], matchedCount: 0, isFallback: false }, outOpts);
+                return;
+            }
+            throw new ExecutionError(`No ActionDock project or linked packages available to match '${effectiveIntent}'`);
+        }
+        const filterRes = filterWithFallbackInfo(aggregated, effectiveIntent, [
+            (p) => p.id,
+            (p) => p.name,
+            (p) => p.description,
+            (p) => p.path,
+            (p) => p.actions,
+            (p) => p.playbooks,
+        ], shouldFallback);
+        // 无匹配项
+        if (filterRes.matchedCount === 0) {
+            if (!filterRes.isFallback) {
+                if (isMachine) {
+                    renderResult({ linkedPackages: [], matchedCount: 0, isFallback: false }, outOpts);
+                    return;
+                }
+                throw new ExecutionError(`No packages matched intent '${effectiveIntent}'`);
+            }
+            // 回退模式：展示全部包并附带提示
+            if (isMachine) {
+                renderResult({ linkedPackages: filterRes.items, isFallback: true, matchedCount: 0 }, outOpts);
+                return;
+            }
+            renderResult({ linkedPackages: filterRes.items, isFallback: true, matchedCount: 0 }, {
+                ...outOpts,
+                humanFormatter: () => `(No linked packages matched intent '${effectiveIntent}', showing all packages)\n\n` +
+                    renderAggregatedPackages(filterRes.items),
+            });
+            return;
+        }
+        // 机器模式下搜索：稳定返回列表结构，不因为 matchedCount === 1 突变为详情
+        if (isMachine) {
+            renderResult({ linkedPackages: filterRes.items, matchedCount: filterRes.matchedCount, isFallback: false }, outOpts);
+            return;
+        }
+        // 人类终端交互：精确匹配单个包展开详情
+        if (filterRes.matchedCount === 1) {
+            const matchedPkg = filterRes.items[0];
+            const detail = await getProjectDetailInfo(matchedPkg.path);
+            renderProjectDetailOutput(detail, outOpts);
+            return;
+        }
+        // 匹配多个包：输出摘要列表
+        renderResult({ linkedPackages: filterRes.items }, {
+            ...outOpts,
+            humanFormatter: () => renderAggregatedPackages(filterRes.items, {
+                header: `ActionDock Linked Packages (${filterRes.matchedCount} matches for '${effectiveIntent}'):\n`,
+                showTip: true,
+            }),
+        });
+    });
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerInitCommand(program: Command): void;

package/dist/commands/init.js

@@ -0,0 +1,24 @@
+import { initProject } from "@actiondock/core";
+import { writeStdout } from "../renderer.js";
+import { ExecutionError } from "../errors.js";
+export function registerInitCommand(program) {
+    program
+        .command("init [directory]")
+        .description("Initialize a new ActionDock project")
+        .option("-i, --id <id>", "Project identifier")
+        .option("-n, --name <name>", "Project display name")
+        .option("-d, --desc <description>", "Project description")
+        .action((dir = ".", options) => {
+        try {
+            initProject(dir, {
+                id: options.id,
+                name: options.name,
+                description: options.desc,
+            });
+            writeStdout(`Successfully initialized ActionDock project in ${dir}`);
+        }
+        catch (err) {
+            throw new ExecutionError(err.message);
+        }
+    });
+}

package/dist/commands/link.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerLinkCommands(program: Command): void;

package/dist/commands/link.js

@@ -0,0 +1,71 @@
+import { linkPackage, pruneRegistry, unlinkPackage, } from "@actiondock/core";
+import { ExecutionError } from "../errors.js";
+import { writeStdout } from "../renderer.js";
+export function registerLinkCommands(program) {
+    // ad link [path]
+    program
+        .command("link [path]")
+        .option("-r, --recursive", "Recursively discover and link packages in subdirectories")
+        .description("Link local Action package(s) or workspace directory into global registry for instant cross-directory execution")
+        .action(async (targetPath, options) => {
+        try {
+            const result = await linkPackage(targetPath || process.cwd(), undefined, {
+                recursive: options.recursive,
+            });
+            if (result.isWorkspace) {
+                writeStdout(`[OK] Linked workspace '${result.path}' (${result.entries.length} package${result.entries.length > 1 ? "s" : ""}):`);
+                for (const e of result.entries) {
+                    writeStdout(`  - ${e.id} (v${e.version}) -> ${e.path}`);
+                }
+                writeStdout("[INFO] Sub-packages added to this workspace will be automatically discovered.");
+            }
+            else {
+                writeStdout(`[OK] Linked package '${result.id}' (v${result.version}) from ${result.path}`);
+            }
+        }
+        catch (err) {
+            throw new ExecutionError(err.message);
+        }
+    });
+    // ad unlink [id|path]
+    program
+        .command("unlink [identifier]")
+        .option("-p, --prune", "Automatically scan and prune any stale/missing paths from registry")
+        .description("Unlink a package, workspace, or prune stale entries from global developer registry")
+        .action(async (identifier, options) => {
+        try {
+            if (options.prune || identifier === "--prune") {
+                const result = await pruneRegistry();
+                const totalPruned = result.prunedPackages.length + result.prunedWorkspaces.length;
+                if (totalPruned === 0) {
+                    writeStdout("[OK] No stale registry entries found.");
+                }
+                else {
+                    writeStdout(`[OK] Pruned ${result.prunedWorkspaces.length} workspace(s) and ${result.prunedPackages.length} package(s) from registry.`);
+                    for (const ws of result.prunedWorkspaces) {
+                        writeStdout(`  - [workspace] ${ws.path}`);
+                    }
+                    for (const pkg of result.prunedPackages) {
+                        writeStdout(`  - [package] ${pkg.id} (${pkg.path})`);
+                    }
+                }
+                return;
+            }
+            const removed = await unlinkPackage(identifier || process.cwd());
+            if (removed) {
+                if (removed.type === "workspace") {
+                    writeStdout(`[OK] Unlinked workspace '${removed.path}' (${removed.packagesCount || 0} package${(removed.packagesCount || 0) > 1 ? "s" : ""} unlinked)`);
+                }
+                else {
+                    writeStdout(`[OK] Unlinked package '${removed.id}' (${removed.path})`);
+                }
+            }
+            else {
+                writeStdout(`Package or workspace '${identifier || process.cwd()}' was not linked in registry`);
+            }
+        }
+        catch (err) {
+            throw new ExecutionError(err.message);
+        }
+    });
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册顶层统一 list 命令：列出当前工程、已链接包或远端服务中的可用 Action。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export declare function registerListCommand(program: Command, context?: CliContext): void;

package/dist/commands/list.js

@@ -0,0 +1,77 @@
+import { filterWithFallbackInfo } from "@actiondock/core";
+import { ArgumentError } from "../errors.js";
+import { renderActionList, renderResult } from "../renderer.js";
+import { getEffectiveOptions, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, withTarget } from "../utils/index.js";
+/**
+ * 注册顶层统一 list 命令：列出当前工程、已链接包或远端服务中的可用 Action。
+ *
+ * @param program Commander 根程序对象
+ * @param context 命令行上下文
+ */
+export function registerListCommand(program, context) {
+    program
+        .command("list [patterns...]")
+        .description("List actions in current project, linked packages, or remote profile")
+        .option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match")
+        .option("-P, --package <id>", "Target package ID or path")
+        .option("-p, --profile <name>", "Query against a specific execution profile")
+        .option("-s, --server <url>", "Remote server URL")
+        .option("-t, --token <token>", "Auth token for remote server")
+        .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")
+        .option("--data-dir <path>", "Custom database storage directory")
+        .action(async (patterns = [], rawOptions, cmd) => {
+        const options = getEffectiveOptions(rawOptions, cmd);
+        const effectiveIntent = resolveIntent(options.intent, patterns);
+        const { isMachine, shouldFallback } = resolveFallbackStrategy(options);
+        // 目标拓扑解析（仅 local 分支需要包寻址）
+        const targetPackageRoot = resolveLocalPackageRoot(options.package);
+        if (options.package && !targetPackageRoot) {
+            throw new ArgumentError(`Package '${options.package}' not found in linked packages or path`);
+        }
+        // 通过 Target 门面统一获取 Action 列表
+        await withTarget(options, context, async (target, resolved) => {
+            let rawSummaries = await target.listActions();
+            // 若指定了目标包但本地未过滤，则精确匹配包标识
+            if (options.package && !options.profile && !options.server) {
+                rawSummaries = rawSummaries.filter((s) => s.id.startsWith(`${options.package}/`) ||
+                    s.packageId === options.package ||
+                    !s.id.includes("/"));
+            }
+            const rawList = rawSummaries.map((s) => {
+                let id = s.id;
+                if (targetPackageRoot || options.package) {
+                    const pkgId = s.packageId || options.package;
+                    if (pkgId && id.startsWith(`${pkgId}/`)) {
+                        id = id.slice(pkgId.length + 1);
+                    }
+                    else if (targetPackageRoot && id.includes("/")) {
+                        id = id.slice(id.indexOf("/") + 1);
+                    }
+                }
+                return {
+                    id,
+                    description: s.description || "",
+                };
+            });
+            const filterRes = filterWithFallbackInfo(rawList, effectiveIntent, [(a) => a.id, (a) => a.description], shouldFallback);
+            if (filterRes.isFallback && isMachine) {
+                renderResult({ items: filterRes.items, isFallback: true, matchedCount: 0 }, { json: options.json, envelope: options.envelope, context });
+                return;
+            }
+            const title = resolved.type === "remote"
+                ? `Actions on remote server ${resolved.serverUrl}${resolved.profileName ? ` (Profile: ${resolved.profileName})` : ""}`
+                : targetPackageRoot
+                    ? `Actions in ${options.package || "current project"}`
+                    : "Available Actions";
+            renderResult(filterRes.items, {
+                json: options.json,
+                envelope: options.envelope,
+                humanFormatter: () => renderActionList(filterRes.items, title, filterRes.isFallback, effectiveIntent),
+                context,
+            });
+        }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true });
+    });
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import type { CliContext } from "../types.js";
+/**
+ * 注册 mcp 命令（STDIO 与 HTTP 传输服务模式）。
+ *
+ * @param program Commander 实例
+ * @param context 命令行上下文
+ */
+export declare function registerMcpCommands(program: Command, context?: CliContext): void;

package/dist/commands/mcp.js

@@ -0,0 +1,172 @@
+import { resolve } from "node:path";
+import { findProjectRoot, formatHostForUrl, loadProjectConfig, parseDuration } from "@actiondock/core";
+import { startMcpHttpServer, startMcpStdio } from "@actiondock/mcp";
+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 {
+            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 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;