@actiondock/core 2.19.0 → 2.20.0

package/dist/server/routes/common.js

@@ -1,84 +1,48 @@
 import { assertValidPackageId } from "../../utils/index.js";
-import { ActionDockError, PACKAGE_NOT_FOUND } from "../../errors.js";
-import { ActionForbiddenError, assertActionAllowedByPolicy, assertPackageAllowedByPolicy, filterActionsByPolicy, filterPackagesByPolicy, isActionAllowed, isActionAllowedByPolicy, isManagementAllowedByPolicy, isPackageAllowedByPolicy, PackageNotAllowedError, } from "../policy.js";
-export { ActionForbiddenError, PackageNotAllowedError, isActionAllowed, isActionAllowedByPolicy, isPackageAllowedByPolicy, isManagementAllowedByPolicy, filterActionsByPolicy, filterPackagesByPolicy, assertActionAllowedByPolicy, assertPackageAllowedByPolicy, };
-/**
- * 构造带 CORS 头的标准 JSON HTTP 响应。
- */
+import { ActionDockError, PACKAGE_NOT_ALLOWED, PACKAGE_NOT_FOUND } from "../../errors.js";
+import { ActionForbiddenError, assertActionAllowedByPolicy, assertPackageAllowedByPolicy, filterActionsByPolicy, filterPackagesByPolicy, isActionAllowed, isActionAllowedByPolicy, isFullAccessGranted, isManagementAllowedByPolicy, isPackageAllowedByPolicy, isPackageVisibleByPolicy, PackageNotAllowedError, requiresMinimalPackageProjection, } from "../policy.js";
+export { ActionForbiddenError, PackageNotAllowedError, isActionAllowed, isActionAllowedByPolicy, isFullAccessGranted, isPackageAllowedByPolicy, isPackageVisibleByPolicy, isManagementAllowedByPolicy, requiresMinimalPackageProjection, filterActionsByPolicy, filterPackagesByPolicy, assertActionAllowedByPolicy, assertPackageAllowedByPolicy, };
 export function jsonResponse(data, status = 200, corsHeaders = {}) {
     return new Response(JSON.stringify(data, null, 2), {
         status,
-        headers: {
-            "Content-Type": "application/json",
-            ...corsHeaders,
-        },
+        headers: { "Content-Type": "application/json", ...corsHeaders },
     });
 }
-/**
- * 剥离标准版本前缀 (/api/v2/)，获取相对路由子路径。
- */
 export function getSubPath(pathname) {
-    if (pathname.startsWith("/api/v2/")) {
-        return pathname.slice(7);
-    }
-    return pathname;
+    return pathname.startsWith("/api/v2/") ? pathname.slice(7) : pathname;
 }
-/**
- * 校验目标 action 是否属于允许动作白名单。
- * 当 options 或 policy 中的 actionAllowlist 存在且目标 action 不在白名单中时抛出 403 ACTION_FORBIDDEN 异常。
- */
 export function assertActionAllowed(action, options) {
-    const policy = options
-        ? {
-            packageAllowlist: options.packageAllowlist,
-            actionAllowlist: options.actionAllowlist,
-        }
-        : undefined;
-    assertActionAllowedByPolicy(action, policy);
+    assertActionAllowedByPolicy(action, options);
 }
-/**
- * 校验目标 packageId 是否属于允许包白名单。
- * 当 options 或 policy 中的 packageAllowlist 存在且目标 packageId 不在白名单中时抛出 403 PACKAGE_NOT_ALLOWED 异常。
- */
 export function assertPackageAllowed(packageId, options) {
-    const policy = options
-        ? {
-            packageAllowlist: options.packageAllowlist,
-        }
-        : undefined;
-    assertPackageAllowedByPolicy(packageId, policy);
+    assertPackageAllowedByPolicy(packageId, options);
+}
+/** 包发现可见性与整包能力分开判断，不能因单动作授权开放包级管理。 */
+export function assertPackageVisible(packageId, options) {
+    if (!isPackageVisibleByPolicy(packageId, options))
+        throw new PackageNotAllowedError(packageId);
 }
