progmune-runtime 3.7.47 → 3.7.49

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## [3.7.49] — 2026-09-22
+
+### TS 侧「框架鉴权」语义标记：装饰器里的鉴权第一次对规则可见（E2）
+
+- **缺口**：NestJS 的鉴权写在装饰器里（`@UseGuards(JwtAuthGuard)`，类级或方法级），
+  既不在函数体文本里、也不在 `calls` 里 ⇒ 规则**无论如何都看不到**。
+  探针：`@UseGuards(JwtAuthGuard)` 的 `createGroup` 被报
+  「Authorization (Unauthenticated Mutation)」，而它明明有守卫。
+- **更底层的发现**：规则侧定义了 23 个 `__progmune_*` 语义标记；Python 提取器产出
+  **23/23**，TS 提取器只产出 **4/23**（C/Go/Java **0/23**）。FP 观测池 100% 是 TS/JS
+  ⇒ 规则在 TS 上跑的时候 19 条证据通道是断的。本轮补的是其中一条（且是唯一
+  「规则侧已经等着认、只是没人产」的那条）。
+- **修复**（`src/extract-ir.ts`，类方法分支追加注入）：
+  类级 + 方法级装饰器 ⇒ `__progmune_auth_machinery__`（镜像 `tools/extract_ir.py:1134`
+  的「类级框架守卫」）。**规则侧零改动**——Authorization 两条规则的 `auth_check`
+  safeguard 早已接受该标记。
+- **边界（写死）**：`@Public()` / `@SkipAuth()` 显式免鉴权不注入；
+  `@UseGuards(ThrottlerGuard)` 等非鉴权守卫不注入；`@ApiBearerAuth()` 等 Swagger
+  文档装饰器不注入；顶层函数装饰器不在本轮范围内。
+- **实测效果**（FP 观测池 6 切片 / 367 条）：Authorization 违规 **−24 条**
+  （Unauthenticated Access −11 / Mutation −13），**新增 0**，非 Authorization 规则
+  **0 变动**（与判据一致：只有接受标记的规则会受益；Input Validation 的 safeguard
+  不接受任何标记，装饰器救不了它）。
+- 回归：tsc ✓ / taintpath 160 条 ✓ / fr-007 pre 5·post 0、fr-016 pre 7·post 0 ✓ /
+  定向测试 176 全绿（新增 E2 组 11 条）/ 反向验证四刀各落自己那组、残留 0。
+  **TS 盲测 LOST 0 / ADDED 0 —— 但这是空过**：generated 语料里装饰器命中数为 0，
+  该门测不到本轮（R23 家族第三次），真证据来自 FP 观测池。
+
+## [3.7.48] — 2026-09-22
+
+### IR 提取失败必须发声（OOM 杀后的「0 违规假干净」根治）
+
+- **事故**：skyvern E1 重扫时 python3 提取器被 OOM 杀（SIGKILL），ir.json 被写成 2 字节空数组——引擎带着空 IR 照样输出「0 违规、85 分 APPROVED」，结果自洽、无任何迹象表明它是废票（静默降级比 R8 陈旧产物更阴）
+- **修复**（`src/trust/engine.ts` + `types.ts`）：
+  - 提取异常不再静默吞掉——异常信息记入 `extractionWarning`
+  - **提取后验尸**：ir.json 存在但函数数=0 且项目确有源码 ⇒ 记失败并 console.warn
+  - TrustDecision 新增 `overall.extractionWarning` 字段；失败时 `coverageConfidence` 强制降 LOW，摘要明示「本次扫描是废票，不得据此得出干净结论」
+- **E2E 验证**：空 ir.json + 1 个源文件 → warning 触发 / confidence LOW / 摘要正确
+- 回归：engine 21 + ir-staleness 12 + structural 165 全绿；build ✓
+- 后续：python3 提取分块（skyvern 级项目单进程内存峰值不可控，按目录分批提取、引擎侧合并）——机器资源恢复后按四门验收
+
 ## [3.7.47] — 2026-09-21
 
 ### 类方法的真实调用必须进 IR（状态机在 OO 代码上没有输入）

package/dist/extract-ir-taint-structural.test.js

@@ -2115,3 +2115,215 @@ export function dispatchTool(args: any) {
         }, 150000);
     }
 });
