@actiondock/cli 2.7.0 → 2.8.0

package/dist/commands/runs.js

@@ -1,7 +1,9 @@
-import { filterWithFallbackInfo, findProjectRoot, listLinkedPackages, loadProjectConfig, resolvePackageRoot, } from "@actiondock/core";
-import { ArgumentError, ExecutionError, NO_PROJECT_NO_LINKED_MESSAGE, notInProjectError, packageNotFoundError, } from "../errors.js";
+import { findProjectRoot, loadProjectConfig, } from "@actiondock/core";
+import { filterWithFallbackInfo, } from "@actiondock/core/project";
+import { listLinkedPackages, resolvePackageRoot, } from "@actiondock/core/registry";
+import { ArgumentError, ExecutionError, NO_PROJECT_NO_LINKED_MESSAGE, packageNotFoundError, } from "../errors.js";
 import { renderResult, renderRunDetail, renderRunsList } from "../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, resolveIntent, resolveTargetFromOptions, withRemoteTarget, withTarget, } from "../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, remoteTargetSuffix, requirePackageRoot, resolveFallbackStrategy, resolveIntent, withService, } from "../utils/index.js";
 /**
  * 解析本地目标包根目录与工程配置（仅在 local 分支调用）。
  * 显式指定包且寻址失败时抛出参数错误；工程清单损坏时降级为链接包视图。
@@ -50,21 +52,26 @@ export function registerRunsCommands(program, context) {
         .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("--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("--data-dir <path>", "Custom database storage directory")
         .option("--json", "Output as JSON")
         .action(async (patterns = [], rawOptions, cmd) => {
         const options = getEffectiveOptions(rawOptions, cmd);
         const effectiveIntent = resolveIntent(options.intent, patterns);
-        const shouldFallback = options.fallback !== false;
+        const { shouldFallback } = resolveFallbackStrategy(options);
         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({
+        // 通过 Service 门面统一访问
+        await withService(options, context, async (service, resolved) => {
+            // limit 下推查询层：intent 过滤发生在内存（过滤后仍需截断到用户值），
+            // 下推时附加合理裕量，保证过滤后可截断数量不少于用户请求
+            const FETCH_HEADROOM = 200;
+            const queryLimit = effectiveIntent ? limit + FETCH_HEADROOM : limit;
+            const records = await service.runs.list({
                 packageId: options.package,
                 actionId: options.action,
-                limit: 500,
+                limit: queryLimit,
             });
             // 若处于本地无项目环境且无任何软链接包，则直接输出友好提示
             if (resolved.type === "local" && !scope.targetPackageRoot) {
@@ -85,7 +92,7 @@ export function registerRunsCommands(program, context) {
                 humanFormatter: () => {
                     let title = "Execution Runs";
                     if (resolved.type === "remote") {
-                        title = `Execution Runs on remote server ${resolved.serverUrl}${resolved.profileName ? ` (Profile: ${resolved.profileName})` : ""}`;
+                        title = `Execution Runs ${remoteTargetSuffix(resolved)}`;
                     }
                     else if (scope.projConfig) {
                         title = `Execution Runs in ${scope.projConfig.name} (${scope.projConfig.id})`;
@@ -112,9 +119,9 @@ export function registerRunsCommands(program, context) {
             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);
+        // 通过 Service 门面统一查询
+        await withService(options, context, async (service, resolved) => {
+            const run = await service.runs.get(id);
             if (!run) {
                 if (resolved.type === "remote") {
                     throw new ExecutionError(`Run record '${id}' not found on remote server`);
@@ -144,12 +151,8 @@ export function registerRunsCommands(program, context) {
         if (!id) {
             throw new ArgumentError("Run ID is required for cancel");
         }
-        const resolved = resolveTargetFromOptions(options, context);
-        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);
+        await withService(options, context, async (service) => {
+            const result = await service.runs.cancel(id, options.reason);
             const isErrorOutcome = result.outcome === "not_found" || result.outcome === "not_owner";
             renderResult(result, {
                 json: options.json,
@@ -167,7 +170,7 @@ export function registerRunsCommands(program, context) {
             if (isErrorOutcome) {
                 process.exitCode = 1;
             }
-        });
+        }, { requireRemote: true });
     });
     // runs clear
     applyTargetOptions(runsCmd
@@ -182,19 +185,7 @@ export function registerRunsCommands(program, context) {
         let targetPackageRoot;
         let packageId = options.package;
         if (!options.profile && !options.server) {
-            if (options.package) {
-                const root = resolvePackageRoot(options.package);
-                if (!root) {
-                    throw packageNotFoundError(options.package);
-                }
-                targetPackageRoot = root;
-            }
-            else {
-                targetPackageRoot = findProjectRoot() || undefined;
-                if (!targetPackageRoot) {
-                    throw notInProjectError("Please specify -P, --package <id> or cd into a project directory.");
-                }
-            }
+            targetPackageRoot = requirePackageRoot(options.package).root;
             try {
                 packageId = loadProjectConfig(targetPackageRoot).id;
             }
@@ -202,9 +193,9 @@ export function registerRunsCommands(program, context) {
                 // 清单损坏时保留原始 -P 参数作为包标识
             }
         }
-        await withTarget(options, context, async (target, resolved) => {
-            const count = target.clearRuns
-                ? await target.clearRuns({ packageId, actionId: options.action })
+        await withService(options, context, async (service, resolved) => {
+            const count = service.runs.clear
+                ? await service.runs.clear({ packageId, actionId: options.action })
                 : 0;
             const payload = { ok: true, clearedCount: count };
             renderResult(payload, {

package/dist/commands/serve.js

@@ -1,10 +1,11 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { createActionDockTarget, findProjectRoot, formatHostForUrl, loadProjectConfig, startActionDockServer, } from "@actiondock/core";
-import { createNodePlatform } from "@actiondock/runtime-node";
-import { ArgumentError, ExecutionError } from "../errors.js";
+import { createActionDock, createNodePlatform, findProjectRoot, loadProjectConfig, startActionDockServer, } from "@actiondock/core";
+import { resolvePackageRoot } from "@actiondock/core/registry";
+import { formatHostForUrl, } from "@actiondock/core/server";
+import { ArgumentError, ExecutionError, packageNotFoundError } from "../errors.js";
 import { writeStderr, writeStdout } from "../renderer.js";
-import { ensureSelfSignedCertificate, getEffectiveOptions, parseByteSize } from "../utils/index.js";
+import { ensureSelfSignedCertificate, getEffectiveOptions, normalizeCorsOrigins, registerStopSignalHandler, printServerBanner, resolveMaxBodyBytes, resolveServerHost, resolveServerPort, resolveServerToken, parseListOption, } from "../utils/index.js";
 /**
  * 注册 serve HTTP 服务启动命令。
  *
@@ -31,17 +32,17 @@ export function registerServeCommand(program, context) {
         .option("--tls-ca <path>", "Path to TLS CA certificate file (or set ACTIONDOCK_TLS_CA)")
         .option("--tls-passphrase <passphrase>", "Passphrase for TLS private key (or set ACTIONDOCK_TLS_PASSPHRASE)")
         .option("-d, --dir <path>", "Project root directory (default: current working directory)")
+        .option("-P, --package <package-id>", "Specific package ID(s) to serve (can be specified multiple times or comma-separated)", parseListOption, [])
         .option("--data-dir <path>", "Custom database storage directory")
         .action(async (rawOptions, cmd) => {
         const options = getEffectiveOptions(rawOptions, cmd);
-        const parsedPort = parseInt(options.port, 10);
-        const port = Number.isNaN(parsedPort) ? 5177 : parsedPort;
-        const host = options.host || "127.0.0.1";
-        const token = options.token || (typeof process !== "undefined" ? process.env?.ACTIONDOCK_TOKEN : undefined);
+        const port = resolveServerPort(options.port, 5177);
+        const host = resolveServerHost(options.host);
+        const token = resolveServerToken(options.token);
         const allowInsecureNoAuth = Boolean(options.allowInsecureNoAuth);
         const allowQueryToken = Boolean(options.allowQueryToken);
         const enableManagement = Boolean(options.management);
-        const corsOrigins = options.corsOrigin && options.corsOrigin.length > 0 ? options.corsOrigin : undefined;
+        const corsOrigins = normalizeCorsOrigins(options.corsOrigin);
         const exposeDebugInfo = Boolean(options.exposeDebugInfo);
         const httpsEnabled = Boolean(options.https ||
             options.tlsCert ||
@@ -82,18 +83,46 @@ export function registerServeCommand(program, context) {
                 };
             }
         }
-        let maxBodyBytes;
-        if (options.maxBody) {
-            try {
-                maxBodyBytes = parseByteSize(options.maxBody);
-            }
-            catch (err) {
-                throw new ArgumentError(`Invalid max-body format: ${err.message}`);
-            }
-        }
+        const maxBodyBytes = resolveMaxBodyBytes(options.maxBody);
         const projectRoot = options.dir
             ? resolve(options.dir)
             : findProjectRoot(process.cwd());
+        const rawPackages = options.package || [];
+        const packageAllowlist = rawPackages.length > 0 ? [] : undefined;
+        const resolvedPackageIds = [];
+        const explicitPackages = [];
+        if (rawPackages.length > 0) {
+            for (const pkgId of rawPackages) {
+                const root = resolvePackageRoot(pkgId, projectRoot || undefined, context?.customHome);
+                if (!root) {
+                    throw packageNotFoundError(pkgId);
+                }
+                if (!projectRoot || root !== projectRoot) {
+                    if (!explicitPackages.some((p) => p.packageRoot === root)) {
+                        explicitPackages.push({ packageRoot: root });
+                    }
+                }
+                let resolvedId = pkgId;
+                try {
+                    const config = loadProjectConfig(root);
+                    if (config.id) {
+                        resolvedId = config.id;
+                        if (!packageAllowlist.includes(config.id)) {
+                            packageAllowlist.push(config.id);
+                        }
+                    }
+                }
+                catch {
+                    // 降级使用原始标识符
+                }
+                if (!packageAllowlist.includes(pkgId)) {
+                    packageAllowlist.push(pkgId);
+                }
+                if (!resolvedPackageIds.includes(resolvedId)) {
+                    resolvedPackageIds.push(resolvedId);
+                }
+            }
+        }
         let projectName = "Global Registry Mode";
         if (projectRoot) {
             try {
@@ -109,13 +138,14 @@ export function registerServeCommand(program, context) {
             dataDir: options.dataDir || context?.dataDir,
             rootDir: projectRoot || undefined,
         });
-        const target = await createActionDockTarget({
+        const service = await createActionDock({
             type: "local",
             projectRoot: projectRoot || undefined,
+            packages: explicitPackages.length > 0 ? explicitPackages : undefined,
             customHome: context?.customHome,
             dataDir: options.dataDir || context?.dataDir,
             platform,
-            scanLinkedPackages: !projectRoot,
+            scanLinkedPackages: !projectRoot || rawPackages.length > 0,
         });
         let mcpHandler;
         const enableMcp = options.mcp !== false;
@@ -128,7 +158,9 @@ export function registerServeCommand(program, context) {
                 ]);
                 const handler = createMcpHandler(() => {
                     return createActionDockMcpServer({
-                        target,
+                        service,
+                        packageAllowlist,
+                        packageIds: packageAllowlist,
                     });
                 }, {
                     onerror: (err) => {
@@ -140,7 +172,7 @@ export function registerServeCommand(program, context) {
                 };
             }
             catch (err) {
-                await target.close().catch(() => { });
+                await service.close().catch(() => { });
                 throw new ExecutionError(`Failed to initialize MCP endpoint: ${err?.message || String(err)}`, err);
             }
         }
@@ -159,16 +191,19 @@ export function registerServeCommand(program, context) {
                 mcpHandler,
                 tls,
                 projectRoot: projectRoot || undefined,
-                target,
+                service,
+                packageAllowlist,
             });
             const displayHost = formatHostForUrl(host);
             const actualEndpointHost = formatHostForUrl(host === "0.0.0.0" ? "127.0.0.1" : host);
             const scheme = tls ? "https" : "http";
-            writeStdout(`\n======================================================`, context);
-            writeStdout(`  ActionDock 2.0 HTTP Runner Server`, context);
-            writeStdout(`======================================================`, context);
-            writeStdout(`  * Listening on:    ${scheme}://${displayHost}:${server.port}`, context);
-            writeStdout(`  * Project:         ${projectName}`, context);
+            printServerBanner(`ActionDock 2.0 HTTP Runner Server`, scheme, displayHost, server.port, context);
+            if (resolvedPackageIds.length > 0) {
+                writeStdout(`  * Packages:        ${resolvedPackageIds.join(", ")}`, context);
+            }
+            else {
+                writeStdout(`  * Project:         ${projectName}`, context);
+            }
             if (projectRoot && exposeDebugInfo) {
                 writeStdout(`  * Root Path:       ${projectRoot}`, context);
             }
@@ -183,30 +218,17 @@ export function registerServeCommand(program, context) {
             writeStdout(`  * Management APIs: ${enableManagement ? "Enabled" : "Disabled (Default)"}`, context);
             writeStdout(`  * CORS Origins:    ${corsOrigins ? corsOrigins.join(", ") : "Disabled (Default)"}`, context);
             writeStdout(`  * Max Body Size:   ${options.maxBody || "1mb"}`, context);
-            writeStdout(`  * Health Endpoint: ${scheme}://${actualEndpointHost}:${server.port}/api/v1/health`, context);
+            writeStdout(`  * Health Endpoint: ${scheme}://${actualEndpointHost}:${server.port}/api/v2/health`, context);
             if (enableMcp) {
                 writeStdout(`  * MCP Endpoint:    ${scheme}://${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);
-                Promise.resolve(server.stop())
-                    .catch((err) => {
-                    // 停止失败必须可见：写入 stderr 一行并标记失败退出码
-                    writeStderr(`[ERROR] Failed to stop ActionDock server gracefully: ${err instanceof Error ? err.message : String(err)}`, context);
-                    process.exitCode = 1;
-                })
-                    .finally(() => {
-                    process.exit(typeof process.exitCode === "number" ? process.exitCode : 0);
-                });
-            };
-            process.once("SIGINT", stopSignalHandler);
-            process.once("SIGTERM", stopSignalHandler);
+            registerStopSignalHandler(server, `ActionDock server`, context);
         }
         catch (err) {
-            await target.close().catch(() => { });
+            await service.close().catch(() => { });
             throw new ExecutionError(`Failed to start ActionDock server: ${err.message}`, err);
         }
     });

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

@@ -1,10 +1,10 @@
-import type { ActionDockTarget } from "@actiondock/core";
+import { type ActionDockService } from "@actiondock/core";
 import type { CliContext } from "../types.js";
 /**
  * 状态键列表渲染参数视图。
  */
 export interface StateListRenderArgs {
-    target: ActionDockTarget;
+    service: ActionDockService;
     actionId: string;
     prefix: string;
     options: any;

package/dist/commands/state-list.js

@@ -1,4 +1,6 @@
-import { filterWithFallbackInfo, listLinkedPackages, loadProjectConfig, } from "@actiondock/core";
+import { loadProjectConfig, } from "@actiondock/core";
+import { filterWithFallbackInfo, } from "@actiondock/core/project";
+import { listLinkedPackages, } from "@actiondock/core/registry";
 import { existsSync } from "node:fs";
 import { NO_PROJECT_NO_LINKED_MESSAGE } from "../errors.js";
 import { renderResult, renderStateList } from "../renderer.js";
@@ -6,16 +8,16 @@ import { renderResult, renderStateList } from "../renderer.js";
  * 渲染单个项目作用域的状态键列表（含 --detail JSON 明细分支）。
  */
 export async function renderProjectScopedStateList(args) {
-    const { target, targetRoot, actionId, prefix, options, effectiveIntent, shouldFallback, context } = args;
+    const { service, targetRoot, actionId, prefix, options, effectiveIntent, shouldFallback, context } = args;
     const projConfig = loadProjectConfig(targetRoot);
-    const allKeys = await target.listStateKeys(projConfig.id, actionId, {
+    const allKeys = (await service.management?.state.list(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, {
+            const entry = await service.management?.state.get(projConfig.id, actionId, k, {
                 namespace: options.namespace,
                 detail: true,
             });
@@ -41,7 +43,7 @@ export async function renderProjectScopedStateList(args) {
  * 渲染全部链接包聚合的状态键列表（跳过磁盘失效与清单损坏的链接项）。
  */
 export async function renderLinkedPackagesStateList(args) {
-    const { target, actionId, prefix, options, effectiveIntent, shouldFallback, context } = args;
+    const { service, actionId, prefix, options, effectiveIntent, shouldFallback, context } = args;
     // 扫描所有链接的包状态
     const linked = listLinkedPackages();
     if (linked.length === 0) {
@@ -58,10 +60,10 @@ export async function renderLinkedPackagesStateList(args) {
             continue;
         try {
             const config = loadProjectConfig(pkg.path);
-            const keys = await target.listStateKeys(config.id, actionId, {
+            const keys = (await service.management?.state.list(config.id, actionId, {
                 namespace: options.namespace !== undefined ? options.namespace : null,
                 prefix,
-            });
+            })) ?? [];
             for (const k of keys) {
                 aggregatedKeys.push(`${config.id}/${k}`);
             }

package/dist/commands/state.d.ts

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