@actiondock/cli 2.6.0 → 2.8.0

package/dist/commands/remove.js

@@ -1,8 +1,7 @@
-import { resolve } from "node:path";
-import { beginTransaction, findProjectRoot, getInstallCommand, loadLockfile, loadManifest, saveLockfile, saveManifest, } from "@actiondock/core";
-import { ArgumentError, ExecutionError, notInProjectError } from "../errors.js";
+import { beginTransaction, getInstallCommand, loadLockfile, saveLockfile, saveManifest, } from "@actiondock/core/project";
+import { ArgumentError, ExecutionError } from "../errors.js";
 import { renderResult, writeStderr } from "../renderer.js";
-import { assertSafePackageSpec, getEffectiveOptions, spawnAsync } from "../utils/index.js";
+import { assertSafePackageSpec, getEffectiveOptions, requireProjectManifestRoot, rollbackAndRethrow, spawnAsync, } from "../utils/index.js";
 /**
  * 注册 ad remove 依赖移除命令。
  * 遵循规范：移除依赖并更新锁文件，保留该包的历史存储数据，检查反向引用防止误删。
@@ -15,14 +14,7 @@ export function registerRemoveCommand(program, context) {
         .option("--json", "Output as JSON")
         .action(async (packageIdentifier, rawOptions, cmd) => {
         const options = getEffectiveOptions(rawOptions, cmd);
-        const root = options.package ? resolve(options.package) : findProjectRoot();
-        if (!root) {
-            throw notInProjectError("Please 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}`);
-        }
+        const { root, manifest } = requireProjectManifestRoot(options.package);
         // 寻址逻辑包标识
         let targetPackageId = null;
         let npmPackageName = packageIdentifier;
@@ -115,8 +107,7 @@ export function registerRemoveCommand(program, context) {
             });
         }
         catch (err) {
-            await tx.rollback({ frozenInstall: false });
-            throw new ExecutionError(err.message, err, err.code || "REMOVE_DEPENDENCY_FAILED");
+            await rollbackAndRethrow(tx, err, "REMOVE_DEPENDENCY_FAILED");
         }
     });
 }

package/dist/commands/run.d.ts

@@ -1,3 +1,4 @@
+import { type InvocationControl } from "@actiondock/core/server";
 import type { ExecutionResult } from "@actiondock/sdk";
 import { Command } from "commander";
 import type { CliContext } from "../types.js";
@@ -9,9 +10,12 @@ import type { CliContext } from "../types.js";
  */
 export declare function renderRawExecutionResult(targetRef: string, result: ExecutionResult, context?: CliContext): void;
 /**
- * 统一执行 Action 核心逻辑（使用 ActionDockTarget 门面）。
+ * 统一执行 Action 核心逻辑（使用 ActionDockService 服务端口）。
+ *
+ * @param id 目标 Action 标识
+ * @param options 执行选项（由 Command 统一构造）
  */
-export declare function executeAction(id: string, options: any, context?: CliContext): Promise<void>;
+export declare function executeAction(id: string, options: any, context?: CliContext, flatArgs?: string[], control?: InvocationControl): Promise<void>;
 /**
  * 挂载 run 子命令至指定 Commander 节点。
  *

package/dist/commands/run.js

@@ -1,7 +1,8 @@
-import { parseDuration, resolveTarget } from "@actiondock/core";
+import { validateActionInputValue, mapInputValidationFailure, } from "@actiondock/core/project";
+import { resolveTarget, } from "@actiondock/core/profile";
 import { ArgumentError, ExecutionError, SigintError, packageNotFoundError } from "../errors.js";
 import { writeStderr, writeStdout } from "../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, resolveActionInput, resolveLocalPackageRoot, withTarget, } from "../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, resolveActionInput, resolveLocalPackageRoot, resolveTimeoutMs, withService, } from "../utils/index.js";
 /**
  * 以原始纯文本形式渲染 Action 执行终态结果（默认纯文本模式）。
  *
@@ -86,30 +87,38 @@ export function renderRawExecutionResult(targetRef, result, context) {
                 ? result.error.details
                 : JSON.stringify(result.error.details, null, 2), context);
         }
-        process.exitCode = 1;
+        if (context) {
+            context.exitCode = 1;
+        }
+        if (!context?.control) {
+            process.exitCode = 1;
+        }
     }
 }
 /**
- * 统一执行 Action 核心逻辑（使用 ActionDockTarget 门面）。
+ * 统一执行 Action 核心逻辑（使用 ActionDockService 服务端口）。
+ *
+ * @param id 目标 Action 标识
+ * @param options 执行选项（由 Command 统一构造）
  */
