@actiondock/cli 2.7.0 → 2.9.0

package/dist/commands/run.d.ts

@@ -1,4 +1,4 @@
-import { type InvocationControl } from "@actiondock/core";
+import { type InvocationControl } from "@actiondock/core/server";
 import type { ExecutionResult } from "@actiondock/sdk";
 import { Command } from "commander";
 import type { CliContext } from "../types.js";
@@ -10,7 +10,10 @@ 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, flatArgs?: string[], control?: InvocationControl): Promise<void>;
 /**

package/dist/commands/run.js

@@ -1,7 +1,8 @@
-import { parseDuration, resolveTarget, validateActionInputValue, mapInputValidationFailure, } 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 执行终态结果（默认纯文本模式）。
  *
@@ -95,7 +96,10 @@ export function renderRawExecutionResult(targetRef, result, context) {
     }
 }
 /**
- * 统一执行 Action 核心逻辑（使用 ActionDockTarget 门面）。
+ * 统一执行 Action 核心逻辑（使用 ActionDockService 服务端口）。
+ *
+ * @param id 目标 Action 标识
+ * @param options 执行选项（由 Command 统一构造）
  */
 export async function executeAction(id, options, context, flatArgs, control) {
     if (!id) {
@@ -114,15 +118,7 @@ export async function executeAction(id, options, context, flatArgs, control) {
     if (!check.valid) {
         throw mapInputValidationFailure("cli-pre-target", check);
     }
-    let timeoutMs;
-    if (options.timeout) {
-        try {
-            timeoutMs = parseDuration(options.timeout);
-        }
-        catch (err) {
-            throw new ArgumentError(`Invalid timeout format: ${err.message}`);
-        }
-    }
+    const timeoutMs = resolveTimeoutMs(options.timeout);
     const configOverrides = {};
     if (options.config) {
         const list = Array.isArray(options.config) ? options.config : [options.config];
@@ -149,14 +145,14 @@ export async function executeAction(id, options, context, flatArgs, control) {
             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, {
+                const ticket = await service.execution.start(targetRef, input, {
                     signal: effectiveSignal,
                     timeoutMs,
                     config: configOverrides,
@@ -182,7 +178,7 @@ export async function executeAction(id, options, context, flatArgs, control) {
                 }
             }
             else {
-                const result = await target.runAction(targetRef, input, {
+                const result = await service.execution.run(targetRef, input, {
                     signal: effectiveSignal,
                     timeoutMs,
                     config: configOverrides,
@@ -208,10 +204,13 @@ export async function executeAction(id, options, context, flatArgs, control) {
         }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true, ownDataDir: true });
     }
     catch (err) {
+        // sigint 取消源、中断链路特征错误码或 SigintError 本身，均统一归并为 SigintError
+        // 原 if 中额外的「cancellationSource 为 sigint 且 AbortError/aborted/ACTION_CANCELLED」
+        // 子句被首项 cancellationSource === "sigint" 完全蕴含，等价化简后移除
         const isSigint = effectiveControl?.cancellationSource === "sigint" ||
-            err?.message?.includes("Interrupted by SIGINT");
-        if (isSigint &&
-            (err?.name === "AbortError" || effectiveSignal?.aborted || err?.message?.includes("SIGINT") || err instanceof SigintError)) {
+            err?.code === "SIGINT_INTERRUPTED" ||
+            err instanceof SigintError;
+        if (isSigint) {
             throw new SigintError();
         }
         throw err;

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,12 @@
 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 { parseActionRef } from "@actiondock/core/graph";
+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, loadViewsFromFile, mergeServerViews, normalizeCorsOrigins, registerStopSignalHandler, printServerBanner, resolveMaxBodyBytes, resolveServerHost, resolveServerPort, resolveServerToken, parseListOption, } from "../utils/index.js";
 /**
  * 注册 serve HTTP 服务启动命令。
  *
@@ -31,17 +33,20 @@ 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("-A, --action <action-ref>", "Specific action ref(s) to serve (can be specified multiple times or comma-separated)", parseListOption, [])
+        .option("--views-file <path>", "Path to JSON file configuring virtual projection views")
+        .option("--views <json>", "JSON string configuring virtual projection views")
         .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,42 +87,153 @@ 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());
+        let projectConfig;
         let projectName = "Global Registry Mode";
         if (projectRoot) {
             try {
-                const config = loadProjectConfig(projectRoot);
-                projectName = `${config.name} (${config.id})`;
+                projectConfig = loadProjectConfig(projectRoot);
+                projectName = `${projectConfig.name} (${projectConfig.id})`;
             }
             catch {
                 // 降级处理
             }
         }
+        const fileViews = options.viewsFile
+            ? loadViewsFromFile(options.viewsFile)
+            : undefined;
+        let cliViews;
+        if (options.views) {
+            try {
+                const parsed = typeof options.views === "string" ? JSON.parse(options.views) : options.views;
+                cliViews =
+                    parsed && typeof parsed === "object" && "views" in parsed && (typeof parsed.views === "object" || Array.isArray(parsed.views))
+                        ? parsed.views
+                        : parsed;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                throw new ArgumentError(`Failed to parse --views option: ${msg}`);
+            }
+        }
+        const configViews = projectConfig?.server?.views;
+        const viewsConfig = mergeServerViews(mergeServerViews(configViews, fileViews), cliViews);
+        const rawPackages = options.package || [];
+        const packageAllowlist = rawPackages.length > 0 ? [] : undefined;
+        const resolvedPackageIds = [];
+        const explicitPackages = [];
+        const rawActions = options.action || [];
+        const actionAllowlist = rawActions.length > 0 ? [...rawActions] : undefined;
+        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);
+                }
+            }
+        }
+        if (rawActions.length > 0) {
+            for (const actRef of rawActions) {
+                try {
+                    const parsed = parseActionRef(actRef);
+                    if (parsed.packageId) {
+                        const root = resolvePackageRoot(parsed.packageId, projectRoot || undefined, context?.customHome);
+                        if (root) {
+                            if (!projectRoot || root !== projectRoot) {
+                                if (!explicitPackages.some((p) => p.packageRoot === root)) {
+                                    explicitPackages.push({ packageRoot: root });
+                                }
+                            }
+                        }
+                        else {
+                            writeStderr(`Warning: Package '${parsed.packageId}' specified in action '${actRef}' was not found.`, context);
+                        }
+                    }
+                }
+                catch {
+                    // 忽略非标准或短引用形态
+                }
+            }
+        }
+        if (viewsConfig) {
+            const viewItems = Array.isArray(viewsConfig) ? viewsConfig : Object.values(viewsConfig);
+            for (const item of viewItems) {
+                if (!item || typeof item !== "object")
+                    continue;
+                if (Array.isArray(item.packageAllowlist)) {
+                    for (const pkgId of item.packageAllowlist) {
+                        if (typeof pkgId === "string") {
+                            const root = resolvePackageRoot(pkgId, projectRoot || undefined, context?.customHome);
+                            if (root && (!projectRoot || root !== projectRoot)) {
+                                if (!explicitPackages.some((p) => p.packageRoot === root)) {
+                                    explicitPackages.push({ packageRoot: root });
+                                }
+                            }
+                        }
+                    }
+                }
+                if (Array.isArray(item.actionAllowlist)) {
+                    for (const actRef of item.actionAllowlist) {
+                        if (typeof actRef === "string") {
+                            try {
+                                const parsed = parseActionRef(actRef);
+                                if (parsed.packageId) {
+                                    const root = resolvePackageRoot(parsed.packageId, projectRoot || undefined, context?.customHome);
+                                    if (root && (!projectRoot || root !== projectRoot)) {
+                                        if (!explicitPackages.some((p) => p.packageRoot === root)) {
+                                            explicitPackages.push({ packageRoot: root });
+                                        }
+                                    }
+                                }
+                            }
+                            catch { }
+                        }
+                    }
+                }
+            }
+        }
         const platform = createNodePlatform({
             customHome: context?.customHome,
             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 || rawActions.length > 0 || Boolean(viewsConfig),
         });
-        let mcpHandler;
+        let mcpHandlerFactory;
         const enableMcp = options.mcp !== false;
         if (enableMcp) {
             // MCP 处理器创建失败时直接终止启动，避免横幅宣称不存在的端点
@@ -126,21 +242,26 @@ export function registerServeCommand(program, context) {
                     import("@actiondock/mcp"),
                     import("@modelcontextprotocol/server"),
                 ]);
-                const handler = createMcpHandler(() => {
-                    return createActionDockMcpServer({
-                        target,
+                mcpHandlerFactory = (view) => {
+                    const handler = createMcpHandler(() => {
+                        return createActionDockMcpServer({
+                            service,
+                            packageAllowlist: view.packageAllowlist,
+                            packageIds: view.packageAllowlist,
+                            actionAllowlist: view.actionAllowlist,
+                        });
+                    }, {
+                        onerror: (err) => {
+                            writeStderr(`[MCP HTTP Error] ${err?.message || String(err)}`, context);
+                        },
                     });
-                }, {
-                    onerror: (err) => {
-                        writeStderr(`[MCP HTTP Error] ${err?.message || String(err)}`, context);
-                    },
-                });
-                mcpHandler = async (req) => {
-                    return handler.fetch(req);
+                    return async (req) => {
+                        return handler.fetch(req);
+                    };
                 };
             }
             catch (err) {
-                await target.close().catch(() => { });
+                await service.close().catch(() => { });
                 throw new ExecutionError(`Failed to initialize MCP endpoint: ${err?.message || String(err)}`, err);
             }
         }
@@ -156,19 +277,31 @@ export function registerServeCommand(program, context) {
                 exposeDebugInfo,
                 enableMcp,
                 enableManagement,
-                mcpHandler,
+                mcpHandlerFactory,
                 tls,
                 projectRoot: projectRoot || undefined,
-                target,
+                service,
+                packageAllowlist,
+                actionAllowlist,
+                views: viewsConfig,
             });
             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, {
+                views: viewsConfig,
+                endpointHost: actualEndpointHost,
+                enableMcp,
+            });
+            if (resolvedPackageIds.length > 0) {
+                writeStdout(`  * Packages:        ${resolvedPackageIds.join(", ")}`, context);
+            }
+            else {
+                writeStdout(`  * Project:         ${projectName}`, context);
+            }
+            if (actionAllowlist && actionAllowlist.length > 0) {
+                writeStdout(`  * Actions:         ${actionAllowlist.join(", ")}`, context);
+            }
             if (projectRoot && exposeDebugInfo) {
                 writeStdout(`  * Root Path:       ${projectRoot}`, context);
             }
@@ -183,30 +316,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;