@actiondock/core 2.7.0 → 2.9.0

package/dist/server/routes/state.js

@@ -1,13 +1,22 @@
 import { decodeStateKey } from "../../storage/index.js";
-import { CAPABILITY_UNAVAILABLE, STATE_KEY_NOT_FOUND } from "../../errors.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 { assertPackageAllowed, getSubPath, jsonResponse, resolveAppForPackage } 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 ||
+        err?.code === PATH_TRAVERSAL ||
+        err?.code === AMBIGUOUS_STATE_KEY ||
+        err?.code === INVALID_ARGUMENT ||
+        err?.status === 400 ||
+        err?.status === 404);
+}
 /**
  * 处理状态键名列表、读取、写入、删除及清空接口。
- * 在未显式开启管理功能 (options.enableManagement !== true) 时返回 403 拒绝。
+ * 在未显式开启管理功能时返回 403 拒绝。
  */
 export async function handleStateRoutes(ctx) {
-    const { req, url, pathname, corsHeaders, options, host, target } = ctx;
+    const { req, url, pathname, corsHeaders, options, service, activePolicy: policy } = ctx;
     const subpath = getSubPath(pathname);
     const isStateRoute = subpath === "/state" ||
         subpath.startsWith("/state/") ||
@@ -16,7 +25,7 @@ export async function handleStateRoutes(ctx) {
         return null;
     }
     // 校验管理能力开关
-    if (options.enableManagement !== true) {
+    if (!isManagementAllowedByPolicy(policy) || !service.management?.state) {
         return jsonResponse({
             ok: false,
             error: {
@@ -32,31 +41,26 @@ export async function handleStateRoutes(ctx) {
             const actionParam = url.searchParams.get("action") || url.searchParams.get("actionId") || "";
             const nsParam = url.searchParams.get("namespace") ?? undefined;
             const prefix = url.searchParams.get("prefix") || "";
-            if (pkgParam) {
-                assertPackageAllowed(pkgParam, options);
-            }
-            const app = resolveAppForPackage(pkgParam, host, target, options);
-            assertPackageAllowed(app.packageId, options);
-            const effectiveNs = actionParam
-                ? (nsParam !== undefined ? `${actionParam}:${nsParam}` : actionParam)
-                : (nsParam !== undefined ? nsParam : null);
-            const keys = await app.storage.listStateKeys(effectiveNs, prefix);
-            return jsonResponse({ ok: true, packageId: app.packageId, keys }, 200, corsHeaders);
+            const pkgs = await service.discovery.listPackages();
+            const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, policy);
+            const keys = await service.management.state.list(targetPackageId, actionParam, {
+                namespace: nsParam,
+                prefix,
+            });
+            return jsonResponse({ ok: true, packageId: targetPackageId, keys }, 200, corsHeaders);
         }
         catch (err) {
-            if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+            if (err.code === PACKAGE_NOT_ALLOWED || err.status === 403) {
                 return jsonResponse({
                     ok: false,
                     error: {
-                        code: "PACKAGE_NOT_ALLOWED",
+                        code: PACKAGE_NOT_ALLOWED,
                         message: err.message || "Package is not in the allowed package list",
                     },
                 }, 403, corsHeaders);
             }
-            const isClient = err.message?.includes("Unknown or unregistered package") ||
-                err.message?.includes("Invalid packageId") ||
-                err.message?.includes("escapes boundary");
-            return jsonResponse({ ok: false, error: { code: isClient ? "INVALID_ARGUMENT" : "STATE_LIST_ERROR", message: err.message } }, isClient ? 400 : 500, corsHeaders);
+            const isClient = isClientStateError(err);
+            return jsonResponse({ ok: false, error: { code: isClient ? INVALID_ARGUMENT : STATE_LIST_ERROR, message: err.message } }, isClient ? 400 : 500, corsHeaders);
         }
     }
     // 2. State Clear: POST /state/clear
@@ -66,33 +70,27 @@ export async function handleStateRoutes(ctx) {
             const pkgParam = url.searchParams.get("package") || url.searchParams.get("packageId") || body.package || undefined;
             const actionParam = url.searchParams.get("action") || url.searchParams.get("actionId") || body.action || body.actionId || "";
             const baseNs = body.namespace ?? (url.searchParams.get("namespace") || undefined);
-            const effectiveNs = actionParam ? (baseNs ? `${actionParam}:${baseNs}` : actionParam) : baseNs;
-            if (pkgParam) {
-                assertPackageAllowed(pkgParam, options);
-            }
-            const app = resolveAppForPackage(pkgParam, host, target, options);
-            assertPackageAllowed(app.packageId, options);
-            const clearedCount = await app.storage.clearState({
-                namespace: effectiveNs,
+            const pkgs = await service.discovery.listPackages();
+            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"),
                 prefix: body.prefix ?? (url.searchParams.get("prefix") || undefined),
             });
-            return jsonResponse({ ok: true, packageId: app.packageId, clearedCount }, 200, corsHeaders);
+            return jsonResponse({ ok: true, packageId: targetPackageId, clearedCount }, 200, corsHeaders);
         }
         catch (err) {
-            if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+            if (err.code === PACKAGE_NOT_ALLOWED || err.status === 403) {
                 return jsonResponse({
                     ok: false,
                     error: {
-                        code: "PACKAGE_NOT_ALLOWED",
+                        code: PACKAGE_NOT_ALLOWED,
                         message: err.message || "Package is not in the allowed package list",
                     },
                 }, 403, corsHeaders);
             }
-            const isClient = err.message?.includes("Unknown or unregistered package") ||
-                err.message?.includes("Invalid packageId") ||
-                err.message?.includes("escapes boundary");
-            return jsonResponse({ ok: false, error: { code: isClient ? "INVALID_ARGUMENT" : "STATE_CLEAR_ERROR", message: err.message } }, isClient ? 400 : 500, corsHeaders);
+            const isClient = isClientStateError(err);
+            return jsonResponse({ ok: false, error: { code: isClient ? INVALID_ARGUMENT : STATE_CLEAR_ERROR, message: err.message } }, isClient ? 400 : 500, corsHeaders);
         }
     }
     // 3. State Key CRUD: GET / PUT / POST / DELETE /state/:key
@@ -103,24 +101,26 @@ export async function handleStateRoutes(ctx) {
             const pkgParam = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
             const actionParam = url.searchParams.get("action") || url.searchParams.get("actionId") || "";
             const nsParam = url.searchParams.get("namespace") || undefined;
-            const effectiveNs = actionParam ? (nsParam ? `${actionParam}:${nsParam}` : actionParam) : nsParam;
-            if (pkgParam) {
-                assertPackageAllowed(pkgParam, options);
-            }
-            const app = resolveAppForPackage(pkgParam, host, target, options);
-            assertPackageAllowed(app.packageId, options);
+            const pkgs = await service.discovery.listPackages();
+            const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, policy);
             if (req.method === "GET") {
-                const entry = await app.storage.findState(key, effectiveNs);
-                if (!entry || entry.value === undefined) {
+                const entry = await service.management.state.get(targetPackageId, actionParam, key, {
+                    namespace: nsParam,
+                    detail: true,
+                });
+                if (!entry || (typeof entry === "object" && entry.value === undefined)) {
                     return jsonResponse({ ok: false, error: { code: STATE_KEY_NOT_FOUND, message: `State key '${key}' not found` } }, 404, corsHeaders);
                 }
+                const data = typeof entry === "object" && "value" in entry
+                    ? entry
+                    : { key, namespace: nsParam || "", value: entry, expiresAt: undefined };
                 return jsonResponse({
                     ok: true,
-                    packageId: app.packageId,
-                    key: entry.key,
-                    namespace: entry.namespace,
-                    value: entry.value,
-                    expiresAt: entry.expiresAt,
+                    packageId: targetPackageId,
+                    key: data.key || key,
+                    namespace: data.namespace ?? nsParam ?? "",
+                    value: data.value,
+                    expiresAt: data.expiresAt,
                 }, 200, corsHeaders);
             }
             if (req.method === "PUT" || req.method === "POST") {
@@ -129,40 +129,41 @@ export async function handleStateRoutes(ctx) {
                 const ttl = typeof body.ttl === "number" ? body.ttl : undefined;
                 const bodyAction = body.action || body.actionId || actionParam;
                 const explicitNs = body.namespace || nsParam;
-                const combinedNs = bodyAction ? (explicitNs ? `${bodyAction}:${explicitNs}` : bodyAction) : explicitNs;
                 let actualKey = key;
-                let ns = combinedNs || "";
-                if (!combinedNs) {
+                let ns = explicitNs;
+                if (!bodyAction && !explicitNs) {
                     const decoded = decodeStateKey(key);
                     ns = decoded.namespace;
                     actualKey = decoded.key;
                 }
-                await app.storage.setState(ns, actualKey, val, ttl);
-                return jsonResponse({ ok: true, packageId: app.packageId, key: actualKey, namespace: ns, message: "updated" }, 200, corsHeaders);
+                await service.management.state.set(targetPackageId, bodyAction, actualKey, val, {
+                    namespace: ns,
+                    ttl,
+                });
+                return jsonResponse({ ok: true, packageId: targetPackageId, key: actualKey, namespace: ns || bodyAction || "", message: "updated" }, 200, corsHeaders);
             }
             if (req.method === "DELETE") {
-                const deleted = await app.storage.deleteStateSmart(key, effectiveNs);
+                const deleted = await service.management.state.delete(targetPackageId, actionParam, key, {
+                    namespace: nsParam,
+                });
                 if (!deleted) {
                     return jsonResponse({ ok: false, error: { code: STATE_KEY_NOT_FOUND, message: `State key '${key}' not found` } }, 404, corsHeaders);
                 }
-                return jsonResponse({ ok: true, packageId: app.packageId, key, deleted: true }, 200, corsHeaders);
+                return jsonResponse({ ok: true, packageId: targetPackageId, key, deleted: true }, 200, corsHeaders);
             }
         }
         catch (err) {
-            if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+            if (err.code === PACKAGE_NOT_ALLOWED || err.status === 403) {
                 return jsonResponse({
                     ok: false,
                     error: {
-                        code: "PACKAGE_NOT_ALLOWED",
+                        code: PACKAGE_NOT_ALLOWED,
                         message: err.message || "Package is not in the allowed package list",
                     },
                 }, 403, corsHeaders);
             }
-            const isClient = err.message?.includes("Unknown or unregistered package") ||
-                err.message?.includes("Invalid packageId") ||
-                err.message?.includes("escapes boundary") ||
-                err.message?.includes("Ambiguous state key");
-            return jsonResponse({ ok: false, error: { code: isClient ? "INVALID_ARGUMENT" : "STATE_KEY_ERROR", message: err.message } }, isClient ? 400 : 500, corsHeaders);
+            const isClient = isClientStateError(err);
+            return jsonResponse({ ok: false, error: { code: isClient ? INVALID_ARGUMENT : STATE_KEY_ERROR, message: err.message } }, isClient ? 400 : 500, corsHeaders);
         }
     }
     return null;

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.d.ts

@@ -9,7 +9,7 @@ export declare function formatHostForUrl(host: string): string;
  */
 export declare function launchHttpServer(port: number, host: string, fetchHandler: (req: Request) => Promise<Response>, tls?: ServerTlsOptions): Promise<CoreHttpServerInstance>;
 /**
- * 启动 ActionDock 2.0 原生轻量级 HTTP 服务端。
- * 作为 ActionDockHost 与 ActionDockTarget 的薄适配层，负责中间件流转、认证拦截与路由分发。
+ * 启动 ActionDock 原生轻量级 HTTP 服务端。
+ * 面向 ActionDockService 服务端口，负责中间件流转、认证拦截与路由分发。
  */
 export declare function startActionDockServer(options?: ServerOptions): Promise<ActionDockServerInstance>;