@actiondock/core 2.8.0 → 2.9.0

package/dist/server/routes/runs.js

@@ -1,12 +1,12 @@
-import { CAPABILITY_UNAVAILABLE, EVENT_BACKPRESSURE_LIMIT, EVENT_CURSOR_EXPIRED, EXECUTION_FAILED, PACKAGE_FORBIDDEN, RUN_ALREADY_FINISHED, RUN_INTERRUPTED, RUN_NOT_FOUND, RUNS_CLEAR_ERROR, RUNS_LIST_ERROR, } from "../../errors.js";
+import { ACTION_FORBIDDEN, CAPABILITY_UNAVAILABLE, EVENT_BACKPRESSURE_LIMIT, EVENT_CURSOR_EXPIRED, EXECUTION_FAILED, PACKAGE_FORBIDDEN, RUN_ALREADY_FINISHED, RUN_INTERRUPTED, RUN_NOT_FOUND, RUNS_CLEAR_ERROR, RUNS_LIST_ERROR, } from "../../errors.js";
 import { isTerminalRunStatus } from "../../storage/types.js";
 import { readJsonBody } from "../body.js";
-import { getSubPath, jsonResponse } from "./common.js";
+import { getSubPath, isActionAllowedByPolicy, isPackageAllowedByPolicy, jsonResponse } from "./common.js";
 /**
  * 处理历史运行记录查询、清理、详情及 SSE 流式日志接口。
  */
 export async function handleRunsRoutes(ctx) {
-    const { req, url, pathname, corsHeaders, options, service } = ctx;
+    const { req, url, pathname, corsHeaders, options, service, activePolicy: policy } = ctx;
     const subpath = getSubPath(pathname);
     // 1. Runs List: GET /api/v2/runs, GET /runs
     if (subpath === "/runs" && req.method === "GET") {
@@ -20,10 +20,7 @@ export async function handleRunsRoutes(ctx) {
             const limit = Number.isFinite(parsedLimit) && parsedLimit > 0
                 ? Math.min(parsedLimit, 500)
                 : 50;
-            if (packageId &&
-                options.packageAllowlist &&
-                options.packageAllowlist.length > 0 &&
-                !options.packageAllowlist.includes(packageId)) {
+            if (packageId && !isPackageAllowedByPolicy(packageId, policy)) {
                 return jsonResponse({
                     ok: false,
                     error: {
@@ -32,6 +29,15 @@ export async function handleRunsRoutes(ctx) {
                     },
                 }, 403, corsHeaders);
             }
+            if (actionId && !isActionAllowedByPolicy({ packageId, actionId }, policy)) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        code: ACTION_FORBIDDEN,
+                        message: `Action '${packageId ? `${packageId}/${actionId}` : actionId}' is not in the allowed action list`,
+                    },
+                }, 403, corsHeaders);
+            }
             let allRuns = await service.runs.list({
                 actionId,
                 status,
@@ -39,8 +45,11 @@ export async function handleRunsRoutes(ctx) {
                 intent,
                 limit,
             });
-            if (options.packageAllowlist && options.packageAllowlist.length > 0) {
-                allRuns = allRuns.filter((r) => !r.packageId || options.packageAllowlist.includes(r.packageId));
+            if (policy.packageAllowlist && policy.packageAllowlist.length > 0) {
+                allRuns = allRuns.filter((r) => isPackageAllowedByPolicy(r.packageId, policy));
+            }
+            if (policy.actionAllowlist && policy.actionAllowlist.length > 0) {
+                allRuns = allRuns.filter((r) => isActionAllowedByPolicy({ packageId: r.packageId, actionId: r.actionId }, policy));
             }
             const sliced = allRuns.slice(0, limit);
             return jsonResponse({ ok: true, total: allRuns.length, items: sliced }, 200, corsHeaders);
@@ -60,10 +69,7 @@ export async function handleRunsRoutes(ctx) {
             const packageId = url.searchParams.get("packageId") || body.packageId || undefined;
             const actionId = url.searchParams.get("actionId") || body.actionId || undefined;
             const status = url.searchParams.get("status") || body.status || undefined;
-            if (packageId &&
-                options.packageAllowlist &&
-                options.packageAllowlist.length > 0 &&
-                !options.packageAllowlist.includes(packageId)) {
+            if (packageId && !isPackageAllowedByPolicy(packageId, policy)) {
                 return jsonResponse({
                     ok: false,
                     error: {
@@ -90,14 +96,21 @@ export async function handleRunsRoutes(ctx) {
         if (!run) {
             return jsonResponse({ ok: false, error: { code: RUN_NOT_FOUND, message: `Run '${runId}' not found` } }, 404, corsHeaders);
         }
-        if (options.packageAllowlist &&
-            options.packageAllowlist.length > 0 &&
-            (!run.packageId || !options.packageAllowlist.includes(run.packageId))) {
+        if (!isPackageAllowedByPolicy(run.packageId, policy)) {
             return jsonResponse({
                 ok: false,
                 error: {
                     code: PACKAGE_FORBIDDEN,
-                    message: `Package '${run.packageId}' is not in the allowed package list`,
+                    message: `Package '${run.packageId || "unknown"}' is not in the allowed package list`,
+                },
+            }, 403, corsHeaders);
+        }
+        if (!isActionAllowedByPolicy({ packageId: run.packageId, actionId: run.actionId }, policy)) {
+            return jsonResponse({
+                ok: false,
+                error: {
+                    code: ACTION_FORBIDDEN,
+                    message: `Action '${run.packageId ? `${run.packageId}/${run.actionId}` : run.actionId}' is not in the allowed action list`,
                 },
             }, 403, corsHeaders);
         }
@@ -258,9 +271,7 @@ export async function handleRunsRoutes(ctx) {
                 },
             }, 404, corsHeaders);
         }
-        if (options.packageAllowlist &&
-            options.packageAllowlist.length > 0 &&
-            (!run.packageId || !options.packageAllowlist.includes(run.packageId))) {
+        if (!isPackageAllowedByPolicy(run.packageId, policy)) {
             return jsonResponse({
                 ok: false,
                 error: {
@@ -269,22 +280,43 @@ export async function handleRunsRoutes(ctx) {
                 },
             }, 403, corsHeaders);
         }
+        if (!isActionAllowedByPolicy({ packageId: run.packageId, actionId: run.actionId }, policy)) {
+            return jsonResponse({
+                ok: false,
+                error: {
+                    code: ACTION_FORBIDDEN,
+                    message: `Action '${run.packageId ? `${run.packageId}/${run.actionId}` : run.actionId}' is not in the allowed action list`,
+                },
+            }, 403, corsHeaders);
+        }
         return jsonResponse(run, 200, corsHeaders);
     }
     // 5. Run Cancel: POST /api/v2/runs/:runId/cancel, POST /runs/:runId/cancel
     const runCancelMatch = subpath.match(/^\/runs\/([^/]+)\/cancel$/);
     if (runCancelMatch && req.method === "POST") {
         const runId = decodeURIComponent(runCancelMatch[1]);
-        if (options.packageAllowlist && options.packageAllowlist.length > 0) {
+        if ((policy.packageAllowlist && policy.packageAllowlist.length > 0) ||
+            (policy.actionAllowlist && policy.actionAllowlist.length > 0)) {
             const run = await service.runs.get(runId);
-            if (run && (!run.packageId || !options.packageAllowlist.includes(run.packageId))) {
-                return jsonResponse({
-                    ok: false,
-                    error: {
-                        code: PACKAGE_FORBIDDEN,
-                        message: `Package '${run.packageId}' is not in the allowed package list`,
-                    },
-                }, 403, corsHeaders);
+            if (run) {
+                if (!isPackageAllowedByPolicy(run.packageId, policy)) {
+                    return jsonResponse({
+                        ok: false,
+                        error: {
+                            code: PACKAGE_FORBIDDEN,
+                            message: `Package '${run.packageId || "unknown"}' is not in the allowed package list`,
+                        },
+                    }, 403, corsHeaders);
+                }
+                if (!isActionAllowedByPolicy({ packageId: run.packageId, actionId: run.actionId }, policy)) {
+                    return jsonResponse({
+                        ok: false,
+                        error: {
+                            code: ACTION_FORBIDDEN,
+                            message: `Action '${run.packageId ? `${run.packageId}/${run.actionId}` : run.actionId}' is not in the allowed action list`,
+                        },
+                    }, 403, corsHeaders);
+                }
             }
         }
         let body = {};

package/dist/server/routes/state.d.ts

@@ -1,6 +1,6 @@
 import { type RouteContext } from "./common.js";
 /**
  * 处理状态键名列表、读取、写入、删除及清空接口。
- * 在未显式开启管理功能 (options.enableManagement !== true) 时返回 403 拒绝。
+ * 在未显式开启管理功能时返回 403 拒绝。
  */
 export declare function handleStateRoutes(ctx: RouteContext): Promise<Response | null>;

package/dist/server/routes/state.js

@@ -1,7 +1,7 @@
 import { decodeStateKey } from "../../storage/index.js";
 import { AMBIGUOUS_STATE_KEY, CAPABILITY_UNAVAILABLE, INVALID_ARGUMENT, INVALID_PACKAGE_ID, PACKAGE_NOT_ALLOWED, PACKAGE_NOT_FOUND, PATH_TRAVERSAL, STATE_CLEAR_ERROR, STATE_KEY_ERROR, STATE_KEY_NOT_FOUND, STATE_LIST_ERROR, } from "../../errors.js";
 import { readJsonBody } from "../body.js";
-import { getSubPath, jsonResponse, resolveTargetPackageId } from "./common.js";
+import { getSubPath, isManagementAllowedByPolicy, jsonResponse, resolveTargetPackageId, } from "./common.js";
 function isClientStateError(err) {
     return (err?.code === PACKAGE_NOT_FOUND ||
         err?.code === INVALID_PACKAGE_ID ||
@@ -13,10 +13,10 @@ function isClientStateError(err) {
 }
 /**
  * 处理状态键名列表、读取、写入、删除及清空接口。
- * 在未显式开启管理功能 (options.enableManagement !== true) 时返回 403 拒绝。
+ * 在未显式开启管理功能时返回 403 拒绝。
  */
 export async function handleStateRoutes(ctx) {
-    const { req, url, pathname, corsHeaders, options, service } = ctx;
+    const { req, url, pathname, corsHeaders, options, service, activePolicy: policy } = ctx;
     const subpath = getSubPath(pathname);
     const isStateRoute = subpath === "/state" ||
         subpath.startsWith("/state/") ||
@@ -25,7 +25,7 @@ export async function handleStateRoutes(ctx) {
         return null;
     }
     // 校验管理能力开关
-    if (options.enableManagement !== true || !service.management?.state) {
+    if (!isManagementAllowedByPolicy(policy) || !service.management?.state) {
         return jsonResponse({
             ok: false,
             error: {
@@ -42,7 +42,7 @@ export async function handleStateRoutes(ctx) {
             const nsParam = url.searchParams.get("namespace") ?? undefined;
             const prefix = url.searchParams.get("prefix") || "";
             const pkgs = await service.discovery.listPackages();
-            const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, options);
+            const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, policy);
             const keys = await service.management.state.list(targetPackageId, actionParam, {
                 namespace: nsParam,
                 prefix,
@@ -71,7 +71,7 @@ export async function handleStateRoutes(ctx) {
             const actionParam = url.searchParams.get("action") || url.searchParams.get("actionId") || body.action || body.actionId || "";
             const baseNs = body.namespace ?? (url.searchParams.get("namespace") || undefined);
             const pkgs = await service.discovery.listPackages();
-            const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, options);
+            const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, policy);
             const clearedCount = await service.management.state.clear(targetPackageId, actionParam, {
                 namespace: baseNs,
                 all: Boolean(body.all ?? url.searchParams.get("all") === "true"),
@@ -102,7 +102,7 @@ export async function handleStateRoutes(ctx) {
             const actionParam = url.searchParams.get("action") || url.searchParams.get("actionId") || "";
             const nsParam = url.searchParams.get("namespace") || undefined;
             const pkgs = await service.discovery.listPackages();
-            const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, options);
+            const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, policy);
             if (req.method === "GET") {
                 const entry = await service.management.state.get(targetPackageId, actionParam, key, {
                     namespace: nsParam,

package/dist/server/security.d.ts

@@ -15,6 +15,17 @@ export interface VerifyBearerTokenOptions {
     /** 是否允许通过 URL 查询参数携带 Token（默认 false） */
     allowQueryToken?: boolean;
 }
+/**
+ * 从 HTTP 请求中提取 Bearer Token。
+ *
+ * 默认仅接受 HTTP 请求头: `Authorization: Bearer <token>`。
+ * 仅当 allowQueryToken 为 true 时才允许解析 URL 查询参数 `?token=<token>`。
+ *
+ * @param req 传入的 HTTP Request 对象
+ * @param allowQueryToken 是否允许从 URL 查询参数解析 Token
+ * @returns 提取出的 Token 字符串，若未携带则返回 null
+ */
+export declare function extractBearerToken(req: Request, allowQueryToken?: boolean): string | null;
 /**
  * 校验 HTTP 请求中的鉴权令牌是否有效。
  *

package/dist/server/security.js

@@ -13,49 +13,66 @@ export function safeEqual(a, b) {
     const aa = Buffer.from(a);
     const bb = Buffer.from(b);
     if (aa.length !== bb.length) {
+        // 长度不等时对自身做一次恒定时间比较，消除因长度不等提前退出带来的时序差
+        timingSafeEqual(aa, aa);
         return false;
     }
     return timingSafeEqual(aa, bb);
 }
 /**
- * 校验 HTTP 请求中的鉴权令牌是否有效。
+ * 从 HTTP 请求中提取 Bearer Token。
  *
  * 默认仅接受 HTTP 请求头: `Authorization: Bearer <token>`。
- * 仅当 options.allowQueryToken 为 true 时才允许解析 URL 查询参数 `?token=<token>`。
+ * 仅当 allowQueryToken 为 true 时才允许解析 URL 查询参数 `?token=<token>`。
  *
  * @param req 传入的 HTTP Request 对象
- * @param expectedToken 服务端预期的正确 Token（若未配置 Token 则默认放行）
- * @param options 校验选项或布尔值 allowQueryToken 开关
- * @returns 是否鉴权成功
+ * @param allowQueryToken 是否允许从 URL 查询参数解析 Token
+ * @returns 提取出的 Token 字符串，若未携带则返回 null
  */
-export function verifyBearerToken(req, expectedToken, options) {
-    if (!expectedToken || !expectedToken.trim()) {
-        return true;
-    }
-    const trimmedExpected = expectedToken.trim();
+export function extractBearerToken(req, allowQueryToken) {
     // 1. 请求头 Authorization: Bearer <token>
     const authHeader = req.headers.get("authorization");
     if (authHeader && authHeader.startsWith("Bearer ")) {
         const token = authHeader.slice(7).trim();
-        if (safeEqual(token, trimmedExpected)) {
-            return true;
-        }
+        if (token)
+            return token;
     }
     // 2. URL 查询参数: ?token=<token>（仅当显式开启 allowQueryToken 时允许）
-    const allowQuery = typeof options === "boolean" ? options : options?.allowQueryToken === true;
-    if (allowQuery) {
+    if (allowQueryToken) {
         try {
             const url = new URL(req.url);
             const tokenParam = url.searchParams.get("token");
-            if (tokenParam && safeEqual(tokenParam.trim(), trimmedExpected)) {
-                return true;
+            if (tokenParam && tokenParam.trim()) {
+                return tokenParam.trim();
             }
         }
         catch {
-            // 畸形 URL 视作鉴权失败
+            // 畸形 URL 忽略
         }
     }
-    return false;
+    return null;
+}
+/**
+ * 校验 HTTP 请求中的鉴权令牌是否有效。
+ *
+ * 默认仅接受 HTTP 请求头: `Authorization: Bearer <token>`。
+ * 仅当 options.allowQueryToken 为 true 时才允许解析 URL 查询参数 `?token=<token>`。
+ *
+ * @param req 传入的 HTTP Request 对象
+ * @param expectedToken 服务端预期的正确 Token（若未配置 Token 则默认放行）
+ * @param options 校验选项或布尔值 allowQueryToken 开关
+ * @returns 是否鉴权成功
+ */
+export function verifyBearerToken(req, expectedToken, options) {
+    if (!expectedToken || !expectedToken.trim()) {
+        return true;
+    }
+    const allowQuery = typeof options === "boolean" ? options : options?.allowQueryToken === true;
+    const token = extractBearerToken(req, allowQuery);
+    if (!token) {
+        return false;
+    }
+    return safeEqual(token, expectedToken.trim());
 }
 /**
  * 根据配置的 CORS 白名单解析并返回跨域响应头。

package/dist/server/server.js

@@ -1,13 +1,15 @@
-import { resolve } from "node:path";
+import { posix, resolve } from "node:path";
 import { NodeHttpServer } from "./http-server.js";
 import { createActionDock } from "../service/factory.js";
 import { NOT_FOUND, UNAUTHORIZED } from "../errors.js";
+import { parseActionRef } from "../catalog/resolve-action.js";
 import { ensureDependencyClosure } from "../project/closure.js";
 import { findProjectRoot } from "../project/loader.js";
 import { listLinkedPackages, resolvePackageRoot } from "../registry/registry.js";
 import { handleActionsRoutes, handleConfigRoutes, handleDoctorRoute, handleHealthRoute, handleInfoRoute, handlePlaybooksRoutes, handleRunsRoutes, handleStateRoutes, jsonResponse, } from "./routes/index.js";
 import { isLoopbackHost, resolveCorsHeaders, verifyBearerToken } from "./security.js";
 import { createMcpEndpointHandler } from "./mcp-endpoint.js";
+import { extractBearerToken, matchViewByToken, normalizeServerViews, } from "./policy.js";
 /**
  * 规范化主机地址用于拼接 URL。
  * 若 host 包含冒号 : 且不以 [ 开头，则添加中括号包裹（IPv6 标准格式）。
@@ -48,8 +50,13 @@ export async function startActionDockServer(options = {}) {
     const projectRoot = options.projectRoot
         ? resolve(options.projectRoot)
         : findProjectRoot(process.cwd());
+    // 1. 归一化解析视图配置集合（含默认视图与自定义视图）
+    const { defaultView, views } = normalizeServerViews(options);
     // 非回环地址强制要求配置 Token 鉴权（防裸奔）
-    if (!isLoopbackHost(host) && !token && !options.allowInsecureNoAuth) {
+    const hasTokenConfigured = Boolean(token ||
+        defaultView.policy.token ||
+        Array.from(views.values()).some((v) => Boolean(v.policy.token)));
+    if (!isLoopbackHost(host) && !hasTokenConfigured && !options.allowInsecureNoAuth) {
         throw new Error("Authentication token is required when binding to a non-loopback address. Use --allow-insecure-no-auth to override.");
     }
     let serviceInstance = options.service;
@@ -69,12 +76,27 @@ export async function startActionDockServer(options = {}) {
     if (!serviceInstance) {
         throw new Error("Failed to initialize ActionDockService for server");
     }
+    // 2. 聚合所有 views 声明的依赖包与动作，确保依赖闭包满足
     const roots = [];
     if (projectRoot) {
         roots.push(projectRoot);
     }
-    if (options.packageAllowlist && options.packageAllowlist.length > 0) {
-        for (const pkgId of options.packageAllowlist) {
+    const aggregatedPackageAllowlist = new Set();
+    const aggregatedActionAllowlist = new Set();
+    for (const v of views.values()) {
+        if (v.policy.packageAllowlist) {
+            for (const pkg of v.policy.packageAllowlist) {
+                aggregatedPackageAllowlist.add(pkg);
+            }
+        }
+        if (v.policy.actionAllowlist) {
+            for (const act of v.policy.actionAllowlist) {
+                aggregatedActionAllowlist.add(act);
+            }
+        }
+    }
+    if (aggregatedPackageAllowlist.size > 0) {
+        for (const pkgId of aggregatedPackageAllowlist) {
             const r = resolvePackageRoot(pkgId, projectRoot || undefined, customHome);
             if (r && !roots.includes(r)) {
                 roots.push(r);
@@ -88,18 +110,85 @@ export async function startActionDockServer(options = {}) {
             }
         }
     }
+    if (aggregatedActionAllowlist.size > 0) {
+        for (const actRef of aggregatedActionAllowlist) {
+            try {
+                const parsed = parseActionRef(actRef);
+                if (parsed.packageId) {
+                    const r = resolvePackageRoot(parsed.packageId, projectRoot || undefined, customHome);
+                    if (r && !roots.includes(r)) {
+                        roots.push(r);
+                    }
+                }
+            }
+            catch { }
+        }
+    }
     if (roots.length > 0) {
         await ensureDependencyClosure(roots, { customHome });
     }
-    // MCP 统一网关端点处理器：鉴权、请求体限流与委托序列收敛为共享单一事实源
-    const mcpEndpointHandler = options.mcpHandler
-        ? createMcpEndpointHandler(options.mcpHandler, {
-            token,
-            allowQueryToken: options.allowQueryToken,
-            corsOrigins: options.corsOrigins,
-            maxBodyBytes: options.maxBodyBytes,
-        })
-        : undefined;
+    // 3. 为每个启用 MCP 的视图独立装配 MCP 处理器
+    if (options.enableMcp !== false) {
+        for (const v of views.values()) {
+            if (v.enableMcp !== false) {
+                let delegate;
+                if (v.rawOptions.mcpHandler) {
+                    if (v.rawOptions.mcpHandler.length >= 2) {
+                        delegate = (req) => v.rawOptions.mcpHandler(req, v.policy);
+                    }
+                    else {
+                        let factoryResult;
+                        try {
+                            factoryResult = v.rawOptions.mcpHandler(v.policy);
+                        }
+                        catch {
+                            factoryResult = null;
+                        }
+                        if (typeof factoryResult === "function") {
+                            delegate = factoryResult;
+                        }
+                        else {
+                            delegate = (req) => v.rawOptions.mcpHandler(req, v.policy);
+                        }
+                    }
+                }
+                else if (options.mcpHandlerFactory) {
+                    delegate = options.mcpHandlerFactory(v.policy);
+                }
+                else if (options.mcpHandler) {
+                    if (options.mcpHandler.length >= 2) {
+                        delegate = (req) => options.mcpHandler(req, v.policy);
+                    }
+                    else {
+                        let factoryResult;
+                        try {
+                            factoryResult = options.mcpHandler(v.policy);
+                        }
+                        catch {
+                            factoryResult = null;
+                        }
+                        if (typeof factoryResult === "function") {
+                            delegate = factoryResult;
+                        }
+                        else {
+                            if (factoryResult && typeof factoryResult.catch === "function") {
+                                factoryResult.catch(() => { });
+                            }
+                            delegate = (req) => options.mcpHandler(req, v.policy);
+                        }
+                    }
+                }
+                if (delegate) {
+                    v.mcpEndpointHandler = createMcpEndpointHandler(delegate, {
+                        token: v.policy.token,
+                        allowQueryToken: options.allowQueryToken,
+                        corsOrigins: options.corsOrigins,
+                        maxBodyBytes: options.maxBodyBytes,
+                    });
+                }
+            }
+        }
+    }
     const fetchHandler = async (req) => {
         const origin = req.headers.get("origin");
         const corsHeaders = resolveCorsHeaders(origin, options.corsOrigins);
@@ -110,32 +199,113 @@ export async function startActionDockServer(options = {}) {
             });
         }
         const url = new URL(req.url);
-        const pathname = url.pathname;
+        const rawPathname = url.pathname;
+        let activeView;
+        let effectivePathname;
+        let effectiveReq = req;
+        // 1. 检查是否为 /views/:viewName/... 命名空间路由
+        const viewMatch = rawPathname.match(/^\/views\/([^/]+)(\/.*)?$/);
+        if (viewMatch) {
+            let viewName;
+            try {
+                viewName = decodeURIComponent(viewMatch[1]);
+            }
+            catch {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        code: NOT_FOUND,
+                        message: `Invalid view name encoding: '${viewMatch[1]}'`,
+                    },
+                }, 400, corsHeaders);
+            }
+            const matched = views.get(viewName);
+            if (!matched) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        code: NOT_FOUND,
+                        message: `View '${viewName}' not found`,
+                    },
+                }, 404, corsHeaders);
+            }
+            activeView = matched;
+            // 规范化子路径，防范路径穿透与多斜杠混淆
+            let rawEffective = viewMatch[2] || "/";
+            if (!rawEffective.startsWith("/")) {
+                rawEffective = "/" + rawEffective;
+            }
+            const normalizedPath = posix.normalize(rawEffective);
+            effectivePathname = normalizedPath.startsWith("/") ? normalizedPath : "/" + normalizedPath;
+            // 剥离 /views/:viewName 前缀后重构 URL 与 Request
+            const rewrittenUrl = new URL(req.url);
+            rewrittenUrl.pathname = effectivePathname;
+            try {
+                const init = {
+                    method: req.method,
+                    headers: req.headers,
+                    signal: req.signal,
+                };
+                if (req.body && req.method !== "GET" && req.method !== "HEAD") {
+                    init.body = req.body;
+                    init.duplex = "half";
+                }
+                effectiveReq = new Request(rewrittenUrl.toString(), init);
+            }
+            catch {
+                effectiveReq = req;
+            }
+        }
+        else {
+            // 根路径请求：智能根据 Bearer Token 匹配视图或回退默认视图（遍历全量视图以防范时序差异）
+            effectivePathname = rawPathname;
+            const clientToken = extractBearerToken(req, options.allowQueryToken);
+            if (clientToken) {
+                const matchedByToken = matchViewByToken(clientToken, views.values());
+                activeView = matchedByToken ?? defaultView;
+            }
+            else {
+                activeView = defaultView;
+            }
+        }
+        const effectivePolicy = activeView.policy;
+        const effectiveUrl = new URL(effectiveReq.url);
+        effectiveUrl.pathname = effectivePathname;
         const ctx = {
-            req,
-            url,
-            pathname,
+            req: effectiveReq,
+            url: effectiveUrl,
+            pathname: effectivePathname,
             corsHeaders,
             projectRoot,
             customHome,
             service: serviceInstance,
             options,
+            activePolicy: effectivePolicy,
         };
-        // 1. 健康检查路由（内部处理独立鉴权逻辑）
+        // 2. 健康检查路由（内部处理独立鉴权逻辑，使用 activePolicy.token）
         const healthResponse = await handleHealthRoute(ctx);
         if (healthResponse) {
             return healthResponse;
         }
-        // 2. MCP 统一网关端点（委托共享端点处理器）
-        if (options.enableMcp !== false &&
-            mcpEndpointHandler &&
-            (pathname === "/mcp" || pathname.startsWith("/mcp/"))) {
-            const mcpRes = await mcpEndpointHandler(req);
-            if (mcpRes)
-                return mcpRes;
+        // 3. MCP 统一网关端点（委托当前视图的端点处理器）
+        if (effectivePathname === "/mcp" || effectivePathname.startsWith("/mcp/")) {
+            if (activeView.enableMcp === false || options.enableMcp === false) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        code: NOT_FOUND,
+                        message: `MCP endpoint is disabled for view '${activeView.name}'`,
+                    },
+                }, 404, corsHeaders);
+            }
+            if (activeView.mcpEndpointHandler) {
+                const mcpRes = await activeView.mcpEndpointHandler(effectiveReq);
+                if (mcpRes)
+                    return mcpRes;
+            }
         }
-        // 3. 全局 API 认证鉴权拦截
-        if (!verifyBearerToken(req, token, options)) {
+        // 4. API 认证鉴权拦截（基于当前生效策略中的 Token）
+        if (!verifyBearerToken(effectiveReq, effectivePolicy.token, options)) {
             return jsonResponse({
                 ok: false,
                 error: {
@@ -144,7 +314,7 @@ export async function startActionDockServer(options = {}) {
                 },
             }, 401, corsHeaders);
         }
-        // 4. 业务领域路由分发（完全委托 Service）
+        // 5. 业务领域路由分发（完全委托 Service 与 RouteContext 中的 activePolicy）
         const routeResponse = (await handleInfoRoute(ctx)) ||
             (await handleDoctorRoute(ctx)) ||
             (await handleActionsRoutes(ctx)) ||
@@ -155,12 +325,12 @@ export async function startActionDockServer(options = {}) {
         if (routeResponse) {
             return routeResponse;
         }
-        // 5. 404 路由兜底
+        // 6. 404 路由兜底
         return jsonResponse({
             ok: false,
             error: {
                 code: NOT_FOUND,
-                message: `Route not found: ${req.method} ${pathname}`,
+                message: `Route not found: ${req.method} ${rawPathname}`,
             },
         }, 404, corsHeaders);
     };