@actiondock/core 2.0.12 → 2.2.1

package/dist/server/routes/common.js

@@ -0,0 +1,104 @@
+import { assertValidPackageId } from "../../utils/index.js";
+/**
+ * 构造带 CORS 头的标准 JSON HTTP 响应。
+ */
+export function jsonResponse(data, status = 200, corsHeaders = {}) {
+    return new Response(JSON.stringify(data, null, 2), {
+        status,
+        headers: {
+            "Content-Type": "application/json",
+            ...corsHeaders,
+        },
+    });
+}
+/**
+ * 剥离标准版本前缀 (/api/v2/ 与兼容的 /api/v1/)，获取相对路由子路径。
+ */
+export function getSubPath(pathname) {
+    if (pathname.startsWith("/api/v2/")) {
+        return pathname.slice(7);
+    }
+    if (pathname.startsWith("/api/v1/")) {
+        return pathname.slice(7);
+    }
+    return pathname;
+}
+/**
+ * 包未列入白名单拒绝访问异常。
+ */
+export class PackageNotAllowedError extends Error {
+    status = 403;
+    statusCode = 403;
+    code = "PACKAGE_NOT_ALLOWED";
+    constructor(packageId) {
+        super(`Package '${packageId}' is not in the allowed package list`);
+        this.name = "PackageNotAllowedError";
+    }
+}
+/**
+ * 校验目标 packageId 是否属于允许包白名单。
+ * 当 options.packageAllowlist 存在且目标 packageId 不在白名单中时抛出 403 PACKAGE_NOT_ALLOWED 异常。
+ */
+export function assertPackageAllowed(packageId, options) {
+    if (options?.packageAllowlist &&
+        Array.isArray(options.packageAllowlist) &&
+        options.packageAllowlist.length > 0) {
+        if (!packageId || !options.packageAllowlist.includes(packageId)) {
+            throw new PackageNotAllowedError(packageId || "");
+        }
+    }
+}
+/**
+ * 从 Host 或 Target 中依据 packageId 解析对应的 ActionDockApp 实例。
+ * 若提供了 options，过滤或优先选择白名单内的 app。
+ */
+export function resolveAppForPackage(packageIdOrPath, host, target, options) {
+    if (packageIdOrPath) {
+        assertPackageAllowed(packageIdOrPath, options);
+        assertValidPackageId(packageIdOrPath);
+        if (host) {
+            const app = host.getApp(packageIdOrPath);
+            if (app)
+                return app;
+        }
+        const innerTarget = target?.unwrap?.();
+        if (innerTarget && "packageId" in innerTarget && innerTarget.packageId === packageIdOrPath) {
+            return innerTarget;
+        }
+        if (innerTarget && "getApp" in innerTarget) {
+            const app = innerTarget.getApp(packageIdOrPath);
+            if (app)
+                return app;
+        }
+        throw new Error(`Unknown or unregistered package: '${packageIdOrPath}'`);
+    }
+    if (host) {
+        const apps = host.listApps();
+        if (options?.packageAllowlist &&
+            Array.isArray(options.packageAllowlist) &&
+            options.packageAllowlist.length > 0) {
+            const allowedApp = apps.find((a) => options.packageAllowlist.includes(a.packageId));
+            if (allowedApp)
+                return allowedApp;
+        }
+        if (apps.length > 0)
+            return apps[0];
+    }
+    const innerTarget = target?.unwrap?.();
+    if (innerTarget && "listApps" in innerTarget) {
+        const apps = innerTarget.listApps();
+        if (options?.packageAllowlist &&
+            Array.isArray(options.packageAllowlist) &&
+            options.packageAllowlist.length > 0) {
+            const allowedApp = apps.find((a) => options.packageAllowlist.includes(a.packageId));
+            if (allowedApp)
+                return allowedApp;
+        }
+        if (apps.length > 0)
+            return apps[0];
+    }
+    if (innerTarget && "packageId" in innerTarget) {
+        return innerTarget;
+    }
+    throw new Error("No registered package found in host or target");
+}

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

@@ -1,5 +1,6 @@
-import { type RouteContext } from "./common";
+import { type RouteContext } from "./common.js";
 /**
  * 处理配置元数据与当前值读取、更新及删除接口。
+ * 在未显式开启管理功能 (options.enableManagement !== true) 时返回 403 拒绝。
  */
 export declare function handleConfigRoutes(ctx: RouteContext): Promise<Response | null>;

package/dist/server/routes/config.js

