@actiondock/mcp 2.19.0 → 2.21.0

package/dist/adapter.d.ts

@@ -44,5 +44,7 @@ export type ActionDockMcpServer = McpServer & {
 };
 /**
  * 创建并配置基于 ActionDockService 的 McpServer 适配层实例。
+ * 在任何资源创建或包装载之前，先以 core 统一校验入口校验两份白名单声明：
+ * 数组结构、非法包标识、动作短名与通配符均 fail closed，违规抛 INVALID_ARGUMENT。
  */
 export declare function createActionDockMcpServer(options?: ActionDockMcpOptions): Promise<ActionDockMcpServer>;

package/dist/adapter.js

@@ -1,5 +1,6 @@
 import { ACTIONDOCK_VERSION } from "@actiondock/core";
 import { McpServer } from "@modelcontextprotocol/server";
+import { assertServerPolicyValid, isPackageAllowedByPolicy, } from "@actiondock/core/server";
 import { toMcpSchema } from "./schemas.js";
 import { resolveExecutionTimeout } from "./execution-mode.js";
 import { resolveService } from "./service-resolver.js";
@@ -65,23 +66,26 @@ export function toMcpResult(result) {
 }
 /**
  * 创建并配置基于 ActionDockService 的 McpServer 适配层实例。
+ * 在任何资源创建或包装载之前，先以 core 统一校验入口校验两份白名单声明：
+ * 数组结构、非法包标识、动作短名与通配符均 fail closed，违规抛 INVALID_ARGUMENT。
  */
 export async function createActionDockMcpServer(options = {}) {
+    // 授权声明前置校验（单一事实源：core assertServerPolicyValid），
+    // 覆盖 service/host/runtime/projectRoot/actions 等全部注入路径
+    assertServerPolicyValid(options, "mcp 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;
+    // 统一授权策略单一事实源：以 core EffectiveServerPolicy 表达两份白名单并集，
+    // 复用 core 策略函数判定，适配层不复制授权逻辑
+    const policy = {
+        packageAllowlist: options.packageAllowlist,
+        actionAllowlist: options.actionAllowlist,
+    };
     let serverName = "actiondock";
     let serverVersion = ACTIONDOCK_VERSION;
     try {
         let packages = await service.info();
-        if (allowedPackageIds && allowedPackageIds.length > 0) {
-            packages = packages.filter((p) => p.id && allowedPackageIds.includes(p.id));
-        }
+        // 包元数据按整包授权可见性收敛（含 * 全授权），单动作授权不推导整包身份
+        packages = packages.filter((p) => isPackageAllowedByPolicy(p.id, policy));
         if (packages && packages.length === 1) {
             serverName = packages[0].name || packages[0].id || serverName;
             serverVersion = packages[0].version || serverVersion;
@@ -90,13 +94,15 @@ export async function createActionDockMcpServer(options = {}) {
     catch {
         // 忽略元数据读取失败，使用默认值
     }
+    // 即使当前授权集合为空，tools/list 也应明确返回空列表而非未注册方法。
     const server = new McpServer({
         name: serverName,
         version: serverVersion,
-    });
-    // 工具注册与模式映射：tools/list 纯粹委托 service.discovery.listActions()
+    }, { capabilities: { tools: {} } });
+    // 工具注册与模式映射：tools/list 纯粹委托 service.discovery.listActions()；
+    // 过滤仅用单一 policy 并集判定，不先按包选择截断单动作授权目标
     let rawActions = await service.discovery.listActions();
-    const mappedActions = mapAndFilterActions(rawActions, allowedPackageIds, options.actionAllowlist);
+    const mappedActions = mapAndFilterActions(rawActions, undefined, undefined, policy);
     for (const { toolName, action, description } of mappedActions) {
         // 工具执行：tools/call 委托 service.execution.run()
         server.registerTool(toolName, {
@@ -116,12 +122,12 @@ export async function createActionDockMcpServer(options = {}) {
             return toMcpResult(result);
         });
     }
-    // 资源与规程映射：规程映射为只读 MCP Resource 与 Prompt
+    // 资源与规程映射：规程映射为只读 MCP Resource 与 Prompt。
+    // 仅整包授权（或 * 全授权）的包开放对应规程；
+    // 单动作授权（如 B/read）不得借资源或提示获取该包完整规程（防泄露）
     try {
         let playbooks = await service.discovery.listPlaybooks();
-        if (allowedPackageIds && allowedPackageIds.length > 0) {
-            playbooks = playbooks.filter((pb) => pb.packageId && allowedPackageIds.includes(pb.packageId));
-        }
+        playbooks = playbooks.filter((pb) => isPackageAllowedByPolicy(pb.packageId, policy));
         for (const pb of playbooks) {
             server.registerResource(pb.id, `playbook://${pb.id}`, {
                 title: pb.id,

package/dist/service-resolver.js

@@ -1,13 +1,18 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { ACTIONDOCK_VERSION, ActionDockError, createActionDock, createNodePlatform, findProjectRoot, PACKAGE_NOT_FOUND, PROJECT_ROOT_NOT_FOUND, } from "@actiondock/core";
-import { createActionDockHost } from "@actiondock/core/server";
+import { ACTIONDOCK_VERSION, ActionDockError, createActionDock, createNodePlatform, findProjectRoot, loadProjectConfig, PACKAGE_NOT_FOUND, PROJECT_ROOT_NOT_FOUND, } from "@actiondock/core";
+import { assertServerPolicyValid, createActionDockHost } from "@actiondock/core/server";
+import { parseActionRef } from "@actiondock/core/graph";
 import { resolvePackageRoot } from "@actiondock/core/registry";
 import { createNonClosingStorageView } from "@actiondock/core/package";
 /**
  * 解析或基于选项创建底层 ActionDockService 统一门面。
  */
 export async function resolveService(options) {
+    // 授权声明前置校验（单一事实源：core assertServerPolicyValid）：
+    // 在任何资源创建、包装载或注入实例复用之前执行，
+    // 覆盖 service/host/runtime 直接调用 resolveService 的入口
+    assertServerPolicyValid(options, "mcp options");
     if (options.service) {
         return { service: options.service, ownsService: false };
     }
@@ -63,9 +68,65 @@ export async function resolveService(options) {
             });
         }
     }
-    const targetPackageIds = options.packageIds || options.packageAllowlist;
-    if (targetPackageIds && targetPackageIds.length > 0) {
-        for (const pkgId of targetPackageIds) {
+    // 单一 projectRoot 分支提前解析并统一登记已声明包身份，
+    // 与 projectRoots/内存 actions 包共同构成“无需额外 registry 解析”的身份集合
+    let projectRoot = options.projectRoot;
+    if (projectRoot) {
+        const abs = resolve(projectRoot);
+        const detected = findProjectRoot(abs);
+        if (!detected) {
+            throw new ActionDockError(PROJECT_ROOT_NOT_FOUND, `Project root '${options.projectRoot}' is not a valid ActionDock package (actiondock.json not found)`);
+        }
+        projectRoot = detected;
+        packages.push({
+            ...basePkgOpts,
+            packageRoot: detected,
+        });
+    }
+    // 统一收集全部已声明来源的包身份（projectRoot、projectRoots、内存 actions 包）。
+    // 已声明来源（projectRoot、projectRoots、内存 actions 包）身份优先登记，
+    // 额外授权目标在查 registry 前先比对身份集合：
+    // 已声明身份无需重复装载，避免本地项目未 link 时误走 registry 抛 PACKAGE_NOT_FOUND
+    const declaredIds = new Set();
+    const collectDeclaredId = (packageRoot) => {
+        if (!packageRoot)
+            return;
+        const id = loadProjectConfig(packageRoot).id;
+        if (id)
+            declaredIds.add(id);
+    };
+    if (projectRoot) {
+        collectDeclaredId(projectRoot);
+    }
+    for (const pkg of packages) {
+        if (typeof pkg === "object" && pkg !== null && "packageRoot" in pkg) {
+            collectDeclaredId(pkg.packageRoot);
+        }
+    }
+    if (options.actions) {
+        declaredIds.add(options.packageId || "default");
+    }
+    // 附加装载目标为两份白名单的并集：整包授权包与单动作授权引用的所属包均需装载，
+    // 仅装载整包授权包会导致单动作授权目标缺失而不可用。
+    // * 是全授权标记而非真实包，必须跳过；动作引用用 core parseActionRef 单一事实源解析。
+    // packageId/packageIds 是装载选择，不与授权目标混同：显式授权 B/read 必须装载 B。
+    const allowedPackageIds = [
+        ...(options.packageId ? [options.packageId] : []),
+        ...(options.packageIds || []),
+        ...(options.packageAllowlist || []).filter((id) => id !== "*"),
+        ...(options.actionAllowlist || []).map((ref) => parseActionRef(ref).packageId),
+    ];
+    const dedupedTargetPackageIds = [];
+    for (const pkgId of allowedPackageIds) {
+        if (declaredIds.has(pkgId)) {
+            continue;
+        }
+        if (!dedupedTargetPackageIds.includes(pkgId)) {
+            dedupedTargetPackageIds.push(pkgId);
+        }
+    }
+    if (dedupedTargetPackageIds.length > 0) {
+        for (const pkgId of dedupedTargetPackageIds) {
             const root = resolvePackageRoot(pkgId, undefined, options.customHome);
             if (!root || !existsSync(root)) {
                 throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${pkgId}' not found in registry`);
@@ -76,15 +137,6 @@ export async function resolveService(options) {
             });
         }
     }
-    let projectRoot = options.projectRoot;
-    if (options.projectRoot) {
-        const abs = resolve(options.projectRoot);
-        const detected = findProjectRoot(abs);
-        if (!detected) {
-            throw new ActionDockError(PROJECT_ROOT_NOT_FOUND, `Project root '${options.projectRoot}' is not a valid ActionDock package (actiondock.json not found)`);
-        }
-        projectRoot = detected;
-    }
     if (!projectRoot &&
         packages.length === 0 &&
         !options.all &&
@@ -95,17 +147,6 @@ export async function resolveService(options) {
         }
         projectRoot = currentRoot;
     }
-    if (options.packageId && !options.actions && packages.length === 0) {
-        const root = resolvePackageRoot(options.packageId, undefined, options.customHome);
-        if (!root || !existsSync(root)) {
-            throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${options.packageId}' not found in registry`);
-        }
-        packages.push({
-            ...basePkgOpts,
-            packageRoot: root,
-            dataDir: options.dataDir,
-        });
-    }
     let platform = options.platform;
     if (!platform && typeof process !== "undefined" && process.versions?.node) {
         platform = createNodePlatform({

package/dist/stdio.js

@@ -41,6 +41,8 @@ export async function startMcpStdio(options = {}) {
                     packageId: options.packageId,
                     packageIds: options.packageIds,
                     all: options.all,
+                    packageAllowlist: options.packageAllowlist,
+                    actionAllowlist: options.actionAllowlist,
                     customHome: options.customHome,
                     dataDir: options.dataDir,
                     configOverrides: options.configOverrides,

package/dist/tool-mapper.d.ts

@@ -1,3 +1,4 @@
+import { type EffectiveServerPolicy } from "@actiondock/core/server";
 /**
  * 构造携带结构化错误码的工具名冲突异常。
  *
@@ -25,9 +26,11 @@ export interface MappedAction<T> {
 }
 /**
  * 映射与过滤工具，处理冲突检测、去重、白名单过滤及 SHA-256 截断散列逻辑。
+ * 过滤统一委托 core 策略函数做并集判定（整包 ∪ 全限定单动作），适配层不复制授权逻辑；
+ * 未传 policy 时从两份 allowlist 构造同一 policy（空授权仍为空，不回退全访问）。
  */
 export declare function mapAndFilterActions<T extends {
     id: string;
     packageId?: string;
     description?: string;
-}>(rawActions: T[], allowedPackageIds?: string[], actionAllowlist?: string[]): MappedAction<T>[];
+}>(rawActions: T[], allowedPackageIds?: string[], actionAllowlist?: string[], policy?: EffectiveServerPolicy): MappedAction<T>[];

package/dist/tool-mapper.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { MCP_TOOL_NAME_COLLISION } from "@actiondock/core";
 import { parseActionRef } from "@actiondock/core/graph";
-import { isActionAllowed } from "@actiondock/core/server";
+import { isActionAllowedByPolicy } from "@actiondock/core/server";
 /**
  * 构造携带结构化错误码的工具名冲突异常。
  *
@@ -29,8 +29,15 @@ export function splitActionRef(ref) {
 }
 /**
  * 映射与过滤工具，处理冲突检测、去重、白名单过滤及 SHA-256 截断散列逻辑。
+ * 过滤统一委托 core 策略函数做并集判定（整包 ∪ 全限定单动作），适配层不复制授权逻辑；
+ * 未传 policy 时从两份 allowlist 构造同一 policy（空授权仍为空，不回退全访问）。
  */
-export function mapAndFilterActions(rawActions, allowedPackageIds, actionAllowlist) {
+export function mapAndFilterActions(rawActions, allowedPackageIds, actionAllowlist, policy) {
+    // 策略单点归一：调用方未传 policy 时按同两份 allowlist 构造，保证与 adapter 主链路同一并集语义
+    const effectivePolicy = policy || {
+        packageAllowlist: allowedPackageIds,
+        actionAllowlist,
+    };
     // 引用解析单点归一：每项仅解析一次，后续各轮（白名单过滤、去重、频次统计、
     // 工具命名）复用同一结果，避免同一列表对 splitActionRef 的三轮重复调用；
     // 显式 packageId 与解析所得 packageId 分别留存，各轮按既有优先级消费
@@ -48,21 +55,12 @@ export function mapAndFilterActions(rawActions, allowedPackageIds, actionAllowli
             parsedRefs.set(act, { explicitPkgId: act.packageId || "", baseId: act.id });
         }
     }
-    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 (actionAllowlist && 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 }, actionAllowlist);
-        });
-    }
+    // 授权过滤单轮：仅用 core 策略函数并集判定，不先按包选择截断单动作授权目标
+    rawActions = rawActions.filter((act) => {
+        const ref = parsedRefs.get(act);
+        const pkgId = ref.explicitPkgId || ref.parsedPkgId || undefined;
+        return isActionAllowedByPolicy({ packageId: pkgId, actionId: ref.baseId }, effectivePolicy);
+    });
     const seenActionKeys = new Map();
     for (const act of rawActions) {
         const ref = parsedRefs.get(act);

package/dist/types.d.ts

@@ -21,9 +21,9 @@ export interface ActionDockMcpOptions {
     packageId?: string;
     /** 多个 Package ID 列表 */
     packageIds?: string[];
-    /** 允许访问执行的 Package ID 白名单列表（为空允许全部） */
+    /** 整包授权白名单列表；与动作授权取并集，独立 * 显式授予全部，省略或空数组不增加授权 */
     packageAllowlist?: string[];
-    /** 允许暴露执行的 Action 标识白名单列表（为空允许全部，支持短名或 packageId/actionId） */
+    /** 全限定 packageId/actionId 精确动作授权白名单列表；与整包授权取并集，省略或空数组不增加授权 */
     actionAllowlist?: string[];
     /** 是否聚合暴露全局 Registry 中的所有 Package */
     all?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/mcp",
-  "version": "2.19.0",
+  "version": "2.21.0",
   "description": "ActionDock MCP Adapter for exposing Actions as Model Context Protocol (MCP) Tools",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,8 +29,8 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/core": "^2.19.0",
-    "@actiondock/sdk": "^2.19.0",
+    "@actiondock/core": "^2.21.0",
+    "@actiondock/sdk": "^2.21.0",
     "@modelcontextprotocol/server": "^2.0.0"
   },
   "devDependencies": {