-/**
- * 解析并确定生效的目标 packageId。
- * 遵循严格的解析规则与白名单检查。
- */
+/** 管理接口只能选取整包授权目标；全局管理必须显式拥有全部授权。 */
 export function resolveTargetPackageId(packages, requestedPackageId, options) {
-    const allowlist = options?.packageAllowlist;
     if (requestedPackageId) {
         if (requestedPackageId === "global") {
+            if (options && !isFullAccessGranted(options)) {
+                throw new ActionDockError(PACKAGE_NOT_ALLOWED, "Global management requires explicit full package authorization");
+            }
             return "global";
         }
         assertValidPackageId(requestedPackageId);
         assertPackageAllowed(requestedPackageId, options);
-        const matched = packages.find((p) => p.id === requestedPackageId || p.packageRoot === requestedPackageId);
+        const matched = packages.find((pkg) => pkg.id === requestedPackageId || pkg.packageRoot === requestedPackageId);
         if (!matched) {
             throw new ActionDockError(PACKAGE_NOT_FOUND, `Unknown or unregistered package: '${requestedPackageId}'`);
         }
         return matched.id;
     }
-    let targetId;
-    if (allowlist &&
-        Array.isArray(allowlist) &&
-        allowlist.length > 0) {
-        const allowed = packages.find((p) => allowlist.includes(p.id));
-        targetId = allowed ? allowed.id : (packages[0]?.id || "");
-    }
-    else if (packages.length > 0) {
-        targetId = packages[0].id;
-    }
-    else {
+    if (packages.length === 0)
         throw new ActionDockError(PACKAGE_NOT_FOUND, "No registered package found in service");
-    }
-    assertPackageAllowed(targetId, options);
-    return targetId;
+    const target = packages.find((pkg) => isPackageAllowedByPolicy(pkg.id, options));
+    if (!target)
+        throw new PackageNotAllowedError("No fully authorized package available for management");
+    return target.id;
 }

package/dist/server/routes/config.js

@@ -1,6 +1,7 @@
-import { CAPABILITY_UNAVAILABLE, CONFIG_DELETE_ERROR, CONFIG_ENV_ERROR, CONFIG_LIST_ERROR, CONFIG_SET_ERROR, INVALID_ARGUMENT, INVALID_PACKAGE_ID, PACKAGE_NOT_ALLOWED, PACKAGE_NOT_FOUND, PATH_TRAVERSAL, } from "../../errors.js";
+import { CAPABILITY_UNAVAILABLE, CONFIG_DELETE_ERROR, CONFIG_ENV_ERROR, CONFIG_LIST_ERROR, CONFIG_SET_ERROR, CONFIG_VALUE_INVALID, INVALID_ARGUMENT, INVALID_PACKAGE_ID, PACKAGE_NOT_ALLOWED, PACKAGE_NOT_FOUND, PATH_TRAVERSAL, } from "../../errors.js";
 import { resolveEnvValue } from "../../runtime/index.js";
 import { isSecretConfigKey, sanitizeConfigDefinitions } from "../../storage/index.js";
+import { assertConcreteConfigKey, isConfigTemplate } from "../../project/config-declarations.js";
 import { readJsonBody } from "../body.js";
 import { getSubPath, isManagementAllowedByPolicy, jsonResponse, resolveTargetPackageId, } from "./common.js";
 function isClientConfigError(err) {
@@ -8,6 +9,7 @@ function isClientConfigError(err) {
         err?.code === INVALID_PACKAGE_ID ||
         err?.code === PATH_TRAVERSAL ||
         err?.code === INVALID_ARGUMENT ||
+        err?.code === CONFIG_VALUE_INVALID ||
         err?.status === 400 ||
         err?.status === 404);
 }