@@ -0,0 +1,173 @@
+import { CAPABILITY_UNAVAILABLE } from "../../errors.js";
+import { resolveEnvValue } from "../../runtime/index.js";
+import { isSecretConfigKey, maskSecretValue, sanitizeConfigDefinitions } from "../../storage/index.js";
+import { readJsonBody } from "../body.js";
+import { assertPackageAllowed, getSubPath, jsonResponse, resolveAppForPackage } from "./common.js";
+/**
+ * 处理配置元数据与当前值读取、更新及删除接口。
+ * 在未显式开启管理功能 (options.enableManagement !== true) 时返回 403 拒绝。
+ */
+export async function handleConfigRoutes(ctx) {
+    const { req, url, pathname, corsHeaders, options, host, target } = ctx;
+    const subpath = getSubPath(pathname);
+    const isConfigRoute = subpath === "/config" ||
+        subpath.startsWith("/config/") ||
+        subpath.startsWith("/management/config");
+    if (!isConfigRoute) {
+        return null;
+    }
+    // 校验管理能力开关
+    if (options.enableManagement !== true) {
+        return jsonResponse({
+            ok: false,
+            error: {
+                code: CAPABILITY_UNAVAILABLE,
+                message: "Management APIs are not enabled on this server. Set enableManagement: true to enable.",
+            },
+        }, 403, corsHeaders);
+    }
+    // 1. Config Env Check: GET /config/env
+    if (subpath === "/config/env" && req.method === "GET") {
+        try {
+            const pkgParam = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
+            if (pkgParam) {
+                assertPackageAllowed(pkgParam, options);
+            }
+            const app = resolveAppForPackage(pkgParam, host, target, options);
+            assertPackageAllowed(app.packageId, options);
+            const declared = app.projectConfig?.config || {};
+            const envChecks = [];
+            for (const [k, def] of Object.entries(declared)) {
+                const resolved = resolveEnvValue(k, def, app.packageId);
+                const matchedEnv = resolved?.envKey || null;
+                envChecks.push({
+                    key: k,
+                    required: def.default === undefined,
+                    satisfied: Boolean(resolved !== undefined || def.default !== undefined),
+                    matchedEnv,
+                    hasDefault: def.default !== undefined,
+                    secret: isSecretConfigKey(k, def),
+                });
+            }
+            return jsonResponse({ ok: true, packageId: app.packageId, envChecks }, 200, corsHeaders);
+        }
+        catch (err) {
+            if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        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" : "CONFIG_ENV_ERROR", message: err.message } }, isClient ? 400 : 500, corsHeaders);
+        }
+    }
+    // 2. Config Query: GET /config
+    if (subpath === "/config" && req.method === "GET") {
+        try {
+            const pkgParam = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
+            if (pkgParam) {
+                assertPackageAllowed(pkgParam, options);
+            }
+            const app = resolveAppForPackage(pkgParam, host, target, options);
+            assertPackageAllowed(app.packageId, options);
+            const stored = app.storage.listConfig();
+            const rawDeclared = app.projectConfig?.config || {};
+            const declared = sanitizeConfigDefinitions(rawDeclared) || {};
+            const maskedValues = {};
+            for (const [k, v] of Object.entries(stored)) {
+                if (isSecretConfigKey(k, rawDeclared[k])) {
+                    maskedValues[k] = maskSecretValue(v);
+                }
+                else {
+                    maskedValues[k] = v;
+                }
+            }
+            return jsonResponse({ ok: true, packageId: app.packageId, declared, values: maskedValues }, 200, corsHeaders);
+        }
+        catch (err) {
+            if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        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" : "CONFIG_LIST_ERROR", message: err.message } }, isClient ? 400 : 500, corsHeaders);
+        }
+    }
+    // 3. Config Update: PUT / POST /config
+    if (subpath === "/config" && (req.method === "PUT" || req.method === "POST")) {
+        try {
+            const body = await readJsonBody(req, { maxBytes: options.maxBodyBytes });
+            const pkgParam = url.searchParams.get("package") || url.searchParams.get("packageId") || body.package || undefined;
+            if (pkgParam) {
+                assertPackageAllowed(pkgParam, options);
+            }
+            const app = resolveAppForPackage(pkgParam, host, target, options);
+            assertPackageAllowed(app.packageId, options);
+            const key = body.key;
+            if (!key) {
+                return jsonResponse({ ok: false, error: { code: "INVALID_ARGUMENT", message: "Config 'key' is required" } }, 400, corsHeaders);
+            }
+            await app.setConfig(key, body.value);
+            return jsonResponse({ ok: true, packageId: app.packageId, key, message: "updated" }, 200, corsHeaders);
+        }
+        catch (err) {
+            if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        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" : "CONFIG_SET_ERROR", message: err.message } }, isClient ? 400 : 500, corsHeaders);
+        }
+    }
+    // 4. Config Delete: DELETE /config/:key
+    const configKeyMatch = subpath.match(/^\/config\/([^/]+)$/);
+    if (configKeyMatch && req.method === "DELETE") {
+        try {
+            const key = decodeURIComponent(configKeyMatch[1]);
+            const pkgParam = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
+            if (pkgParam) {
+                assertPackageAllowed(pkgParam, options);
+            }
+            const app = resolveAppForPackage(pkgParam, host, target, options);
+            assertPackageAllowed(app.packageId, options);
+            const deleted = app.storage.deleteConfig(key);
+            return jsonResponse({ ok: true, packageId: app.packageId, key, deleted }, 200, corsHeaders);
+        }
+        catch (err) {
+            if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        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" : "CONFIG_DELETE_ERROR", message: err.message } }, isClient ? 400 : 500, corsHeaders);
+        }
+    }
+    return null;
+}

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