-export async function executeAction(id, options, context) {
+export async function executeAction(id, options, context, flatArgs, control) {
     if (!id) {
         throw new ArgumentError("Action ID is required for run");
     }
+    const effectiveControl = control ?? context?.control;
+    const effectiveSignal = effectiveControl?.signal;
+    const effectiveFlatArgs = flatArgs ?? options.flatArgs;
     const input = await resolveActionInput({
         input: options.input,
         inputFile: options.inputFile,
+        flatArgs: effectiveFlatArgs && effectiveFlatArgs.length > 0 ? effectiveFlatArgs : undefined,
         stdin: context?.stdin,
     });
-    let timeoutMs;
-    if (options.timeout) {
-        try {
-            timeoutMs = parseDuration(options.timeout);
-        }
-        catch (err) {
-            throw new ArgumentError(`Invalid timeout format: ${err.message}`);
-        }
+    const check = validateActionInputValue(input);
+    if (!check.valid) {
+        throw mapInputValidationFailure("cli-pre-target", check);
     }
+    const timeoutMs = resolveTimeoutMs(options.timeout);
     const configOverrides = {};
     if (options.config) {
         const list = Array.isArray(options.config) ? options.config : [options.config];
@@ -119,13 +128,6 @@ export async function executeAction(id, options, context) {
                 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({
@@ -143,15 +145,15 @@ export async function executeAction(id, options, context) {
             throw packageNotFoundError(options.package);
         }
         let targetRef = id;
-        if (options.package && !id.includes("/") && !id.includes(":")) {
+        if (options.package && !id.includes("/")) {
             targetRef = `${options.package}/${id}`;
         }
-        // 通过 Target 统一执行
-        await withTarget(options, context, async (target) => {
+        // 通过 Service 统一执行
+        await withService(options, context, async (service) => {
             const isMachine = Boolean(options.json);
             if (options.async) {
-                const ticket = await target.startAction(targetRef, input, {
-                    signal: controller.signal,
+                const ticket = await service.execution.start(targetRef, input, {
+                    signal: effectiveSignal,
                     timeoutMs,
                     config: configOverrides,
                     requestId: options.requestId,
@@ -169,17 +171,23 @@ export async function executeAction(id, options, context) {
                     writeStdout(ticket.runId, context);
                 }
                 if (ticket.status === "failed") {
-                    process.exitCode = 1;
+                    if (context) {
+                        context.exitCode = 1;
+                    }
                     return;
                 }
             }
             else {
-                const result = await target.runAction(targetRef, input, {
-                    signal: controller.signal,
+                const result = await service.execution.run(targetRef, input, {
+                    signal: effectiveSignal,
                     timeoutMs,
                     config: configOverrides,
                     requestId: options.requestId,
                 });
+                if (effectiveControl?.cancellationSource === "sigint" &&
+                    (effectiveSignal?.aborted || (!result.ok && result.error?.code === "ACTION_CANCELLED"))) {
+                    throw new SigintError();
+                }
                 if (isMachine) {
                     writeStdout(JSON.stringify(result, null, 2), context);
                 }
@@ -187,21 +195,26 @@ export async function executeAction(id, options, context) {
                     renderRawExecutionResult(targetRef, result, context);
                 }
                 if (!result.ok) {
-                    process.exitCode = 1;
+                    if (context) {
+                        context.exitCode = 1;
+                    }
                     return;
                 }
             }
         }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true, ownDataDir: true });
     }
     catch (err) {
-        if (receivedSigint || err?.name === "AbortError" || err?.message?.includes("SIGINT")) {
+        // sigint 取消源、中断链路特征错误码或 SigintError 本身，均统一归并为 SigintError
+        // 原 if 中额外的「cancellationSource 为 sigint 且 AbortError/aborted/ACTION_CANCELLED」
+        // 子句被首项 cancellationSource === "sigint" 完全蕴含，等价化简后移除
+        const isSigint = effectiveControl?.cancellationSource === "sigint" ||
+            err?.code === "SIGINT_INTERRUPTED" ||
+            err instanceof SigintError;
+        if (isSigint) {
             throw new SigintError();
         }
         throw err;
     }
-    finally {
-        process.removeListener("SIGINT", sigintHandler);
-    }
 }
 /**
  * 挂载 run 子命令至指定 Commander 节点。
@@ -211,7 +224,7 @@ export async function executeAction(id, options, context) {
  */
 export function attachRunCommand(parent, context) {
     const cmd = parent
-        .command("run <id>")
+        .command("run <id> [params...]")
         .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>", "Action input as inline JSON")
@@ -223,9 +236,19 @@ export function attachRunCommand(parent, context) {
         .option("--async", "Execute asynchronously in background (requires remote server or profile)")
         .option("--data-dir <path>", "Custom database directory")
         .option("--json", "Output as JSON")
-        .action(async (id, rawOptions, cmd) => {
-        const options = getEffectiveOptions(rawOptions, cmd);
-        await executeAction(id, options, context);
+        .action(async (id, params, rawOptions, cmd) => {
+        let flatArgs;
+        let effectiveRawOptions = rawOptions;
+        let effectiveCmd = cmd;
+        if (Array.isArray(params)) {
+            flatArgs = params.length > 0 ? params : undefined;
+        }
+        else {
+            effectiveCmd = rawOptions;
+            effectiveRawOptions = params;
+        }
+        const options = getEffectiveOptions(effectiveRawOptions, effectiveCmd);
+        await executeAction(id, { ...options, flatArgs }, context, undefined, context?.control);
     });
 }
 /**

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;