@actiondock/mcp 2.7.0 → 2.9.0

package/README.md

@@ -1,13 +1,13 @@
 # @actiondock/mcp
 
-ActionDock 2.0 模型上下文协议适配器。
+ActionDock 2.x 模型上下文协议适配器。
 
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D24.12.0-green?logo=node.js)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue?logo=typescript)](https://www.typescriptlang.org/)
 [![MCP](https://img.shields.io/badge/MCP-Protocol%20Compliant-purple)](https://modelcontextprotocol.io/)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
-`@actiondock/mcp` 将 ActionDock 中的原子 Action 映射为标准的模型上下文协议工具，无缝接入各类主流 AI 智能体与开发环境。
+`@actiondock/mcp` 将 ActionDock 中的原子 Action 映射为标准的模型上下文协议工具，无缝接入各类主流 AI 智能体与开发环境。在 ActionDock 2.x 中，MCP 适配层全面对接 `@actiondock/core` 导出的标准服务端口体系（`DiscoveryPort`、`ExecutionPort` 与 `RunsPort`），彻底消除对底层私有实体的直接穿透。
 
 ---
 
@@ -28,7 +28,7 @@ ActionDock 2.0 模型上下文协议适配器。
 ### 协同取消信号向下传播
 
 - 当 MCP 客户端发起取消请求时，适配层自动捕获中断事件。
-- 取消信号直接传递至底层的 ActionRunner 调度器，并联动激活当前任务上下文中的 `ctx.signal`。
+- 取消信号通过服务端口直接传递至底层的执行服务，并联动激活当前任务上下文中的 `ctx.signal`。
 - 业务代码可通过监听 AbortSignal 安全释放资源或提前终止执行。
 
 ### Tasks 异步任务映射扩展
@@ -39,6 +39,14 @@ ActionDock 2.0 模型上下文协议适配器。
 - 任务主动取消：通过 `tasks/cancel` 端点向正在后台执行的长周期任务发出中止指令。
 - 任务清单列举：通过 `tasks/list` 端点批量查询当前会话及宿主下的活跃与历史任务列表。
 
+### 细粒度权限白名单与安全过滤
+
+MCP 适配层原生支持基于包与动作维度的双层白名单控制，通过 `ActionDockMcpOptions` 进行配置：
+
+- 包白名单 `packageAllowlist`（别名 `packageIds`）：限制仅暴露指定包内的工具。
+- 动作白名单 `actionAllowlist`：限制仅暴露指定的动作，支持动作短名 `actionId` 与全限定名 `packageId/actionId`。
+- 联动过滤机制：同时配置包白名单与动作白名单时自动计算权限交集。未获授权的动作不会出现在 `tools/list` 工具列表中；在 `tasks/get`、`tasks/cancel` 与 `tasks/list` 任务扩展中，涉及未授权动作的任务同样予以严格隔离与隐藏。
+
 ---
 
 ## 快速使用
@@ -60,6 +68,8 @@ import { startMcpStdioServer } from "@actiondock/mcp";
 
 await startMcpStdioServer({
   projectRoot: process.cwd(),
+  packageAllowlist: ["system-tools"],
+  actionAllowlist: ["system-tools/status", "ping"],
 });
 ```
 

package/dist/adapter.d.ts

@@ -1,4 +1,6 @@
-import type { ActionDockApp, ActionDockHost, ActionDockTarget } from "@actiondock/core";
+import { type ActionDockService } from "@actiondock/core";
+import { type ActionDockHost } from "@actiondock/core/server";
+import type { PackageRuntime } from "@actiondock/core/package";
 import type { ExecutionResult } from "@actiondock/sdk";
 import { McpServer } from "@modelcontextprotocol/server";
 import type { ActionDockMcpOptions } from "./types.js";
@@ -29,23 +31,23 @@ export declare function toMcpResult(result: ExecutionResult): {
     structuredContent?: undefined;
 };
 /**
- * 解析或基于选项创建底层 ActionDockTarget 统一门面。
+ * 解析或基于选项创建底层 ActionDockService 统一门面。
  */
-export declare function resolveTarget(options: ActionDockMcpOptions): Promise<{
-    target: ActionDockTarget;
-    ownsTarget: boolean;
+export declare function resolveService(options: ActionDockMcpOptions): Promise<{
+    service: ActionDockService;
+    ownsService: boolean;
 }>;
 export type ActionDockMcpServer = McpServer & {
     close: () => Promise<void>;
-    target: ActionDockTarget;
+    service: ActionDockService;
     host?: ActionDockHost;
-    app?: ActionDockApp;
+    runtime?: PackageRuntime;
     events?: (runId: string, options?: {
         after?: number;
         signal?: AbortSignal;
     }) => AsyncIterable<Record<string, unknown>>;
 };
 /**
- * 创建并配置基于 ActionDockTarget 的 McpServer 适配层实例。
+ * 创建并配置基于 ActionDockService 的 McpServer 适配层实例。
  */
 export declare function createActionDockMcpServer(options?: ActionDockMcpOptions): Promise<ActionDockMcpServer>;

package/dist/adapter.js

@@ -1,11 +1,46 @@
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { ACTIONDOCK_VERSION, ActionResolver, createActionDockTarget, findProjectRoot, resolvePackageRoot, } from "@actiondock/core";
+import { ACTIONDOCK_VERSION, createActionDock, createNodePlatform, findProjectRoot, MCP_TOOL_NAME_COLLISION, } from "@actiondock/core";
+import { createActionDockHost, isActionAllowed, LocalActionDockService, } from "@actiondock/core/server";
+import { resolvePackageRoot } from "@actiondock/core/registry";
+import { createNonClosingStorageView } from "@actiondock/core/package";
+import { parseActionRef } from "@actiondock/core/graph";
 import { McpServer } from "@modelcontextprotocol/server";
 import { registerTasksExtension } from "./register-tasks-extension.js";
 import { toMcpSchema } from "./schemas.js";
 import { extractExecutionTimeoutMs, isAsyncExecutionRequested, stripExecutionWrapper, } from "./execution-mode.js";
+/** 形状缺失告警是否已输出过（每个进程仅告警一次，避免逐请求噪声） */
+let cancelSignalDegradationWarned = false;
+/**
+ * 从 MCP 工具回调上下文提取请求级取消信号。
+ *
+ * @param ctx MCP SDK 回调传入的工具执行上下文
+ * @returns 可用的 AbortSignal；形状缺失时返回 undefined 并输出一次降级警告
+ */
+function extractCancelSignal(ctx) {
+    const signal = ctx?.mcpReq?.signal;
+    if (!signal && !cancelSignalDegradationWarned) {
+        cancelSignalDegradationWarned = true;
+        process.stderr.write("[actiondock-mcp] Tool cancel signal unavailable: MCP SDK callback context does not expose mcpReq.signal; per-request cancellation is degraded for this server instance.\n");
+    }
+    return signal;
+}
+/**
+ * 解析 Action 引用字符串为包标识与动作标识（容错语义）。
+ *
+ * 委派 core 的 parseActionRef 单一事实源完成解析；非法形态（如尾部斜杠、
+ * 含冒号等）回退为整体短名处理，与适配层既有的注册容错行为保持一致，
+ * 不让目录聚合阶段的脏数据中断服务启动。
+ */
+function splitActionRef(ref) {
+    try {
+        return parseActionRef(ref);
+    }
+    catch {
+        return { actionId: ref };
+    }
+}
 /**
  * 判断目标值是否为普通对象（Plain Object）。
  *
@@ -48,28 +83,6 @@ export function toMcpResult(result) {
         ],
     };
 }
-/** 适配层统一结构化错误码：MCP 工具名冲突。 */
-const MCP_TOOL_NAME_COLLISION = "MCP_TOOL_NAME_COLLISION";
-/**
- * 构造外部注入 storage 的非接管视图。
- *
- * 默认（ownStorageLifecycle 为 false）时外部 storage 生命周期由注入方管理，
- * 适配层仅委托读写而不接管关闭：所有成员函数与属性原样转发到原始实例并绑定原 this，
- * 仅 close 收敛为显式声明的无操作边界，确保 target.close() 级联关闭时不会误伤外部实例。
- *
- * @param storage 外部注入的存储实例
- */
-function createExternalStorageView(storage) {
-    return new Proxy(storage, {
-        get(target, prop) {
-            if (prop === "close") {
-                return () => undefined;
-            }
-            const value = Reflect.get(target, prop, target);
-            return typeof value === "function" ? value.bind(target) : value;
-        },
-    });
-}
 /**
  * 构造携带结构化错误码的工具名冲突异常。
  *
@@ -81,42 +94,51 @@ function toolNameCollisionError(toolName) {
     return err;
 }
 /**
- * 解析或基于选项创建底层 ActionDockTarget 统一门面。
+ * 解析或基于选项创建底层 ActionDockService 统一门面。
  */
-export async function resolveTarget(options) {
-    if (options.target) {
-        return { target: options.target, ownsTarget: false };
+export async function resolveService(options) {
+    if (options.service) {
+        return { service: options.service, ownsService: false };
     }
     if (options.host) {
-        const target = await createActionDockTarget({ type: "local", host: options.host });
-        return { target, ownsTarget: false };
+        const service = new LocalActionDockService(options.host);
+        return { service, ownsService: false };
     }
-    if (options.app) {
-        const target = await createActionDockTarget({ type: "local", app: options.app });
-        return { target, ownsTarget: false };
+    if (options.runtime) {
+        const host = await createActionDockHost({
+            autoLoadCurrentProject: false,
+            scanLinkedPackages: false,
+        });
+        host.registerRuntime(options.runtime);
+        const service = new LocalActionDockService(host);
+        return { service, ownsService: false };
     }
     const packages = [];
-    // 外部注入的 storage 生命周期默认由注入方管理，适配层不伪造 close 语义；
-    // 仅当显式声明 ownStorageLifecycle 时才向包配置透传原始实例（随 target.close() 级联关闭）
-    // 外部注入的 storage 生命周期默认由注入方管理，适配层仅委托读写不接管关闭；
-    // 显式声明 ownStorageLifecycle 时透传原始实例，随 target.close() 级联关闭
+    // 外部注入的 storage 生命周期默认由注入方管理，适配层仅委托读写不接管关闭
+    // （非接管视图复用 core 单一事实源）；显式声明 ownStorageLifecycle 时透传
+    // 原始实例，随 target.close() 级联关闭
     const appStorage = options.storage
         ? options.ownStorageLifecycle
             ? options.storage
-            : createExternalStorageView(options.storage)
+            : createNonClosingStorageView(options.storage)
         : undefined;
+    // 多分支共享的包选项基底单点构造：storage 视图、家目录与配置覆写
+    // 在此收敛一次，各 push 分支仅叠加自身特有字段
+    const basePkgOpts = {
+        ...(appStorage ? { storage: appStorage } : {}),
+        customHome: options.customHome,
+        configOverrides: options.configOverrides,
+    };
     if (options.actions) {
         packages.push({
+            ...basePkgOpts,
             projectConfig: {
                 id: options.packageId || "default",
                 name: options.packageId || "default",
                 version: ACTIONDOCK_VERSION,
             },
             actions: options.actions,
-            storage: appStorage,
             inMemory: true,
-            customHome: options.customHome,
-            configOverrides: options.configOverrides,
         });
     }
     if (options.projectRoots && options.projectRoots.length > 0) {
@@ -127,24 +149,21 @@ export async function resolveTarget(options) {
                 throw new Error(`Project root '${root}' is not a valid ActionDock package (actiondock.json not found)`);
             }
             packages.push({
+                ...basePkgOpts,
                 packageRoot: detected,
-                storage: appStorage,
-                customHome: options.customHome,
-                configOverrides: options.configOverrides,
             });
         }
     }
-    if (options.packageIds && options.packageIds.length > 0) {
-        for (const pkgId of options.packageIds) {
+    const targetPackageIds = options.packageIds || options.packageAllowlist;
+    if (targetPackageIds && targetPackageIds.length > 0) {
+        for (const pkgId of targetPackageIds) {
             const root = resolvePackageRoot(pkgId, undefined, options.customHome);
             if (!root || !existsSync(root)) {
                 throw new Error(`Package '${pkgId}' not found in registry`);
             }
             packages.push({
+                ...basePkgOpts,
                 packageRoot: root,
-                storage: appStorage,
-                customHome: options.customHome,
-                configOverrides: options.configOverrides,
             });
         }
     }
@@ -173,32 +192,18 @@ export async function resolveTarget(options) {
             throw new Error(`Package '${options.packageId}' not found in registry`);
         }
         packages.push({
+            ...basePkgOpts,
             packageRoot: root,
-            storage: appStorage,
-            customHome: options.customHome,
-            configOverrides: options.configOverrides,
             dataDir: options.dataDir,
         });
     }
     let platform = options.platform;
     if (!platform && typeof process !== "undefined" && process.versions?.node) {
-        try {
-            const { createNodePlatform } = await import("@actiondock/runtime-node");
-            platform = createNodePlatform({
-                customHome: options.customHome,
-                dataDir: options.dataDir,
-                rootDir: projectRoot,
-            });
-        }
-        catch (err) {
-            // 仅「模块不存在」类错误允许降级回退 core 默认平台；
-            // 其余异常（加载后初始化失败等）原样上抛，避免吞没真实故障
-            const isModuleMissing = err?.code === "ERR_MODULE_NOT_FOUND" ||
-                /Cannot find (?:package|module)/i.test(String(err?.message || ""));
-            if (!isModuleMissing) {
-                throw err;
-            }
-        }
+        platform = createNodePlatform({
+            customHome: options.customHome,
+            dataDir: options.dataDir,
+            rootDir: projectRoot,
+        });
     }
     for (const pkg of packages) {
         if (typeof pkg === "object" && pkg !== null && !("info" in pkg)) {
@@ -210,7 +215,7 @@ export async function resolveTarget(options) {
             }
         }
     }
-    const target = await createActionDockTarget({
+    const service = await createActionDock({
         type: "local",
         projectRoot,
         packages: packages.length > 0 ? packages : undefined,
@@ -225,24 +230,30 @@ export async function resolveTarget(options) {
         dataDir: options.dataDir,
         platform,
     });
-    return { target, ownsTarget: true };
+    return { service, ownsService: true };
 }
 /**
- * 创建并配置基于 ActionDockTarget 的 McpServer 适配层实例。
+ * 创建并配置基于 ActionDockService 的 McpServer 适配层实例。
  */
 export async function createActionDockMcpServer(options = {}) {
-    const { target } = await resolveTarget(options);
+    const { service } = await resolveService(options);
+    const allowedPackageIds = options.packageAllowlist && options.packageAllowlist.length > 0
+        ? options.packageAllowlist
+        : options.packageIds && options.packageIds.length > 0
+            ? options.packageIds
+            : options.packageId
+                ? [options.packageId]
+                : undefined;
     let serverName = "actiondock";
     let serverVersion = ACTIONDOCK_VERSION;
     try {
-        const info = await target.info();
-        if (info) {
-            serverName = info.name || info.id || "actiondock";
-            serverVersion = info.protocolVersion || ACTIONDOCK_VERSION;
-            if (info.packages && info.packages.length === 1) {
-                serverName = info.packages[0].name || info.packages[0].id || serverName;
-                serverVersion = info.packages[0].version || serverVersion;
-            }
+        let packages = await service.info();
+        if (allowedPackageIds && allowedPackageIds.length > 0) {
+            packages = packages.filter((p) => p.id && allowedPackageIds.includes(p.id));
+        }
+        if (packages && packages.length === 1) {
+            serverName = packages[0].name || packages[0].id || serverName;
+            serverVersion = packages[0].version || serverVersion;
         }
     }
     catch {
@@ -253,26 +264,46 @@ export async function createActionDockMcpServer(options = {}) {
         version: serverVersion,
     });
     // 任务规范扩展注册集中隔离在独立模块，本层不再直接操作 SDK 内层实例
-    registerTasksExtension(server, target);
-    // 工具注册与模式映射：tools/list 纯粹委托 target.listActions()
-    const rawActions = await target.listActions();
-    const seenActionKeys = new Map();
+    registerTasksExtension(server, service, allowedPackageIds, options.actionAllowlist);
+    // 工具注册与模式映射：tools/list 纯粹委托 service.discovery.listActions()
+    let rawActions = await service.discovery.listActions();
+    // 引用解析单点归一：每项仅解析一次，后续各轮（白名单过滤、去重、频次统计、
+    // 工具命名）复用同一结果，避免同一列表对 splitActionRef 的三轮重复调用；
+    // 显式 packageId 与解析所得 packageId 分别留存，各轮按既有优先级消费
+    const parsedRefs = new Map();
     for (const act of rawActions) {
-        let pkgId = act.packageId || "";
-        let actId = act.id;
         if (act.id.includes("/")) {
-            try {
-                const parsed = ActionResolver.parseRef(act.id);
-                pkgId = pkgId || parsed.packageId || "";
-                actId = parsed.actionId;
-            }
-            catch {
-                const idx = act.id.lastIndexOf("/");
-                pkgId = pkgId || act.id.slice(0, idx);
-                actId = act.id.slice(idx + 1);
-            }
+            const parsed = splitActionRef(act.id);
+            parsedRefs.set(act, {
+                explicitPkgId: act.packageId || "",
+                parsedPkgId: parsed.packageId,
+                baseId: parsed.actionId,
+            });
+        }
+        else {
+            parsedRefs.set(act, { explicitPkgId: act.packageId || "", baseId: act.id });
         }
-        const key = `${pkgId}:${actId}`;
+    }
+    if (allowedPackageIds && allowedPackageIds.length > 0) {
+        // 白名单轮：显式 packageId 优先，缺失时回退解析所得
+        rawActions = rawActions.filter((act) => {
+            const ref = parsedRefs.get(act);
+            const pkgId = ref.explicitPkgId || ref.parsedPkgId || "";
+            return pkgId ? allowedPackageIds.includes(pkgId) : false;
+        });
+    }
+    if (options.actionAllowlist && options.actionAllowlist.length > 0) {
+        rawActions = rawActions.filter((act) => {
+            const ref = parsedRefs.get(act);
+            const pkgId = ref.explicitPkgId || ref.parsedPkgId || undefined;
+            return isActionAllowed({ packageId: pkgId, actionId: ref.baseId }, options.actionAllowlist);
+        });
+    }
+    const seenActionKeys = new Map();
+    for (const act of rawActions) {
+        const ref = parsedRefs.get(act);
+        const pkgId = ref.explicitPkgId || ref.parsedPkgId || "";
+        const key = `${pkgId}:${ref.baseId}`;
         const existing = seenActionKeys.get(key);
         if (existing) {
             // 若已存在的项是全限定名（含 /），而当前项是短名（不含 /），优先保留短名项
@@ -288,35 +319,24 @@ export async function createActionDockMcpServer(options = {}) {
     // 统计 Action 基础 ID 出现频次，用于同名冲突命名空间隔离
     const baseCounts = new Map();
     for (const act of actions) {
-        let baseId = act.id;
-        if (act.id.includes("/")) {
-            try {
-                const parsed = ActionResolver.parseRef(act.id);
-                baseId = parsed.actionId;
-            }
-            catch {
-                const idx = act.id.lastIndexOf("/");
-                baseId = act.id.slice(idx + 1);
-            }
-        }
+        const baseId = parsedRefs.get(act).baseId;
         baseCounts.set(baseId, (baseCounts.get(baseId) || 0) + 1);
     }
     const registeredToolNames = new Set();
+    // 多包判定（循环外一次算清）：不同 packageId 去重计数大于 1，
+    // 或任一 id 含斜杠（跨包限定名形态），则工具描述需附全限定 id 锚点；
+    // 本轮与工具命名轮一致：解析所得 packageId 优先，缺失时回退显式声明
+    const distinctPackageIds = new Set(actions
+        .map((a) => {
+        const ref = parsedRefs.get(a);
+        return ref.parsedPkgId || a.packageId;
+    })
+        .filter((pkg) => Boolean(pkg)));
+    const isMultiPackage = distinctPackageIds.size > 1 || actions.some((a) => a.id.includes("/"));
     for (const action of actions) {
-        let baseId = action.id;
-        let packageId = action.packageId;
-        if (action.id.includes("/")) {
-            try {
-                const parsed = ActionResolver.parseRef(action.id);
-                packageId = parsed.packageId || packageId;
-                baseId = parsed.actionId;
-            }
-            catch {
-                const idx = action.id.lastIndexOf("/");
-                packageId = packageId || action.id.slice(0, idx);
-                baseId = action.id.slice(idx + 1);
-            }
-        }
+        const ref = parsedRefs.get(action);
+        const baseId = ref.baseId;
+        const packageId = ref.parsedPkgId || action.packageId;
         const count = baseCounts.get(baseId) || 1;
         let toolName = baseId;
         if (count > 1 && packageId) {
@@ -335,11 +355,10 @@ export async function createActionDockMcpServer(options = {}) {
             throw toolNameCollisionError(toolName);
         }
         registeredToolNames.add(toolName);
-        const isMultiPackage = actions.some((a) => a.id.includes("/") || (a.packageId && a.packageId !== actions[0].packageId));
         const description = isMultiPackage
             ? `[${action.id}] ${action.description || ""}`.trim()
             : action.description;
-        // 工具执行：tools/call 委托 target.runAction() 或 target.startAction()
+        // 工具执行：tools/call 委托 service.execution.run() 或 service.execution.start()
         server.registerTool(toolName, {
             description,
             inputSchema: toMcpSchema(action.inputSchema),
@@ -350,7 +369,7 @@ export async function createActionDockMcpServer(options = {}) {
         }, async (input, ctx) => {
             // 异步执行模式只认显式约定字段 execution.mode，旧版 __async 仅作只读兼容探测
             const isAsync = isAsyncExecutionRequested(input);
-            const signal = ctx.mcpReq?.signal;
+            const signal = extractCancelSignal(ctx);
             // 分发前仅剥离适配层注入的包装字段，业务自有字段（含名为 async 的入参）原样透传
             const cleanInput = stripExecutionWrapper(input);
             // 超时组合策略：客户端声明与服务端配置同时存在时取较小值（更防御），
@@ -360,7 +379,7 @@ export async function createActionDockMcpServer(options = {}) {
                 ? Math.min(options.timeoutMs, clientTimeoutMs)
                 : clientTimeoutMs ?? options.timeoutMs;
             if (isAsync) {
-                const ticket = await target.startAction(action.id, cleanInput, {
+                const ticket = await service.execution.start(action.id, cleanInput, {
                     signal,
                     timeoutMs: effectiveTimeoutMs,
                 });
@@ -378,7 +397,7 @@ export async function createActionDockMcpServer(options = {}) {
                     ],
                 };
             }
-            const result = await target.runAction(action.id, cleanInput, {
+            const result = await service.execution.run(action.id, cleanInput, {
                 signal,
                 timeoutMs: effectiveTimeoutMs,
             });
@@ -388,14 +407,17 @@ export async function createActionDockMcpServer(options = {}) {
     // 任务规范映射（tasks/get、tasks/cancel、tasks/list）已收敛至 registerTasksExtension 隔离模块
     // 资源与规程映射：规程映射为只读 MCP Resource 与 Prompt
     try {
-        const playbooks = await target.listPlaybooks();
+        let playbooks = await service.discovery.listPlaybooks();
+        if (allowedPackageIds && allowedPackageIds.length > 0) {
+            playbooks = playbooks.filter((pb) => pb.packageId && allowedPackageIds.includes(pb.packageId));
+        }
         for (const pb of playbooks) {
             server.registerResource(pb.id, `playbook://${pb.id}`, {
                 title: pb.id,
                 description: pb.description,
                 mimeType: "text/markdown",
             }, async (uri) => {
-                const spec = await target.describePlaybook(pb.id);
+                const spec = await service.discovery.describePlaybook(pb.id);
                 return {
                     contents: [
                         {
@@ -410,7 +432,7 @@ export async function createActionDockMcpServer(options = {}) {
                 title: pb.id,
                 description: pb.description,
             }, async () => {
-                const spec = await target.describePlaybook(pb.id);
+                const spec = await service.discovery.describePlaybook(pb.id);
                 return {
                     messages: [
                         {
@@ -429,16 +451,16 @@ export async function createActionDockMcpServer(options = {}) {
         // 规程获取或注册失败不中断适配器启动，但输出诊断行保留排障线索
         console.error(`[actiondock-mcp] Failed to register playbook resources/prompts: ${err?.message || String(err)}`);
     }
-    // 服务生命周期：默认 close 仅关闭 MCP 服务本身，不级联 target——
-    // SDK 传输层（HTTP 每请求 / stdio 探测回落）会销毁工厂产物，若 close 级联会误杀共享 target；
-    // 需要「一次 close 同时释放 target」的独立持有方显式传 cascadeTargetClose
+    // 服务生命周期：默认 close 仅关闭 MCP 服务本身，不级联 service——
+    // SDK 传输层（HTTP 每请求 / stdio 探测回落）会销毁工厂产物，若 close 级联会误杀共享 service；
+    // 需要「一次 close 同时释放 service」的独立持有方显式传 cascadeServiceClose
     const originalClose = server.close.bind(server);
     let isClosed = false;
     const closeFn = async () => {
         if (isClosed)
             return;
         isClosed = true;
-        // 清理异常不吞没：先关服务再级联目标，server 关闭失败也继续释放 target 并聚合上抛
+        // 清理异常不吞没：先关服务再级联目标，server 关闭失败也继续释放 service 并聚合上抛
         let closeError;
         try {
             await originalClose();
@@ -446,13 +468,13 @@ export async function createActionDockMcpServer(options = {}) {
         catch (err) {
             closeError = err;
         }
-        if (options.cascadeTargetClose) {
+        if (options.cascadeServiceClose) {
             try {
-                await target.close();
+                await service.close();
             }
             catch (err) {
                 if (closeError !== undefined) {
-                    throw new AggregateError([closeError, err], "Failed to close MCP server and target");
+                    throw new AggregateError([closeError, err], "Failed to close MCP server and service");
                 }
                 throw err;
             }
@@ -463,9 +485,10 @@ export async function createActionDockMcpServer(options = {}) {
     };
     const decorated = server;
     decorated.close = closeFn;
-    decorated.target = target;
+    decorated.service = service;
     decorated.host = options.host;
-    decorated.app = options.app;
-    decorated.events = (runId, opts) => target.events(runId, opts);
+    if (service.events) {
+        decorated.events = (runId, opts) => service.events.events(runId, opts);
+    }
     return decorated;
 }

package/dist/http.js

@@ -1,6 +1,7 @@
-import { ACTIONDOCK_VERSION, DEFAULT_MAX_BODY_BYTES, formatHostForUrl, isLoopbackHost, launchHttpServer, resolveCorsHeaders, verifyBearerToken, UNAUTHORIZED, } from "@actiondock/core";
+import { ACTIONDOCK_VERSION, UNAUTHORIZED } from "@actiondock/core";
+import { createMcpEndpointHandler, formatHostForUrl, isLoopbackHost, launchHttpServer, resolveCorsHeaders, verifyBearerToken, } from "@actiondock/core/server";
 import { createMcpHandler } from "@modelcontextprotocol/server";
-import { createActionDockMcpServer, resolveTarget } from "./adapter.js";
+import { createActionDockMcpServer, resolveService } from "./adapter.js";
 /**
  * Starts an ActionDock MCP server over HTTP transport.
  */
@@ -16,23 +17,52 @@ export function startMcpHttpServer(options = {}) {
     // 由 allowInsecureNoAuth 与 token 策略约束，传入该字段不会产生任何效果，
     // 检测到时输出警告避免调用方误以为已生效
     if (options.allowInsecureHttp === true) {
-        process.stderr.write("[MCP HTTP Warning] allowInsecureHttp has no effect on the server side and is deprecated; it only applies to remote ActionDockTarget clients.\n");
+        process.stderr.write("[MCP HTTP Warning] allowInsecureHttp has no effect on the server side and is deprecated; it only applies to remote ActionDock clients.\n");
     }
     // Non-loopback address requires token authentication by default
     if (!isLoopbackHost(host) && !token && !options.allowInsecureNoAuth) {
         throw new Error("Authentication token is required when binding to a non-loopback address. Use --allow-insecure-no-auth to override.");
     }
     return (async () => {
-        // 先一次性解析 target，工厂闭包直接捕获已解析产物，消除选项重复展开
-        const { target } = await resolveTarget({
+        // 先一次性解析 service，工厂闭包直接捕获已解析产物，消除选项重复展开
+        const { service } = await resolveService({
             ...options,
             host: hostInstance ?? (typeof options.host === "object" ? options.host : undefined),
         });
-        const handler = createMcpHandler(() => createActionDockMcpServer({ target }), {
+        const resolvedHost = hostInstance ?? (typeof options.host === "object" ? options.host : undefined);
+        const handler = createMcpHandler(() => createActionDockMcpServer({ ...options, host: resolvedHost, service }), {
             onerror: (err) => {
                 process.stderr.write(`[MCP HTTP Error] ${err?.message || String(err)}\n`);
             },
         });
+        // JSON-RPC 形态的 401 响应构造：mcp 客户端按 JSON-RPC 错误信封消费鉴权失败
+        // （错误码 -32000），区别于 core 网关的标准 JSON 信封
+        const unauthorizedJsonRpcResponse = (corsHeaders) => new Response(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+                code: -32000,
+                message: "Unauthorized: Invalid or missing Bearer token",
+            },
+            id: null,
+        }), {
+            status: 401,
+            headers: {
+                "Content-Type": "application/json",
+                ...corsHeaders,
+            },
+        });
+        // MCP 端点共享处理器：Bearer 鉴权（401 JSON-RPC 形态）→ 请求体有界读取
+        // （413 拦截）→ 重建 Request 委托 SDK 处理器 → CORS merge 回写。
+        // 序列收敛为 core 单一事实源，此处仅以定制钩子表达 mcp 独立服务的差异
+        const mcpEndpoint = createMcpEndpointHandler((req) => handler.fetch(req), {
+            token,
+            allowQueryToken: options.allowQueryToken,
+            corsOrigins: options.corsOrigins,
+            maxBodyBytes: options.maxBodyBytes,
+            // mcp 独立服务将解析出的 CORS 头合并覆盖到 MCP 响应（core 网关为 inherit 透传）
+            corsApplyMode: "merge",
+            unauthorizedResponse: unauthorizedJsonRpcResponse,
+        });
         const server = await launchHttpServer(port, host, async (req) => {
             const origin = req.headers.get("origin");
             const corsHeaders = resolveCorsHeaders(origin, options.corsOrigins);
@@ -45,8 +75,8 @@ export function startMcpHttpServer(options = {}) {
             const url = new URL(req.url);
             const pathname = url.pathname;
             const verifyOptions = { allowQueryToken: options.allowQueryToken };
-            // 1. Health check
-            if (pathname === "/health" || pathname === "/api/v1/health") {
+            // 健康检查路由
+            if (pathname === "/health") {
                 if (!verifyBearerToken(req, token, verifyOptions)) {
                     return new Response(JSON.stringify({
                         ok: false,
@@ -75,111 +105,13 @@ export function startMcpHttpServer(options = {}) {
                     },
                 });
             }
-            // 2. Authentication check
-            if (!verifyBearerToken(req, token, verifyOptions)) {
-                return new Response(JSON.stringify({
-                    jsonrpc: "2.0",
-                    error: {
-                        code: -32000,
-                        message: "Unauthorized: Invalid or missing Bearer token",
-                    },
-                    id: null,
-                }), {
-                    status: 401,
-                    headers: {
-                        "Content-Type": "application/json",
-                        ...corsHeaders,
-                    },
-                });
-            }
-            // 3. Delegate MCP endpoint
+            // 委托 MCP 端点（/mcp 与 / 双路径，鉴权与限流由共享端点处理器承担）
             if (pathname === "/mcp" || pathname === "/") {
-                const maxBytes = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
-                const contentLengthHeader = req.headers.get("content-length");
-                if (contentLengthHeader) {
-                    const parsedLength = parseInt(contentLengthHeader, 10);
-                    if (!isNaN(parsedLength) && parsedLength > maxBytes) {
-                        return new Response(JSON.stringify({
-                            ok: false,
-                            error: {
-                                code: "REQUEST_TOO_LARGE",
-                                message: "Request body exceeds maximum allowed size",
-                            },
-                        }), {
-                            status: 413,
-                            headers: {
-                                "Content-Type": "application/json",
-                                ...corsHeaders,
-                            },
-                        });
-                    }
-                }
-                let currentReq = req;
-                if (req.body && req.method !== "GET" && req.method !== "HEAD") {
-                    const reader = req.body.getReader();
-                    const chunks = [];
-                    let totalBytes = 0;
-                    let tooLarge = false;
-                    try {
-                        while (true) {
-                            const { done, value } = await reader.read();
-                            if (done)
-                                break;
-                            if (value) {
-                                totalBytes += value.byteLength;
-                                if (totalBytes > maxBytes) {
-                                    tooLarge = true;
-                                    await reader.cancel();
-                                    break;
-                                }
-                                chunks.push(value);
-                            }
-                        }
-                    }
-                    finally {
-                        reader.releaseLock();
-                    }
-                    if (tooLarge) {
-                        return new Response(JSON.stringify({
-                            ok: false,
-                            error: {
-                                code: "REQUEST_TOO_LARGE",
-                                message: "Request body exceeds maximum allowed size",
-                            },
-                        }), {
-                            status: 413,
-                            headers: {
-                                "Content-Type": "application/json",
-                                ...corsHeaders,
-                            },
-                        });
-                    }
-                    const merged = new Uint8Array(totalBytes);
-                    let offset = 0;
-                    for (const chunk of chunks) {
-                        merged.set(chunk, offset);
-                        offset += chunk.byteLength;
-                    }
-                    currentReq = new Request(req.url, {
-                        method: req.method,
-                        headers: req.headers,
-                        body: merged,
-                        signal: req.signal,
-                    });
-                }
-                const mcpResponse = await handler.fetch(currentReq);
-                if (Object.keys(corsHeaders).length > 0) {
-                    const newHeaders = new Headers(mcpResponse.headers);
-                    for (const [k, v] of Object.entries(corsHeaders)) {
-                        newHeaders.set(k, String(v));
-                    }
-                    return new Response(mcpResponse.body, {
-                        status: mcpResponse.status,
-                        statusText: mcpResponse.statusText,
-                        headers: newHeaders,
-                    });
-                }
-                return mcpResponse;
+                return (await mcpEndpoint(req));
+            }
+            // 其余路径统一鉴权拦截：未认证访问任意未知路径返回 401 而非 404
+            if (!verifyBearerToken(req, token, verifyOptions)) {
+                return unauthorizedJsonRpcResponse(corsHeaders);
             }
             return new Response(JSON.stringify({
                 error: "Not Found",
@@ -201,10 +133,10 @@ export function startMcpHttpServer(options = {}) {
             port: server.port ?? port,
             host,
             url,
-            target,
+            service,
             stop: async () => {
-                // 先停 HTTP 服务（等待在途请求收尾）再释放 target：
-                // 若先关 target，在途请求的后续 Action 调用会全部异常
+                // 先停 HTTP 服务（等待在途请求收尾）再释放 service：
+                // 若先关 service，在途请求的后续 Action 调用会全部异常
                 let serverError;
                 try {
                     await server.stop(true);
@@ -213,13 +145,13 @@ export function startMcpHttpServer(options = {}) {
                     serverError = err;
                 }
                 try {
-                    await target.close();
+                    await service.close();
                 }
-                catch (targetErr) {
+                catch (serviceErr) {
                     if (serverError) {
-                        throw new AggregateError([serverError, targetErr], "Failed to stop MCP HTTP server and target");
+                        throw new AggregateError([serverError, serviceErr], "Failed to stop MCP HTTP server and service");
                     }
-                    throw targetErr;
+                    throw serviceErr;
                 }
                 if (serverError) {
                     throw serverError;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./types.js";
 export * from "./schemas.js";
 export * from "./execution-mode.js";
+export { toMcpTaskStatus, toMcpTaskPayload, type McpTaskStatus, type McpTaskPayload } from "./register-tasks-extension.js";
 export * from "./adapter.js";
 export * from "./stdio.js";
 export * from "./http.js";

package/dist/index.js

@@ -1,6 +1,8 @@
 export * from "./types.js";
 export * from "./schemas.js";
 export * from "./execution-mode.js";
+// 任务规范纯函数迁入 register-tasks-extension 后，从此处转引保持包根导出面不变
+export { toMcpTaskStatus, toMcpTaskPayload } from "./register-tasks-extension.js";
 export * from "./adapter.js";
 export * from "./stdio.js";
 export * from "./http.js";

package/dist/register-tasks-extension.d.ts

@@ -1,9 +1,34 @@
-import type { ActionDockTarget } from "@actiondock/core";
+import type { ActionDockService } from "@actiondock/core";
+import type { RunRecord, RunStatus } from "@actiondock/sdk";
 import { McpServer } from "@modelcontextprotocol/server";
+/**
+ * MCP 任务状态枚举（兼容 Model Context Protocol Task 规范）。
+ */
+export type McpTaskStatus = "working" | "completed" | "failed" | "cancelled";
+/**
+ * MCP 任务状态数据载荷结构体。
+ */
+export interface McpTaskPayload {
+    taskId: string;
+    status: McpTaskStatus;
+    createdAt: string;
+    finishedAt?: string;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+}
+/**
+ * 将 ActionDock 内部的 RunStatus 转换为 MCP 标准的 TaskStatus。
+ */
+export declare function toMcpTaskStatus(status: RunStatus): McpTaskStatus;
+/**
+ * 将内部 RunRecord 实体转换为向 MCP 客户端暴露的 McpTaskPayload。
+ */
+export declare function toMcpTaskPayload(run: RunRecord): McpTaskPayload;
 /**
  * 在低层 Server 实例上注册 tasks 能力声明与三个请求处理器。
  *
  * @param server MCP 高层服务实例
- * @param target ActionDockTarget 公共契约门面
+ * @param service ActionDockService 公共服务实例
  */
-export declare function registerTasksExtension(server: McpServer, target: ActionDockTarget): void;
+export declare function registerTasksExtension(server: McpServer, service: ActionDockService, allowedPackageIds?: string[], actionAllowlist?: string[]): void;

package/dist/register-tasks-extension.js

@@ -1,5 +1,38 @@
+import { isActionAllowed } from "@actiondock/core/server";
 import { fromJsonSchema } from "@modelcontextprotocol/server";
-import { toMcpTaskPayload, toMcpTaskStatus } from "./types.js";
+/**
+ * 将 ActionDock 内部的 RunStatus 转换为 MCP 标准的 TaskStatus。
+ */
+export function toMcpTaskStatus(status) {
+    switch (status) {
+        case "running":
+            return "working";
+        case "success":
+            return "completed";
+        case "failed":
+        case "timed_out":
+        case "interrupted":
+            return "failed";
+        case "cancelled":
+            return "cancelled";
+        default:
+            return "failed";
+    }
+}
+/**
+ * 将内部 RunRecord 实体转换为向 MCP 客户端暴露的 McpTaskPayload。
+ */
+export function toMcpTaskPayload(run) {
+    return {
+        taskId: run.id,
+        status: toMcpTaskStatus(run.status),
+        createdAt: run.startedAt,
+        finishedAt: run.finishedAt,
+        input: run.input,
+        output: run.output,
+        error: run.error,
+    };
+}
 /** JSON-RPC 保留码段：协议保留区为 -32000 至 -32099，服务端自定义错误码必须落在该区段内。 */
 const TASK_NOT_FOUND_CODE = -32001;
 /** 无效的 limit 参数错误码，同样落在服务端自定义码段。 */
@@ -53,9 +86,9 @@ function toTimeMillis(value) {
  * 在低层 Server 实例上注册 tasks 能力声明与三个请求处理器。
  *
  * @param server MCP 高层服务实例
- * @param target ActionDockTarget 公共契约门面
+ * @param service ActionDockService 公共服务实例
  */
-export function registerTasksExtension(server, target) {
+export function registerTasksExtension(server, service, allowedPackageIds, actionAllowlist) {
     server.server.registerCapabilities({
         tasks: {
             list: {},
@@ -63,23 +96,51 @@ export function registerTasksExtension(server, target) {
         },
     });
     server.server.setRequestHandler("tasks/get", { params: TASK_ID_PARAMS }, async (params) => {
-        const run = await target.getRun(params.taskId);
+        const run = await service.runs.get(params.taskId);
         if (!run) {
             // 携带语义码透传，避免被 SDK 映射为内部错误
             throw taskNotFoundError(params.taskId);
         }
+        if (allowedPackageIds &&
+            allowedPackageIds.length > 0 &&
+            (!run.packageId || !allowedPackageIds.includes(run.packageId))) {
+            throw taskNotFoundError(params.taskId);
+        }
+        if (actionAllowlist &&
+            actionAllowlist.length > 0 &&
+            !isActionAllowed({ packageId: run.packageId, actionId: run.actionId }, actionAllowlist)) {
+            throw taskNotFoundError(params.taskId);
+        }
         return { task: toMcpTaskPayload(run) };
     });
     server.server.setRequestHandler("tasks/cancel", { params: TASK_ID_PARAMS }, async (params) => {
+        const hasPackageFilter = Boolean(allowedPackageIds && allowedPackageIds.length > 0);
+        const hasActionFilter = Boolean(actionAllowlist && actionAllowlist.length > 0);
+        if (hasPackageFilter || hasActionFilter) {
+            const existingRun = await service.runs.get(params.taskId);
+            if (!existingRun) {
+                throw taskNotFoundError(params.taskId);
+            }
+            if (hasPackageFilter) {
+                if (!existingRun.packageId || !allowedPackageIds.includes(existingRun.packageId)) {
+                    throw taskNotFoundError(params.taskId);
+                }
+            }
+            if (hasActionFilter) {
+                if (!isActionAllowed({ packageId: existingRun.packageId, actionId: existingRun.actionId }, actionAllowlist)) {
+                    throw taskNotFoundError(params.taskId);
+                }
+            }
+        }
         const reason = params.reason || "Cancelled via MCP tasks/cancel";
-        const cancelRes = await target.cancelRun(params.taskId, reason);
+        const cancelRes = await service.runs.cancel(params.taskId, reason);
         if (cancelRes.outcome === "requested") {
             return { taskId: params.taskId, status: "cancelled" };
         }
         if (cancelRes.outcome === "already_terminal") {
             return { taskId: params.taskId, status: toMcpTaskStatus(cancelRes.status) };
         }
-        const run = await target.getRun(params.taskId);
+        const run = await service.runs.get(params.taskId);
         if (!run) {
             // 携带语义码透传，避免被 SDK 映射为内部错误
             throw taskNotFoundError(params.taskId);
@@ -96,8 +157,14 @@ export function registerTasksExtension(server, target) {
             limit = Math.min(Math.max(params.limit, 1), MAX_TASK_LIST_LIMIT);
         }
         const actionId = params.actionId;
-        // limit 单处截断：下推到 target.listRuns 的 limit 参数，此处不再重复 slice
-        const runs = await target.listRuns({ limit, actionId });
+        // limit 单处截断：下推到 service.runs.list 的 limit 参数，此处不再重复 slice
+        let runs = await service.runs.list({ limit, actionId });
+        if (allowedPackageIds && allowedPackageIds.length > 0) {
+            runs = runs.filter((r) => Boolean(r.packageId && allowedPackageIds.includes(r.packageId)));
+        }
+        if (actionAllowlist && actionAllowlist.length > 0) {
+            runs = runs.filter((r) => isActionAllowed({ packageId: r.packageId, actionId: r.actionId }, actionAllowlist));
+        }
         const ordered = [...runs].sort((a, b) => toTimeMillis(b.startedAt) - toTimeMillis(a.startedAt));
         return { tasks: ordered.map(toMcpTaskPayload) };
     });

package/dist/stdio-host.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { serveParentIpc } from "@actiondock/core";
-import { resolveTarget } from "./adapter.js";
+import { serveParentIpc } from "@actiondock/core/server";
+import { resolveService } from "./adapter.js";
 try {
     const rawOptions = process.env.ACTIONDOCK_MCP_OPTIONS;
     const options = rawOptions ? JSON.parse(rawOptions) : {};
-    const { target } = await resolveTarget(options);
-    await serveParentIpc(target);
+    const { service } = await resolveService(options);
+    await serveParentIpc(service);
 }
 catch (err) {
     process.stderr.write(`[MCP Host Error] ${err?.stack || err?.message || String(err)}\n`);

package/dist/stdio.js

@@ -2,9 +2,9 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { IpcActionDockTarget } from "@actiondock/core";
+import { IpcActionDockService } from "@actiondock/core/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
-import { createActionDockMcpServer, resolveTarget } from "./adapter.js";
+import { createActionDockMcpServer, resolveService } from "./adapter.js";
 /**
  * 启动 ActionDock MCP STDIO 协议服务。
  * 建立监督进程物理边界：
@@ -15,11 +15,17 @@ import { createActionDockMcpServer, resolveTarget } from "./adapter.js";
  */
 export async function startMcpStdio(options = {}) {
     let activeServer;
-    let targetToUse;
+    let serviceToUse;
+    let ownsService = false;
     let childProcess;
-    // 若显式传入了已构造的 target 或不可序列化的内存对象，直接复用或解析目标实例
-    if (options.target || options.actions || options.storage || options.app || options.host || options.platform) {
-        targetToUse = options.target ?? (await resolveTarget(options)).target;
+    // 若显式传入了已构造的 service 或不可序列化的内存对象，直接复用或解析目标实例；
+    // ownsService 标记与 adapter 的所有权契约对齐：仅自建实例由本入口的 cleanup 收敛生命周期
+    if (options.service || options.actions || options.storage || options.runtime || options.host || options.platform) {
+        const resolved = options.service
+            ? { service: options.service, ownsService: false }
+            : await resolveService(options);
+        serviceToUse = resolved.service;
+        ownsService = resolved.ownsService;
     }
     else {
         // 建立隔离的监督子进程
@@ -44,20 +50,22 @@ export async function startMcpStdio(options = {}) {
             stdio: ["pipe", "pipe", "pipe", "ipc"],
         });
         // 标准输出物理隔离与受控限流排空转入 stderr 诊断流
-        targetToUse = new IpcActionDockTarget({
+        serviceToUse = new IpcActionDockService({
             childProcess,
             maxDiagnosticBytes: 512 * 1024,
             maxDiagnosticRate: 64 * 1024,
             diagnosticTarget: process.stderr,
         });
+        // IPC 代理实例由本入口创建，生命周期归本入口的 cleanup 所有
+        ownsService = true;
     }
     const stdioHandler = serveStdio(async () => {
         const server = await createActionDockMcpServer({
             ...options,
-            target: targetToUse,
+            service: serviceToUse,
         });
         activeServer = server;
-        targetToUse = targetToUse || server.target;
+        serviceToUse = serviceToUse || server.service;
         return server;
     }, {
         onerror: (err) => {
@@ -80,9 +88,11 @@ export async function startMcpStdio(options = {}) {
                 swallow(err);
             }
         }
-        if (targetToUse) {
+        if (serviceToUse && ownsService) {
+            // 外部注入的 service（ownsService 为 false）生命周期归调用方，这里不越权关闭；
+            // 自建实例（含 IPC 子进程代理）由本入口统一收敛
             try {
-                await targetToUse.close();
+                await serviceToUse.close();
             }
             catch (err) {
                 swallow(err);

package/dist/types.d.ts

@@ -1,40 +1,18 @@
-import type { ActionDockApp, ActionDockHost, ActionDockTarget, RuntimeStorage, ServerTlsOptions } from "@actiondock/core";
-import type { ActionDefinition, RunRecord, RunStatus } from "@actiondock/sdk";
-/**
- * MCP 任务状态枚举（兼容 Model Context Protocol Task 规范）。
- */
-export type McpTaskStatus = "working" | "completed" | "failed" | "cancelled";
-/**
- * MCP 任务状态数据载荷结构体。
- */
-export interface McpTaskPayload {
-    taskId: string;
-    status: McpTaskStatus;
-    createdAt: string;
-    finishedAt?: string;
-    input?: unknown;
-    output?: unknown;
-    error?: unknown;
-}
-/**
- * 将 ActionDock 内部的 RunStatus 转换为 MCP 标准的 TaskStatus。
- */
-export declare function toMcpTaskStatus(status: RunStatus): McpTaskStatus;
-/**
- * 将内部 RunRecord 实体转换为向 MCP 客户端暴露的 McpTaskPayload。
- */
-export declare function toMcpTaskPayload(run: RunRecord): McpTaskPayload;
+import type { ActionDockService } from "@actiondock/core";
+import type { ActionDockHost, ServerTlsOptions } from "@actiondock/core/server";
+import type { PackageRuntime, RuntimePlatform, RuntimeStorage } from "@actiondock/core/package";
+import type { ActionDefinition } from "@actiondock/sdk";
 /**
  * ActionDock MCP 适配层初始化选项。
- * 统一以 target（及可选 host, app）为核心。
+ * 统一以 service（及可选 host, runtime）为核心。
  */
 export interface ActionDockMcpOptions {
-    /** 目标 ActionDockTarget 门面实例（最高优先级） */
-    target?: ActionDockTarget;
+    /** 目标 ActionDockService 标准服务端口实例 */
+    service?: ActionDockService;
     /** 目标 ActionDockHost 宿主实例 */
     host?: ActionDockHost;
-    /** 目标 ActionDockApp 应用实例 */
-    app?: ActionDockApp;
+    /** 目标 PackageRuntime 应用运行时实例 */
+    runtime?: PackageRuntime;
     /** 单个目标项目根目录 */
     projectRoot?: string;
     /** 多个项目根目录（用于多包聚合提供） */
@@ -43,6 +21,10 @@ export interface ActionDockMcpOptions {
     packageId?: string;
     /** 多个 Package ID 列表 */
     packageIds?: string[];
+    /** 允许访问执行的 Package ID 白名单列表（为空允许全部） */
+    packageAllowlist?: string[];
+    /** 允许暴露执行的 Action 标识白名单列表（为空允许全部，支持短名或 packageId/actionId） */
+    actionAllowlist?: string[];
     /** 是否聚合暴露全局 Registry 中的所有 Package */
     all?: boolean;
     /** 自定义家目录路径 */
@@ -50,7 +32,7 @@ export interface ActionDockMcpOptions {
     /** 自定义全局数据存储目录 */
     dataDir?: string;
     /** 运行时底层平台适配（如提供 NodeProcessDriver 的平台实例） */
-    platform?: import("@actiondock/core").RuntimePlatform;
+    platform?: RuntimePlatform;
     /** 配置动态覆盖项 */
     configOverrides?: Record<string, unknown>;
     /** 单个 Tool 执行超时时间（毫秒） */
@@ -66,18 +48,20 @@ export interface ActionDockMcpOptions {
     storage?: RuntimeStorage;
     /**
      * 是否由适配层接管外部注入 storage 的生命周期。
-     * 默认 false：外部注入的 storage 由注入方自行管理，适配层不具各 close 语义；
-     * 置为 true 时透传原始实例，随 target.close() 级联关闭。
+     * 默认 false：外部注入的 storage 由注入方自行管理，适配层不具备 close 语义；
+     * 置为 true 时透传原始实例，随 service.close() 级联关闭。
      */
     ownStorageLifecycle?: boolean;
     /**
-     * 实例 close 是否级联关闭 target 门面。
+     * 实例 close 是否级联关闭 service 门面。
      * 默认 false：适配层产物可能被 SDK 传输层按请求（或按连接）创建与销毁，
-     * 级联语义会误杀共享 target，生命周期统一由外层入口的 stop/cleanup 收敛；
-     * 仅在调用方自行持有实例并需要一次 close 同时释放 target 时置 true。
+     * 级联语义会误杀共享 service，生命周期统一由外层入口的 stop/cleanup 收敛；
+     * 仅在调用方自行持有实例并需要一次 close 同时释放 service 时置 true。
      */
-    cascadeTargetClose?: boolean;
+    cascadeServiceClose?: boolean;
 }
+/** ActionDock MCP 适配层初始化选项别名 */
+export type ActionDockMcpServerOptions = ActionDockMcpOptions;
 /**
  * HTTP 传输协议安全配置项。
  */
@@ -87,11 +71,6 @@ export interface HttpSecurityOptions {
     token?: string;
     allowInsecureNoAuth?: boolean;
     allowQueryToken?: boolean;
-    /**
-     * 已废弃：该选项仅适用于远程 ActionDockTarget 客户端侧的明文 HTTP 豁免，
-     * 服务端监听安全性由 allowInsecureNoAuth 与 token 策略约束，传入不会产生任何效果；
-     * 服务端检测到该字段时仅输出警告日志
-     */
     allowInsecureHttp?: boolean;
     corsOrigins?: string[];
     maxBodyBytes?: number;
@@ -105,6 +84,6 @@ export interface ActionDockMcpHttpServerInstance {
     port: number;
     host: string;
     url: string;
-    target?: ActionDockTarget;
+    service: ActionDockService;
     stop: () => Promise<void>;
 }

package/dist/types.js

@@ -1,33 +1 @@
-/**
- * 将 ActionDock 内部的 RunStatus 转换为 MCP 标准的 TaskStatus。
- */
-export function toMcpTaskStatus(status) {
-    switch (status) {
-        case "running":
-            return "working";
-        case "success":
-            return "completed";
-        case "failed":
-        case "timed_out":
-        case "interrupted":
-            return "failed";
-        case "cancelled":
-            return "cancelled";
-        default:
-            return "failed";
-    }
-}
-/**
- * 将内部 RunRecord 实体转换为向 MCP 客户端暴露的 McpTaskPayload。
- */
-export function toMcpTaskPayload(run) {
-    return {
-        taskId: run.id,
-        status: toMcpTaskStatus(run.status),
-        createdAt: run.startedAt,
-        finishedAt: run.finishedAt,
-        input: run.input,
-        output: run.output,
-        error: run.error,
-    };
-}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/mcp",
-  "version": "2.7.0",
+  "version": "2.9.0",
   "description": "ActionDock MCP Adapter for exposing Actions as Model Context Protocol (MCP) Tools",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,18 +29,10 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/core": "^2.7.0",
-    "@actiondock/sdk": "^2.7.0",
+    "@actiondock/core": "^2.9.0",
+    "@actiondock/sdk": "^2.9.0",
     "@modelcontextprotocol/server": "^2.0.0"
   },
-  "peerDependencies": {
-    "@actiondock/runtime-node": "^2.7.0"
-  },
-  "peerDependenciesMeta": {
-    "@actiondock/runtime-node": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "typescript": "^5.7.0"
   },