@@ -1,5 +1,5 @@
-import { type RouteContext } from "./common";
+import { type RouteContext } from "./common.js";
 /**
- * 处理环境与依赖诊断接口（GET /api/v1/doctor）。
+ * 处理环境与依赖诊断接口（GET /api/v2/doctor、/doctor 与兼容别名 /api/v1/doctor）。
  */
 export declare function handleDoctorRoute(ctx: RouteContext): Promise<Response | null>;

package/dist/server/routes/doctor.js

@@ -0,0 +1,63 @@
+import { runDoctorChecks } from "../../doctor/doctor.js";
+import { assertPackageAllowed, getSubPath, jsonResponse } from "./common.js";
+/**
+ * 处理环境与依赖诊断接口（GET /api/v2/doctor、/doctor 与兼容别名 /api/v1/doctor）。
+ */
+export async function handleDoctorRoute(ctx) {
+    const { req, url, pathname, corsHeaders, projectRoot, customHome, host, target, options } = ctx;
+    const subpath = getSubPath(pathname);
+    if (subpath !== "/doctor" || req.method !== "GET") {
+        return null;
+    }
+    try {
+        const targetPkg = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
+        if (options.packageAllowlist && options.packageAllowlist.length > 0) {
+            if (!targetPkg) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        code: "PACKAGE_NOT_ALLOWED",
+                        message: "Global doctor check is forbidden when package allowlist is active. Please specify an allowed package.",
+                    },
+                }, 403, corsHeaders);
+            }
+        }
+        if (targetPkg) {
+            assertPackageAllowed(targetPkg, options);
+        }
+        let packageRoot;
+        if (targetPkg) {
+            if (host) {
+                packageRoot = host.getApp(targetPkg)?.packageRoot;
+            }
+            if (!packageRoot && target?.unwrap) {
+                const inner = target.unwrap();
+                if (inner && "getApp" in inner && typeof inner.getApp === "function") {
+                    packageRoot = inner.getApp(targetPkg)?.packageRoot;
+                }
+                else if (inner && "packageId" in inner && inner.packageId === targetPkg) {
+                    packageRoot = inner.packageRoot;
+                }
+            }
+        }
+        const report = await runDoctorChecks({
+            cwd: packageRoot || projectRoot || process.cwd(),
+            packageIdOrPath: packageRoot || targetPkg,
+            customHome,
+            packageAllowlist: options.packageAllowlist,
+        });
+        return jsonResponse({ ok: true, report }, 200, corsHeaders);
+    }
+    catch (err) {
+        if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+            return jsonResponse({
+                ok: false,
+                error: {
+                    code: "PACKAGE_NOT_ALLOWED",
+                    message: err.message || "Package is not in the allowed package list",
+                },
+            }, 403, corsHeaders);
+        }
+        return jsonResponse({ ok: false, error: { code: "DOCTOR_ERROR", message: err.message } }, 500, corsHeaders);
+    }
+}

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

@@ -1,5 +1,5 @@
-import { type RouteContext } from "./common";
+import { type RouteContext } from "./common.js";
 /**
- * 处理健康检查与就绪状态接口（支持 /api/v1/health 与 /health）。
+ * 处理健康检查与就绪状态接口（支持 /api/v2/health、/health 与兼容别名 /api/v1/health）。
  */
 export declare function handleHealthRoute(ctx: RouteContext): Promise<Response | null>;

package/dist/server/routes/health.js