@@ -44,6 +46,9 @@ export async function handleConfigRoutes(ctx) {
             const declared = pkg?.config || {};
             const envChecks = [];
             for (const [k, def] of Object.entries(declared)) {
+                if (isConfigTemplate(k)) {
+                    continue;
+                }
                 const resolved = resolveEnvValue(k, def, targetPackageId);
                 const matchedEnv = resolved?.envKey || null;
                 envChecks.push({
@@ -80,17 +85,38 @@ export async function handleConfigRoutes(ctx) {
             const pkg = pkgs.find((p) => p.id === targetPackageId);
             const rawDeclared = pkg?.config || {};
             const declared = sanitizeConfigDefinitions(rawDeclared) || {};
+            const queryKey = url.searchParams.get("key");
+            if (queryKey !== null) {
+                assertConcreteConfigKey(queryKey);
+                const item = await service.management.config.get(targetPackageId, queryKey);
+                return jsonResponse({ ok: true, configViewVersion: 1, packageId: targetPackageId, declared, item }, 200, corsHeaders);
+            }
             const views = await service.management.config.list(targetPackageId);
-            const maskedValues = {};
+            const maskedValues = Object.create(null);
+            const maskedPaths = Object.create(null);
             for (const v of views) {
-                if (v.secret) {
-                    maskedValues[v.key] = "********";
+                maskedPaths[v.key] = v.redactedPaths || [];
+                if (v.secret && v.value === undefined) {
+                    if (v.redactedPaths && v.redactedPaths.length > 0) {
+                        maskedValues[v.key] = "********";
+                    }
+                    else {
+                        maskedValues[v.key] = undefined;
+                    }
                 }
                 else {
                     maskedValues[v.key] = v.value;
                 }
             }
-            return jsonResponse({ ok: true, packageId: targetPackageId, declared, values: maskedValues }, 200, corsHeaders);
+            return jsonResponse({
+                ok: true,
+                configViewVersion: 1,
+                packageId: targetPackageId,
+                declared,
+                values: maskedValues,
+                items: views,
+                masked: maskedPaths,
+            }, 200, corsHeaders);
         }
         catch (err) {
             if (err.code === PACKAGE_NOT_ALLOWED || err.status === 403) {
@@ -117,6 +143,7 @@ export async function handleConfigRoutes(ctx) {
             if (!key) {
                 return jsonResponse({ ok: false, error: { code: INVALID_ARGUMENT, message: "Config 'key' is required" } }, 400, corsHeaders);
             }
+            assertConcreteConfigKey(key);
             await service.management.config.set(targetPackageId, key, body.value);
             return jsonResponse({ ok: true, packageId: targetPackageId, key, message: "updated" }, 200, corsHeaders);
         }
@@ -131,14 +158,45 @@ export async function handleConfigRoutes(ctx) {
                 }, 403, corsHeaders);
             }
             const isClient = isClientConfigError(err);
-            return jsonResponse({ ok: false, error: { code: isClient ? INVALID_ARGUMENT : CONFIG_SET_ERROR, message: err.message } }, isClient ? 400 : 500, corsHeaders);
+            const errCode = err?.code === CONFIG_VALUE_INVALID
+                ? CONFIG_VALUE_INVALID
+                : isClient
+                    ? INVALID_ARGUMENT
+                    : CONFIG_SET_ERROR;
+            return jsonResponse({ ok: false, error: { code: errCode, message: err.message, details: err.details } }, isClient ? 400 : 500, corsHeaders);
         }
     }
-    // 4. Config Delete: DELETE /config/:key
+    // 4. Config Item Route: GET /config/:key or DELETE /config/:key
     const configKeyMatch = subpath.match(/^\/config\/([^/]+)$/);
+    if (configKeyMatch && req.method === "GET") {
+        try {
+            const key = decodeURIComponent(configKeyMatch[1]);
+            assertConcreteConfigKey(key);
+            const pkgParam = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
+            const pkgs = await service.discovery.listPackages();
+            const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, policy);
+            const item = await service.management.config.get(targetPackageId, key);
+            const declared = sanitizeConfigDefinitions(pkgs.find((pkg) => pkg.id === targetPackageId)?.config) || {};
+            return jsonResponse({ ok: true, configViewVersion: 1, packageId: targetPackageId, declared, item }, 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 = isClientConfigError(err);
+            return jsonResponse({ ok: false, error: { code: isClient ? INVALID_ARGUMENT : CONFIG_LIST_ERROR, message: err.message } }, isClient ? 400 : 500, corsHeaders);
+        }
+    }
     if (configKeyMatch && req.method === "DELETE") {
         try {
             const key = decodeURIComponent(configKeyMatch[1]);
+            assertConcreteConfigKey(key);
             const pkgParam = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
             const pkgs = await service.discovery.listPackages();
             const targetPackageId = resolveTargetPackageId(pkgs, pkgParam, policy);

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

@@ -1,5 +1,6 @@
 import { type RouteContext } from "./common.js";
 /**
  * 处理环境与依赖诊断接口（GET /api/v2/doctor 与 /doctor）。
+ * 只有整包授权开放该包诊断，全局诊断必须显式授予全部包。
  */
 export declare function handleDoctorRoute(ctx: RouteContext): Promise<Response | null>;

package/dist/server/routes/doctor.js

@@ -1,8 +1,9 @@
 import { DOCTOR_ERROR, PACKAGE_NOT_ALLOWED } from "../../errors.js";
 import { runDoctorChecks } from "../../doctor/doctor.js";
-import { assertPackageAllowed, getSubPath, jsonResponse } from "./common.js";
+import { assertPackageAllowed, getSubPath, isFullAccessGranted, jsonResponse } from "./common.js";
 /**
  * 处理环境与依赖诊断接口（GET /api/v2/doctor 与 /doctor）。
+ * 只有整包授权开放该包诊断，全局诊断必须显式授予全部包。
  */
 export async function handleDoctorRoute(ctx) {
     const { req, url, pathname, corsHeaders, projectRoot, customHome, service, options, activePolicy: policy } = ctx;
@@ -12,7 +13,7 @@ export async function handleDoctorRoute(ctx) {
     }
     try {
         const targetPkg = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
-        if (policy.packageAllowlist && policy.packageAllowlist.length > 0) {
+        if (!isFullAccessGranted(policy)) {
             if (!targetPkg) {
                 return jsonResponse({
                     ok: false,
@@ -36,7 +37,7 @@ export async function handleDoctorRoute(ctx) {
             cwd: packageRoot || projectRoot || process.cwd(),
             packageIdOrPath: packageRoot || targetPkg,
             customHome,
-            packageAllowlist: policy.packageAllowlist,
+            packageAllowlist: isFullAccessGranted(policy) ? undefined : policy.packageAllowlist,
         });
         return jsonResponse({ ok: true, report }, 200, corsHeaders);
     }

package/dist/server/routes/info.js

@@ -2,7 +2,8 @@ import { filterWithFallbackInfo } from "../../utils/intent.js";
 import { INFO_ERROR, PACKAGE_NOT_ALLOWED, PACKAGE_NOT_FOUND, PACKAGES_INFO_ERROR } from "../../errors.js";
 import { ACTIONDOCK_VERSION } from "../../version.js";
 import { sanitizeConfigDefinitions } from "../../storage/index.js";
-import { assertPackageAllowed, filterPackagesByPolicy, getSubPath, jsonResponse } from "./common.js";
+import { parseActionRef } from "../../catalog/resolve-action.js";
+import { assertPackageVisible, filterPackagesByPolicy, getSubPath, jsonResponse, requiresMinimalPackageProjection, } from "./common.js";
 function sanitizePackage(pkg, exposeDebugInfo) {
     if (!pkg)
         return pkg;
@@ -16,6 +17,73 @@ function sanitizePackage(pkg, exposeDebugInfo) {
     }
     return sanitized;
 }
+/**
+ * 仅在部分授权包缺少动作清单时补查目录；已有真实清单时不增加查询。
+ */
+function requiresCatalogForMinimalProjection(packages, policy) {
+    return packages.some((p) => requiresMinimalPackageProjection(p.id, policy) && !Array.isArray(p.actions));
+}
+/**
+ * 拉取真实动作目录并按包分组，查询失败交由路由返回错误，不能伪造发现结果。
+ */
+async function listCatalogActionIds(service) {
+    const actions = await service.discovery.listActions();
+    const byPackage = new Map();
+    for (const act of actions) {
+        const parsed = parseActionRef(act.id);
+        const pkgId = act.packageId || parsed.packageId;
+        if (!pkgId)
+            continue;
+        const bucket = byPackage.get(pkgId) || [];
+        if (!bucket.includes(parsed.actionId)) {
+            bucket.push(parsed.actionId);
+        }
+        byPackage.set(pkgId, bucket);
+    }
+    return byPackage;
+}
+/**
+ * 按当前生效策略统一投影包信息。
+ * 整包授权与全量授权沿用安全脱敏后的完整结构；
+ * 仅持有单动作授权的包收缩为最小身份元数据：
+ * 仅保留 id、name、version、description 与已授权动作列表信息，
+ * 不泄露 actionsDir/playbooksDir/config/actions 完整清单/playbooks/packageRoot 等结构。
+ * 授权动作引用统一经 core parseActionRef 单一事实源归一化
+ * （兼容 @scope/pkg/read 形态与前后空白），与鉴权判定同源；
+ * 返回的已授权动作与真实包清单取交集并去重，
+ * 不把不存在的声明动作当成已发现能力，真实清单查询失败时透明返回错误。
+ * 统一投影单点收敛，避免各响应分支复制裁剪逻辑。
+ */
+function projectPackageForPolicy(pkg, policy, exposeDebugInfo, realActionIds) {
+    const sanitized = sanitizePackage(pkg, exposeDebugInfo);
+    if (!requiresMinimalPackageProjection(pkg.id, policy)) {
+        return sanitized;
+    }
+    // 授权引用统一归一化，支持带作用域的包标识和引用两端的空白。
+    const grantedRefs = new Set();
+    for (const ref of policy.actionAllowlist || []) {
+        const parsed = parseActionRef(ref);
+        if (parsed.packageId === pkg.id) {
+            grantedRefs.add(parsed.actionId);
+        }
+    }
+    // 授权声明只用于过滤真实清单，不能替代已注册能力。
+    const declaredRealActions = Array.isArray(sanitized.actions)
+        ? sanitized.actions
+        : realActionIds?.get(pkg.id) || [];
+    const grantedActionIds = Array.from(new Set(declaredRealActions
+        .map((id) => parseActionRef(id).actionId)
+        .filter((id) => grantedRefs.has(id))));
+    const minimal = {
+        id: sanitized.id,
+        ...(sanitized.name !== undefined ? { name: sanitized.name } : {}),
+        ...(sanitized.version !== undefined ? { version: sanitized.version } : {}),
+        ...(sanitized.description !== undefined ? { description: sanitized.description } : {}),
+        actions: grantedActionIds,
+        actionsCount: grantedActionIds.length,
+    };
+    return minimal;
+}
 /**
  * 处理系统自省与包信息接口：
  * - GET /api/v2/info 与 GET /info -> 委托 service.info()
@@ -29,10 +97,14 @@ export async function handleInfoRoute(ctx) {
         try {
             const targetPkg = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
             if (targetPkg) {
-                assertPackageAllowed(targetPkg, policy);
+                assertPackageVisible(targetPkg, policy);
             }
             const rawPackages = await service.discovery.listPackages();
-            const packages = filterPackagesByPolicy(rawPackages.map((p) => sanitizePackage(p, options.exposeDebugInfo)), policy);
+            // 缺少包内清单时补查真实目录，查询失败不得伪造已发现能力。
+            const realActionIds = requiresCatalogForMinimalProjection(rawPackages, policy)
+                ? await listCatalogActionIds(service)
+                : undefined;
+            const packages = filterPackagesByPolicy(rawPackages.map((p) => projectPackageForPolicy(p, policy, options.exposeDebugInfo, realActionIds)), policy);
             return jsonResponse({
                 ok: true,
                 packages,
@@ -61,14 +133,18 @@ export async function handleInfoRoute(ctx) {
             const intent = url.searchParams.get("intent") || undefined;
             const targetPkg = url.searchParams.get("package") || url.searchParams.get("packageId") || undefined;
             if (targetPkg) {
-                assertPackageAllowed(targetPkg, policy);
+                assertPackageVisible(targetPkg, policy);
             }
             const rawPackages = await service.info();
-            const packages = filterPackagesByPolicy(rawPackages.map((p) => sanitizePackage(p, options.exposeDebugInfo)), policy);
+            const realActionIds = requiresCatalogForMinimalProjection(rawPackages, policy)
+                ? await listCatalogActionIds(service)
+                : undefined;
+            const packages = filterPackagesByPolicy(rawPackages.map((p) => projectPackageForPolicy(p, policy, options.exposeDebugInfo, realActionIds)), policy);
             if (isTree) {
                 return jsonResponse({ ok: true, type: "tree", packages }, 200, corsHeaders);
             }
-            // 显式指定 package 详情下钻
+            // 显式指定 package 详情下钻：最小投影包仅返回最小身份元数据，
+            // 不能借单动作授权展开完整包结构
             if (targetPkg) {
                 const matched = packages.find((p) => p.id === targetPkg || p.packageRoot === targetPkg || p.path === targetPkg);
                 if (!matched) {
@@ -80,6 +156,14 @@ export async function handleInfoRoute(ctx) {
                         },
                     }, 404, corsHeaders);
                 }
+                const isMinimal = requiresMinimalPackageProjection(matched.id, policy);
+                if (isMinimal) {
+                    return jsonResponse({
+                        ok: true,
+                        type: "package_detail",
+                        ...matched,
+                    }, 200, corsHeaders);
+                }
                 return jsonResponse({
                     ok: true,
                     type: "package_detail",
@@ -96,12 +180,15 @@ export async function handleInfoRoute(ctx) {
                 ], true);
                 if (filterRes.matchedCount === 1) {
                     const single = filterRes.items[0];
+                    const isMinimal = requiresMinimalPackageProjection(single.id, policy);
                     return jsonResponse({
                         ok: true,
                         type: "package_detail",
                         isSingleMatch: true,
                         ...single,
-                        ...(options.exposeDebugInfo ? { projectRoot: single.packageRoot || projectRoot } : {}),
+                        ...(options.exposeDebugInfo && !isMinimal
+                            ? { projectRoot: single.packageRoot || projectRoot }
+                            : {}),
                     }, 200, corsHeaders);
                 }
                 return jsonResponse({
@@ -111,15 +198,18 @@ export async function handleInfoRoute(ctx) {
                     packages: filterRes.items,
                 }, 200, corsHeaders);
             }
-            // 单包模式下展开详情
+            // 单包模式下展开详情：最小投影包不展开 projectRoot 等调试信息
             if (packages.length === 1) {
                 const p = packages[0];
+                const isMinimal = requiresMinimalPackageProjection(p.id, policy);
                 return jsonResponse({
                     ok: true,
                     type: "package_detail",
                     ...p,
                     packages,
-                    ...(options.exposeDebugInfo ? { projectRoot: p.packageRoot || projectRoot } : {}),
+                    ...(options.exposeDebugInfo && !isMinimal
+                        ? { projectRoot: p.packageRoot || projectRoot }
+                        : {}),
                 }, 200, corsHeaders);
             }
             // 多包列表概览
@@ -141,10 +231,7 @@ export async function handleInfoRoute(ctx) {
                     },
                 }, 403, corsHeaders);
             }
-            return jsonResponse({
-                ok: false,
-                error: { code: INFO_ERROR, message: err.message },
-            }, 500, corsHeaders);
+            return jsonResponse({ ok: false, error: { code: INFO_ERROR, message: err.message } }, 500, corsHeaders);
         }
     }
     return null;

package/dist/server/routes/playbooks.js

@@ -19,9 +19,7 @@ export async function handlePlaybooksRoutes(ctx) {
             if (targetPkg) {
                 pbs = pbs.filter((p) => p.packageId === targetPkg);
             }
-            if (policy.packageAllowlist && Array.isArray(policy.packageAllowlist) && policy.packageAllowlist.length > 0) {
-                pbs = pbs.filter((p) => isPackageAllowedByPolicy(p.packageId, policy));
-            }
+            pbs = pbs.filter((p) => isPackageAllowedByPolicy(p.packageId, policy));
             if (intent) {
                 pbs = filterByIntent(pbs, intent, [(p) => p.id, (p) => p.description || "", (p) => p.packageId || "", (p) => (p.actions || []).join(" ")], false);
             }