+// ═══════════════════════════════════════════════════════════════
+// E2：框架鉴权（装饰器）必须对规则可见（2026-09-22）
+//
+// 判据（先抄准再写 expect，R22）：
+//   protocol-detector.ts:398 / :430 —— Authorization (Unauthenticated Access /
+//   Mutation) 两条规则的 auth_check safeguard 接受 __progmune_auth_machinery__；
+//   探针实测：@UseGuards(JwtAuthGuard) 的 createGroup 修复前报
+//   「Authorization (Unauthenticated Mutation)」，注入标记后该条消失，
+//   而 Input Validation 仍在（它的 safeguard 不接受任何标记 ⇒ 装饰器救不了它）。
+//
+// 反面风险（注入过头 = 假阴性，比误报更危险）：
+//   @Public()/@SkipAuth() 是「显式免鉴权」，不得注入；
+//   @UseGuards(ThrottlerGuard) 是限流不是鉴权，不得注入；
+//   @ApiBearerAuth() 只是 Swagger 文档，不实施鉴权，不得注入。
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("E2：框架鉴权装饰器必须对规则可见（此前 TS 侧从未产出该标记）", () => {
+    const AUTH_MARK = "__progmune_auth_machinery__";
+    const cases = [
+        {
+            name: "正例·① 类级 @UseGuards(JwtAuthGuard)",
+            fn: "GroupController.createGroup",
+            files: {
+                "a.ts": `
+declare const UseGuards: any;
+declare const Controller: any;
+declare const Post: any;
+declare class JwtAuthGuard {}
+@UseGuards(JwtAuthGuard)
+@Controller('groups')
+export class GroupController {
+  createGroup(dto: any) { return this.svc.create(dto); }
+}
+`,
+            },
+            want: [AUTH_MARK],
+            why: "NestJS 最常见的形态：鉴权写在类上，方法体内什么都没有 ⇒ 规则原来看不见",
+        },
+        {
+            name: "正例·② 方法级 @UseGuards(JwtAuthGuard)",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+declare const UseGuards: any;
+declare class JwtAuthGuard {}
+export class C {
+  @UseGuards(JwtAuthGuard)
+  m() { return 1; }
+}
+`,
+            },
+            want: [AUTH_MARK],
+            why: "守卫挂在单个端点上（而不是整个控制器）",
+        },
+        {
+            name: "正例·③ @UseGuards(AuthGuard('jwt'))",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+declare const UseGuards: any;
+declare function AuthGuard(x: string): any;
+export class C {
+  @UseGuards(AuthGuard('jwt'))
+  m() { return 1; }
+}
+`,
+            },
+            want: [AUTH_MARK],
+            why: "NestJS 官方 passport 形态：守卫是工厂调用，实参里含 jwt",
+        },
+        {
+            name: "正例·④ @Roles('admin')",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+declare const Roles: any;
+export class C {
+  @Roles('admin')
+  m() { return 1; }
+}
+`,
+            },
+            want: [AUTH_MARK],
+            why: "角色/权限装饰器同样是框架鉴权",
+        },
+        {
+            name: "正例·⑤ @Authorize()（无实参）",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+declare const Authorize: any;
+export class C {
+  @Authorize()
+  m() { return 1; }
+}
+`,
+            },
+            want: [AUTH_MARK],
+            why: "无实参装饰器：无法靠实参判断，按装饰器名判定（保守放行）",
+        },
+        {
+            name: "负对照·① @Public() 显式免鉴权，不得注入",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+declare const UseGuards: any;
+declare const Public: any;
+declare class JwtAuthGuard {}
+@UseGuards(JwtAuthGuard)
+export class C {
+  @Public()
+  m() { return 1; }
+}
+`,
+            },
+            want: [],
+            dontWant: [AUTH_MARK],
+            why: "公开端点被判成「有鉴权」= 假阴性，比误报危险得多，必须挡住",
+        },
+        {
+            name: "负对照·② @UseGuards(ThrottlerGuard) 是限流不是鉴权",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+declare const UseGuards: any;
+declare class ThrottlerGuard {}
+export class C {
+  @UseGuards(ThrottlerGuard)
+  m() { return 1; }
+}
+`,
+            },
+            want: [],
+            dontWant: [AUTH_MARK],
+            why: "同名装饰器、非鉴权语义 ⇒ 实参必须看起来像鉴权守卫（R19：分母里最容易漏的就是被拒掉的那些）",
+        },
+        {
+            name: "负对照·③ @ApiBearerAuth() 只是 Swagger 文档",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+declare const ApiBearerAuth: any;
+export class C {
+  @ApiBearerAuth()
+  m() { return 1; }
+}
+`,
+            },
+            want: [],
+            dontWant: [AUTH_MARK],
+            why: "名字里带 auth，但不实施鉴权 ⇒ Api* 一律跳过",
+        },
+        {
+            name: "负对照·④ 无装饰器不得注入",
+            fn: "C.m",
+            files: {
+                "a.ts": `
+export class C { m() { return 1; } }
+`,
+            },
+            want: [],
+            dontWant: [AUTH_MARK],
+            why: "基线：没有鉴权证据就不许凭空给出鉴权",
+        },
+        {
+            name: "负对照·⑤ 顶层函数（非类）不在本轮范围内",
+            fn: "handler",
+            files: {
+                "a.ts": `
+declare const UseGuards: any;
+declare class JwtAuthGuard {}
+@UseGuards(JwtAuthGuard)
+export function handler() { return 1; }
+`,
+            },
+            want: [],
+            dontWant: [AUTH_MARK],
+            why: "本轮只覆盖类/方法（镜像 Python 的『类级守卫』）。顶层函数装饰器罕见，边界写死在此",
+        },
+        {
+            name: "正对照·⑥ 真实调用与既有标记不得被挤掉（E1 不回归）",
+            fn: "Uploader.read",
+            files: {
+                "a.ts": `
+import * as fs from "fs";
+declare const UseGuards: any;
+declare class JwtAuthGuard {}
+@UseGuards(JwtAuthGuard)
+export class Uploader {
+  read(filePath: string) { return fs.readFileSync(filePath, "utf-8"); }
+}
+`,
+            },
+            want: [AUTH_MARK, "readFileSync"],
+            why: "本轮是**追加**标记，不是替换；E1 补进来的真实调用必须仍在",
+        },
+    ];
+    for (const c of cases) {
+        (0, vitest_1.it)(`${c.name} —— ${c.why}`, () => {
+            const dir = makeProject(c.files);
+            try {
+                const calls = marksFor(dir, c.fn);
+                for (const w of c.want)
+                    (0, vitest_1.expect)(calls).toContain(w);
+                for (const d of c.dontWant ?? [])
+                    (0, vitest_1.expect)(calls).not.toContain(d);
+            }
+            finally {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        }, 150000);
+    }
+});

package/dist/extract-ir.js

@@ -390,6 +390,57 @@ function extractDirectCalls(func, preText) {
 // 与 protocol-detector 的同名规则（source-level benchmark 路径）。
 // ═══════════════════════════════════════════════════════════════
 const PATH_TRAVERSAL_MARKER = "__progmune_path_traversal__";
+// ═══════════════════════════════════════════════════════════════
+// E2（2026-09-22）：TS 侧「框架鉴权」语义标记 —— 镜像 tools/extract_ir.py:1134
+//
+// Python 侧由**类级框架守卫**触发（类名含 authenticator / DRF permission_classes）；
+// TS 侧的等价物是 NestJS 的类/方法级守卫装饰器：@UseGuards(JwtAuthGuard)、@Roles(...) 等。
+// 装饰器里的鉴权既不在函数体文本里、也不在 calls 里，规则**无论如何都看不到**——
+// 探针：@UseGuards(JwtAuthGuard) 的 createGroup 被报「未鉴权」，注入本标记后该条消失。
+//
+// 消费方：protocol-detector 的 Authorization (Unauthenticated Access / Mutation)
+// 两条规则的 auth_check safeguard（protocol-detector.ts:398 / :430）——它们**早已接受**
+// __progmune_auth_machinery__，TS 侧此前从未产出 ⇒ 规则侧零改动。
+//
+// 边界（写死在这里，别想当然）：只有**接受标记的规则**会受益。
+// Input Validation 的 safeguard 不接受任何 __progmune_* 标记（protocol-detector.ts:481
+// 是纯词形匹配），装饰器对它无效；实测注入后 Input Validation 条仍在。
+// ═══════════════════════════════════════════════════════════════
+const AUTH_MACHINERY_MARKER = "__progmune_auth_machinery__";
+/** 显式免鉴权装饰器 —— 出现即不注入。把公开端点判成「有鉴权」是最危险的假阴性。 */
+const AUTH_SKIP_DECORATOR = /^(?:Public|SkipAuth|AllowAnonymous|IsPublic|NoAuth|ApiExcludeEndpoint)$/i;
+/** 承载鉴权的装饰器名（NestJS 约定：Guard = 鉴权/授权）。 */
+const AUTH_DECORATOR = /^(?:UseGuards|Roles|Permissions|Authorize|RequireAuth|RequiresAuth|Authenticated|UseAuth|CheckPermissions|RequirePermissions|AdminOnly)$/i;
+/** @UseGuards(X) 的实参须像鉴权守卫 —— 用于排除 @UseGuards(ThrottlerGuard) 之类。 */
+const GUARD_ARG_AUTH = /auth|jwt|session|login|permission|role|admin|bearer|credential/i;
+/**
+ * 由类/方法装饰器判定是否注入框架鉴权标记。文本匹配（与 computeMarkerCalls 口径一致）。
+ * @returns [] 或 [AUTH_MACHINERY_MARKER]
+ */
+function authMachineryFromDecorators(decorators) {
+    let skip = false;
+    let auth = false;
+    for (const d of decorators) {
+        const text = (d?.getText?.() ?? "").trim();
+        const name = /^@([A-Za-z_$][\w$]*)/.exec(text)?.[1];
+        if (!name)
+            continue;
+        if (AUTH_SKIP_DECORATOR.test(name)) {
+            skip = true;
+            continue;
+        }
+        // Swagger 文档装饰器（@ApiBearerAuth …）只描述、不实施鉴权
+        if (/^Api/i.test(name))
+            continue;
+        if (!AUTH_DECORATOR.test(name) && !/guard|auth/i.test(name))
+            continue;
+        const args = /^@[\w$]*\(([\s\S]*)\)$/.exec(text)?.[1] ?? "";
+        if (args.trim() && !GUARD_ARG_AUTH.test(args))
+            continue;
+        auth = true;
+    }
+    return auth && !skip ? [AUTH_MACHINERY_MARKER] : [];
+}
 /**
  * 标识符是否「看起来像基目录」—— G-A2 的定案依据。
  *
@@ -2877,6 +2928,15 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                 // 顺序与函数声明 / 箭头两个分支保持一致：先真实调用，再追加语义标记。
                 const mCalls = extractDirectCalls(m, mText);
                 mCalls.push(...computeMarkerCalls(mText, mParams.map((p) => p.getName()), sinkParams, onMethodHit, guardFns, directGuardFns, shapers));
+                // E2（2026-09-22）：类级 + 方法级守卫装饰器 → 框架鉴权标记。鉴权写在装饰器里，
+                // 函数体文本与 calls 都看不到（镜像 Python 提取器的「类级框架守卫」处理）。
+                for (const mk of authMachineryFromDecorators([
+                    ...(cls.getDecorators?.() ?? []),
+                    ...(m.getDecorators?.() ?? []),
+                ])) {
+                    if (!mCalls.includes(mk))
+                        mCalls.push(mk);
+                }
                 funcs.push({
                     name: `${cn}.${mn}`,
                     params: mParams.map((p) => ({ name: p.getName(), type: getParamType(p), typeDetail: getParamTypeDetail(p) })),

package/dist/sdk.js

@@ -20,7 +20,7 @@ const risk_model_1 = require("./risk-model");
 const protocol_knowledge_1 = require("./protocol-knowledge");
 const evidence_repository_1 = require("./evidence-repository");
 /** Runtime version — stable public identifier. Internal layers evolve underneath. */
-exports.RUNTIME_VERSION = "3.7.47";
+exports.RUNTIME_VERSION = "3.7.49";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/dist/trust/engine.js

@@ -103,7 +103,7 @@ async function evaluateTrust(ctx) {
     // ── Phase 5: Build call graph for cross-function propagation ──
     const callGraph = (0, call_graph_propagator_1.buildCallGraphFromIR)(path.join(ctx.projectPath, "ir.json"));
     const enterpriseViolations = collectEnterpriseViolations(ctx);
-    const { violations: protocolViolations, coverage: mappingCoverageData, ssgCoverage: ssgCov, annotationSuggestions: cAnnotationSuggestions } = await collectProtocolViolations(ctx, callGraph);
+    const { violations: protocolViolations, coverage: mappingCoverageData, ssgCoverage: ssgCov, annotationSuggestions: cAnnotationSuggestions, extractionWarning } = await collectProtocolViolations(ctx, callGraph);
     const expressResult = collectExpressViolations(ctx);
     const nestjsResult = collectNestJSViolations(ctx);
     const trpcResult = collectTRPCViolations(ctx);
@@ -218,12 +218,20 @@ async function evaluateTrust(ctx) {
             score: effectiveScore,
             decision,
             confidence,
-            coverageConfidence: {
-                score: coverageConfidence.score,
-                margin: coverageConfidence.margin,
-                level: coverageConfidence.level,
-                summary: coverageConfidence.summary,
-            },
+            coverageConfidence: extractionWarning
+                ? {
+                    score: 0,
+                    margin: 25,
+                    level: "LOW",
+                    summary: `${extractionWarning}——本次扫描是废票，不得据此得出「干净」结论`,
+                }
+                : {
+                    score: coverageConfidence.score,
+                    margin: coverageConfidence.margin,
+                    level: coverageConfidence.level,
+                    summary: coverageConfidence.summary,
+                },
+            extractionWarning,
             mappingCoverage: mappingCoverageData.totalApis > 0
                 ? {
                     rate: Math.round(((mappingCoverageData.lookupHits + mappingCoverageData.llmHits) /
@@ -1208,6 +1216,8 @@ async function collectProtocolViolations(ctx, callGraph) {
     const annotationRuleNames = new Set();
     // C 注解建议（函数级作用域——返回值在 try 外组装）
     let annotationSuggestions;
+    // 2026-09-22：提取失败标记（跨 try 作用域，随结果返回）
+    let extractionWarning;
     try {
         // ── P4.5 校准：TS/JS 项目在 ir.json 缺失时先提取 IR ──
         // 序列必须来自「函数体内真实调用」而非「文件内函数声明名单」——
@@ -1255,10 +1265,35 @@ async function collectProtocolViolations(ctx, callGraph) {
                             `需重提取运行 PROGMUNE_IR_REEXTRACT=always 或删除 ir.json）`);
                     }
                     if (shouldExtract) {
-                        const ir = extractFn();
-                        // C 走合并形态（与 execute/MCP 写盘一致）；TS/Python 保持裸数组形态
-                        const payload = lang === "c" ? { typeMap: {}, functions: ir } : ir;
-                        fs.writeFileSync(path.join(ctx.projectPath, "ir.json"), JSON.stringify(payload, null, 2));
+                        try {
+                            const ir = extractFn();
+                            // C 走合并形态（与 execute/MCP 写盘一致）；TS/Python 保持裸数组形态
+                            const payload = lang === "c" ? { typeMap: {}, functions: ir } : ir;
+                            fs.writeFileSync(path.join(ctx.projectPath, "ir.json"), JSON.stringify(payload, null, 2));
+                        }
+                        catch (extractErr) {
+                            // 2026-09-22：提取异常不再静默吞掉——OOM 杀（exit 137）等失败
+                            // 必须发声，否则引擎带着空 IR 输出「0 违规」的假干净结论
+                            extractionWarning = `IR 提取失败（${extractErr?.message || extractErr}）——结果不可信`;
+                        }
+                    }
+                    // 2026-09-22：提取后验尸——ir.json 存在但函数数为 0 且项目确有
+                    // 源码时，说明提取被静默截断（如 python3 被 OOM 杀后留下 2 字节
+                    // 空数组），同样记为失败
+                    if (!extractionWarning) {
+                        try {
+                            const irPath2 = path.join(ctx.projectPath, "ir.json");
+                            if (fs.existsSync(irPath2)) {
+                                const raw = fs.readFileSync(irPath2, "utf-8");
+                                const parsed = JSON.parse(raw);
+                                const fnCount = Array.isArray(parsed) ? parsed.length : (parsed.functions || []).length;
+                                if (fnCount === 0 && freshness.scannedFiles > 0) {
+                                    extractionWarning = `IR 提取产物为空（0 函数，但项目有 ${freshness.scannedFiles} 个源文件）——提取可能被 OOM 截断，结果不可信`;
+                                    console.warn(`[progmune] ⚠️ ${extractionWarning}`);
+                                }
+                            }
+                        }
+                        catch { /* best-effort */ }
                     }
                 }
                 catch { /* best-effort — 回退正则扫描 */ }
@@ -1590,6 +1625,7 @@ async function collectProtocolViolations(ctx, callGraph) {
             },
         } : undefined,
         annotationSuggestions,
+        extractionWarning,
     };
 }
 function extractCallSequencesFromProject(projectPath, language, keepNames) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "progmune-runtime",
-  "version": "3.7.47",
+  "version": "3.7.49",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",