@@ -0,0 +1,35 @@
+import { ACTIONDOCK_VERSION } from "../../version.js";
+import { UNAUTHORIZED } from "../../errors.js";
+import { verifyBearerToken } from "../security.js";
+import { jsonResponse } from "./common.js";
+/**
+ * 处理健康检查与就绪状态接口（支持 /api/v2/health、/health 与兼容别名 /api/v1/health）。
+ */
+export async function handleHealthRoute(ctx) {
+    const { req, pathname, corsHeaders, options, projectRoot } = ctx;
+    if (pathname !== "/api/v2/health" &&
+        pathname !== "/health" &&
+        pathname !== "/api/v1/health") {
+        return null;
+    }
+    if (!verifyBearerToken(req, options.token, options)) {
+        return jsonResponse({
+            ok: false,
+            error: {
+                code: UNAUTHORIZED,
+                message: "Invalid or missing Bearer token",
+            },
+        }, 401, corsHeaders);
+    }
+    const healthData = {
+        ok: true,
+        status: "healthy",
+        version: ACTIONDOCK_VERSION,
+        timestamp: new Date().toISOString(),
+        uptime: process.uptime(),
+    };
+    if (options.exposeDebugInfo && projectRoot) {
+        healthData.projectRoot = projectRoot;
+    }
+    return jsonResponse(healthData, 200, corsHeaders);
+}

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

@@ -1,9 +1,9 @@
-export * from "./common";
-export * from "./health";
-export * from "./info";
-export * from "./doctor";
-export * from "./actions";
-export * from "./playbooks";
-export * from "./runs";
-export * from "./state";
-export * from "./config";
+export * from "./common.js";
+export * from "./health.js";
+export * from "./info.js";
+export * from "./doctor.js";
+export * from "./actions.js";
+export * from "./playbooks.js";
+export * from "./runs.js";
+export * from "./state.js";
+export * from "./config.js";

package/dist/server/routes/index.js

@@ -0,0 +1,9 @@
+export * from "./common.js";
+export * from "./health.js";
+export * from "./info.js";
+export * from "./doctor.js";
+export * from "./actions.js";
+export * from "./playbooks.js";
+export * from "./runs.js";
+export * from "./state.js";
+export * from "./config.js";

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

@@ -1,5 +1,7 @@
-import { type RouteContext } from "./common";
+import { type RouteContext } from "./common.js";
 /**
- * 处理系统探索与自省接口（GET /api/v1/info）。
+ * 处理系统自省与包信息接口：
+ * - GET /api/v2/info 与 GET /info -> 委托 target.info()
+ * - GET /api/v2/packages 与 GET /packages -> 委托 host.info() 或 target.info()
  */
 export declare function handleInfoRoute(ctx: RouteContext): Promise<Response | null>;

package/dist/server/routes/info.js

@@ -0,0 +1,158 @@
+import { filterWithFallbackInfo } from "../../filter/index.js";
+import { PACKAGE_NOT_FOUND } from "../../errors.js";
+import { ACTIONDOCK_VERSION } from "../../version.js";
+import { sanitizeConfigDefinitions } from "../../storage/index.js";
+import { assertPackageAllowed, getSubPath, jsonResponse } from "./common.js";
+function sanitizePackage(pkg, exposeDebugInfo) {
+    if (!pkg)
+        return pkg;
+    const sanitized = {
+        ...pkg,
+        ...(pkg.config ? { config: sanitizeConfigDefinitions(pkg.config) } : {}),
+    };
+    if (exposeDebugInfo !== true) {
+        delete sanitized.packageRoot;
+        delete sanitized.path;
+    }
+    return sanitized;
+}
+/**
+ * 处理系统自省与包信息接口：
+ * - GET /api/v2/info 与 GET /info -> 委托 target.info()
+ * - GET /api/v2/packages 与 GET /packages -> 委托 host.info() 或 target.info()
+ */
+export async function handleInfoRoute(ctx) {
+    const { req, url, pathname, corsHeaders, options, target, host, projectRoot } = ctx;
+    const subpath = getSubPath(pathname);
+    // 1. Packages List: GET /api/v2/packages, /packages
+    if ((subpath === "/packages" || pathname === "/api/v2/packages" || pathname === "/packages") && req.method === "GET") {
+        try {
+            const targetPkg = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
+            if (targetPkg) {
+                assertPackageAllowed(targetPkg, options);
+            }
+            const rawPackages = target ? await target.listPackages() : (host ? await host.info() : []);
+            let packages = rawPackages.map((p) => sanitizePackage(p, options.exposeDebugInfo));
+            if (options.packageAllowlist && Array.isArray(options.packageAllowlist) && options.packageAllowlist.length > 0) {
+                packages = packages.filter((p) => p.id && options.packageAllowlist.includes(p.id));
+            }
+            return jsonResponse({
+                ok: true,
+                packages,
+            }, 200, corsHeaders);
+        }
+        catch (err) {
+            if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        code: "PACKAGE_NOT_ALLOWED",
+                        message: err.message || "Package is not in the allowed package list",
+                    },
+                }, 403, corsHeaders);
+            }
+            return jsonResponse({
+                ok: false,
+                error: { code: "PACKAGES_INFO_ERROR", message: err.message },
+            }, 500, corsHeaders);
+        }
+    }
+    // 2. Info: GET /api/v2/info, /info
+    if ((subpath === "/info" || pathname === "/api/v2/info" || pathname === "/info") && req.method === "GET") {
+        try {
+            const isTree = url.searchParams.get("tree") === "true";
+            const intent = url.searchParams.get("intent") || undefined;
+            const targetPkg = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
+            if (targetPkg) {
+                assertPackageAllowed(targetPkg, options);
+            }
+            const targetInfo = await target.info();
+            const rawPackages = targetInfo.packages || [];
+            let packages = rawPackages.map((p) => sanitizePackage(p, options.exposeDebugInfo));
+            if (options.packageAllowlist && Array.isArray(options.packageAllowlist) && options.packageAllowlist.length > 0) {
+                packages = packages.filter((p) => p.id && options.packageAllowlist.includes(p.id));
+            }
+            if (isTree) {
+                return jsonResponse({ ok: true, type: "tree", packages }, 200, corsHeaders);
+            }
+            // 显式指定 package 详情下钻
+            if (targetPkg) {
+                const matched = packages.find((p) => p.id === targetPkg || p.packageRoot === targetPkg || p.path === targetPkg);
+                if (!matched) {
+                    return jsonResponse({
+                        ok: false,
+                        error: {
+                            code: PACKAGE_NOT_FOUND,
+                            message: `Package '${targetPkg}' not found on remote server`,
+                        },
+                    }, 404, corsHeaders);
+                }
+                return jsonResponse({
+                    ok: true,
+                    type: "package_detail",
+                    ...matched,
+                    ...(options.exposeDebugInfo ? { projectRoot: matched.packageRoot || projectRoot } : {}),
+                }, 200, corsHeaders);
+            }
+            // 意图过滤
+            if (intent) {
+                const filterRes = filterWithFallbackInfo(packages, intent, [
+                    (p) => p.id,
+                    (p) => p.name,
+                    (p) => p.description,
+                ], true);
+                if (filterRes.matchedCount === 1) {
+                    const single = filterRes.items[0];
+                    return jsonResponse({
+                        ok: true,
+                        type: "package_detail",
+                        isSingleMatch: true,
+                        ...single,
+                        ...(options.exposeDebugInfo ? { projectRoot: single.packageRoot || projectRoot } : {}),
+                    }, 200, corsHeaders);
+                }
+                return jsonResponse({
+                    ok: true,
+                    type: "package_list",
+                    isFallback: filterRes.isFallback,
+                    packages: filterRes.items,
+                }, 200, corsHeaders);
+            }
+            // 单包模式下展开详情
+            if (packages.length === 1) {
+                const p = packages[0];
+                return jsonResponse({
+                    ok: true,
+                    type: "package_detail",
+                    ...p,
+                    packages,
+                    ...(options.exposeDebugInfo ? { projectRoot: p.packageRoot || projectRoot } : {}),
+                }, 200, corsHeaders);
+            }
+            // 多包列表概览
+            return jsonResponse({
+                ok: true,
+                type: "package_list",
+                version: ACTIONDOCK_VERSION,
+                packages,
+                ...(options.exposeDebugInfo ? { projectRoot } : {}),
+            }, 200, corsHeaders);
+        }
+        catch (err) {
+            if (err.code === "PACKAGE_NOT_ALLOWED" || err.status === 403) {
+                return jsonResponse({
+                    ok: false,
+                    error: {
+                        code: "PACKAGE_NOT_ALLOWED",
+                        message: err.message || "Package is not in the allowed package list",
+                    },
+                }, 403, corsHeaders);
+            }
+            return jsonResponse({
+                ok: false,
+                error: { code: "INFO_ERROR", message: err.message },
+            }, 500, corsHeaders);
+        }
+    }
+    return null;
+}

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

@@ -1,5 +1,5 @@
-import { type RouteContext } from "./common";
+import { type RouteContext } from "./common.js";
 /**
- * 处理 Playbook 列表与 SOP 详情接口。
+ * 处理 Playbook 规程相关的 HTTP 路由（列表与 SOP 详情查询）。
  */
 export declare function handlePlaybooksRoutes(ctx: RouteContext): Promise<Response | null>;