@kenhkl/agent-moss 0.17.6 → 0.17.8

package/dist/engine/coordinator.d.ts

@@ -1,3 +1,37 @@
+interface AttackChainNode {
+    session_id: string;
+    seq: number;
+    stage: string;
+    action_detail: string;
+    resources: string[];
+    /** 节点在性质中的角色：source/carrier/sink（P2），或阶段名（P1） */
+    role?: string;
+    /** 是否为违例见证节点（当前动作补全链 / 触发外传） */
+    witness?: boolean;
+}
+interface AttackChainEdge {
+    from: number;
+    to: number;
+    type: 'next' | 'data';
+    label?: string;
+}
+/** 性质表达式 token：token 文本 + 对应节点下标（可为多个）。 */
+interface AttackChainExprToken {
+    token: string;
+    node_index: number | number[];
+}
+/** 结构化攻击链图（前端 SVG 渲染的数据契约，与 Python 端逐字段对齐）。 */
+interface AttackChainGraph {
+    /** 性质元信息（前端展示"违反了哪条性质"） */
+    property_id?: string;
+    property_short?: string;
+    property_name?: string;
+    /** 性质表达式与节点位置的对应关系 */
+    property_expression?: AttackChainExprToken[];
+    nodes: AttackChainNode[];
+    edges: AttackChainEdge[];
+}
+
 /** Security judgment result from a single analysis layer */
 interface SecurityJudgment {
     allowed: boolean;
@@ -8,6 +42,10 @@ interface SecurityJudgment {
     source: string;
     violatedLayers: string[];
     isCredential?: boolean;
+    /** 组合式拦截的结构化攻击链（前端可视化用） */
+    violationGraph?: AttackChainGraph | null;
+    /** 兼容旧调用方：反例路径数组 */
+    violationChain?: unknown[];
 }
 
 /** 把命令按 shell 的连接符切成若干段，去掉空白段。

package/dist/engine/coordinator.js

@@ -2249,7 +2249,7 @@ function _scenarioRulesToDefaults() {
   if (!existsSync5(scenDir)) return out;
   let entries;
   try {
-    entries = readdirSync4(scenDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    entries = readdirSync4(scenDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("__")).map((d) => d.name);
   } catch {
     return out;
   }
@@ -8369,7 +8369,7 @@ function markIntegrity(actionDetail) {
   }
   return { integrity: "medium", isLowSource: false };
 }
-function initNode(sessionId, seq, actionType, actionDetail, timestamp) {
+function initNode(sessionId, seq, actionType, actionDetail, timestamp, agentId = "") {
   const { integrity, isLowSource } = markIntegrity(actionDetail);
   return {
     sessionId,
@@ -8377,13 +8377,14 @@ function initNode(sessionId, seq, actionType, actionDetail, timestamp) {
     actionType,
     actionDetail,
     stage: markStage(actionDetail),
+    agentId: agentId || void 0,
     resources: extractResources(actionDetail),
     integrity,
     isLowSource,
     timestamp: timestamp || void 0
   };
 }
-function buildSessionGraph(actionHistory, aNext, sessionId = "current") {
+function buildSessionGraph(actionHistory, aNext, sessionId = "current", agentId = "") {
   const nodes = [];
   const edges = [];
   const stageFlags = /* @__PURE__ */ new Set();
@@ -8393,18 +8394,20 @@ function buildSessionGraph(actionHistory, aNext, sessionId = "current") {
     if (ad) details.push({
       actionType: String(a.actionType || ""),
       actionDetail: ad,
-      calledAt: a.calledAt || void 0
+      calledAt: a.calledAt || void 0,
+      agentId: a.agentId || agentId || void 0
     });
   }
   if (aNext) {
     details.push({
       actionType: String(aNext.actionType || ""),
       actionDetail: String(aNext.actionDetail || ""),
-      calledAt: aNext.calledAt || void 0
+      calledAt: aNext.calledAt || void 0,
+      agentId: aNext.agentId || agentId || void 0
     });
   }
   details.forEach((d, seq) => {
-    const node = initNode(sessionId, seq, d.actionType, d.actionDetail, d.calledAt);
+    const node = initNode(sessionId, seq, d.actionType, d.actionDetail, d.calledAt, d.agentId || "");
     nodes.push(node);
     if (node.stage) stageFlags.add(node.stage);
   });
@@ -8421,7 +8424,7 @@ function buildMultiSessionGraph(sessions, aNext) {
   }
   for (const s of sessions) {
     const sid = String(s.sessionId || "s");
-    mg.sessions.push(buildSessionGraph(s.actionHistory || [], void 0, sid));
+    mg.sessions.push(buildSessionGraph(s.actionHistory || [], void 0, sid, s.agentId || ""));
   }
   if (aNext) {
     const last = mg.sessions[mg.sessions.length - 1];
@@ -8431,7 +8434,8 @@ function buildMultiSessionGraph(sessions, aNext) {
         last.nodes.length,
         String(aNext.actionType || ""),
         String(aNext.actionDetail || ""),
-        aNext.calledAt || void 0
+        aNext.calledAt || void 0,
+        aNext.agentId || ""
       ));
       if (last.nodes.length > 1) {
         last.edges.push({ src: last.nodes.length - 2, dst: last.nodes.length - 1, kind: "next" });
@@ -8479,6 +8483,33 @@ function allNodesFlat(mg) {
 // src/engine/formal-engine/properties.ts
 init_esm_shims();
 init_rules_loader();
+function graphFromPath(nodes, path5, edgeType = "next", propertyMeta, roles, witnessLast = true, propertyExpression) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const n of nodes) byKey.set(`${n.sessionId}#${n.seq}`, n);
+  const gNodes = [];
+  const gEdges = [];
+  for (const item of path5) {
+    const n = byKey.get(`${item.sessionId}#${item.seq}`);
+    gNodes.push({
+      session_id: item.sessionId,
+      seq: item.seq,
+      stage: n ? n.stage : "",
+      action_detail: n ? n.actionDetail : item.detail,
+      resources: n ? [...n.resources].sort() : []
+    });
+    if (gNodes.length > 1) {
+      gEdges.push({ from: gNodes.length - 2, to: gNodes.length - 1, type: edgeType });
+    }
+  }
+  (roles || []).forEach((role, i) => {
+    if (i < gNodes.length && role) gNodes[i].role = role;
+  });
+  if (witnessLast && gNodes.length > 0) gNodes[gNodes.length - 1].witness = true;
+  const out = { nodes: gNodes, edges: gEdges };
+  if (propertyMeta) Object.assign(out, propertyMeta);
+  if (propertyExpression) out.property_expression = propertyExpression;
+  return out;
+}
 function parseTs(ts) {
   if (!ts) return null;
   const t = Date.parse(String(ts).trim());
@@ -8539,7 +8570,12 @@ function checkCrossSessionChain(graph) {
         propertyId: "cross-" + chain.id,
         reason: chain.reason,
         riskLevel: chain.riskLevel,
-        path: path5
+        path: path5,
+        graph: graphFromPath(nodes, path5, "next", {
+          property_id: "cross-" + chain.id,
+          property_short: "P1",
+          property_name: "\u8DE8\u4F1A\u8BDD\u7EC4\u5408\u94FE"
+        }, stages, true, stages.map((s, i) => ({ token: s, node_index: i })))
       });
       return violations;
     } else {
@@ -8559,7 +8595,12 @@ function checkCrossSessionChain(graph) {
           propertyId: "cross-" + chain.id,
           reason: chain.reason,
           riskLevel: chain.riskLevel,
-          path: path5
+          path: path5,
+          graph: graphFromPath(nodes, path5, "next", {
+            property_id: "cross-" + chain.id,
+            property_short: "P1",
+            property_name: "\u8DE8\u4F1A\u8BDD\u7EC4\u5408\u94FE"
+          }, stages, true, stages.map((s, i) => ({ token: s, node_index: i })))
         });
       }
     }
@@ -8574,10 +8615,15 @@ function checkSensitiveDataFlow(graph) {
   for (let i = 0; i < nodes.length; i++) {
     const n = nodes[i];
     if (n.stage === "CRED" && [...n.resources].some((r) => CRED_FILE_RE.test(r))) {
-      tainted.set(i, `${n.sessionId}#${n.seq} \u8BBF\u95EE ${[...n.resources][0]}`);
+      tainted.set(i, {
+        source: `${n.sessionId}#${n.seq} \u8BBF\u95EE ${[...n.resources][0]}`,
+        parent: null
+      });
     }
   }
   if (tainted.size === 0) return violations;
+  const taintEdges = /* @__PURE__ */ new Map();
+  const edgeKey = (p, c) => `${p}:${c}`;
   const edges = allEdges(graph);
   let changed = true;
   while (changed) {
@@ -8588,7 +8634,8 @@ function checkSensitiveDataFlow(graph) {
         const dstRes = nodes[e.dst].resources;
         for (const r of srcRes) {
           if (dstRes.has(r)) {
-            tainted.set(e.dst, tainted.get(e.src));
+            tainted.set(e.dst, { source: tainted.get(e.src).source, parent: e.src });
+            taintEdges.set(edgeKey(e.src, e.dst), r);
             changed = true;
             break;
           }
@@ -8596,16 +8643,75 @@ function checkSensitiveDataFlow(graph) {
       }
     }
   }
+  const tracePath = (idx) => {
+    const chain = [idx];
+    const seen = /* @__PURE__ */ new Set([idx]);
+    while (true) {
+      const parent = tainted.get(chain[chain.length - 1])?.parent;
+      if (parent === void 0 || parent === null || seen.has(parent)) break;
+      chain.push(parent);
+      seen.add(parent);
+    }
+    return chain.reverse();
+  };
+  const taintGraph = (chain) => {
+    const gNodes = [];
+    const gEdges = [];
+    chain.forEach((ni, k) => {
+      const n = nodes[ni];
+      const role = k === 0 ? "source" : k === chain.length - 1 ? "sink" : "carrier";
+      gNodes.push({
+        session_id: n.sessionId,
+        seq: n.seq,
+        stage: n.stage,
+        action_detail: n.actionDetail,
+        resources: [...n.resources].sort(),
+        role
+      });
+      if (k > 0) {
+        const prev = chain[k - 1];
+        gEdges.push({
+          from: k - 1,
+          to: k,
+          type: "data",
+          label: taintEdges.get(edgeKey(prev, ni)) || ""
+        });
+      }
+    });
+    if (gNodes.length > 0) gNodes[gNodes.length - 1].witness = true;
+    const expr = [{ token: "CRED", node_index: 0 }];
+    if (chain.length > 2) {
+      expr.push({
+        token: "\u5171\u4EAB\u8F7D\u4F53",
+        node_index: Array.from({ length: chain.length - 2 }, (_, i) => i + 1)
+      });
+    }
+    expr.push({ token: "EXFIL", node_index: chain.length - 1 });
+    return {
+      property_id: "sensitive-data-flow",
+      property_short: "P2",
+      property_name: "\u654F\u611F\u6570\u636E\u4F20\u64AD\u5916\u4F20",
+      property_expression: expr,
+      nodes: gNodes,
+      edges: gEdges
+    };
+  };
   const witness = graph.witnessIdx;
   const candidates = witness !== void 0 ? [witness] : nodes.map((_, i) => i);
   for (const i of candidates) {
     const n = nodes[i];
     if (tainted.has(i) && EXFIL_RE.test(n.actionDetail)) {
+      const chain = tracePath(i);
       violations.push({
         propertyId: "sensitive-data-flow",
-        reason: `\u654F\u611F\u6570\u636E\u4F20\u64AD\u5916\u4F20\uFF1A${tainted.get(i)} \u2192 ${n.sessionId}#${n.seq} \u7ECF\u5171\u4EAB\u8F7D\u4F53\u5916\u53D1`,
+        reason: `\u654F\u611F\u6570\u636E\u4F20\u64AD\u5916\u4F20\uFF1A${tainted.get(i).source} \u2192 ${n.sessionId}#${n.seq} \u7ECF\u5171\u4EAB\u8F7D\u4F53\u5916\u53D1`,
         riskLevel: "critical",
-        path: [{ sessionId: n.sessionId, seq: n.seq, detail: n.actionDetail.slice(0, 60) }]
+        path: chain.map((j) => ({
+          sessionId: nodes[j].sessionId,
+          seq: nodes[j].seq,
+          detail: nodes[j].actionDetail.slice(0, 60)
+        })),
+        graph: taintGraph(chain)
       });
       if (witness !== void 0) return violations;
     }
@@ -9325,10 +9431,14 @@ async function runAnalysis(input) {
     const formalSessions = [];
     if (input.sessionHistory) {
       for (const s of input.sessionHistory) {
-        formalSessions.push({ sessionId: s.sessionId || "s", actionHistory: s.actionHistory || [] });
+        formalSessions.push({
+          sessionId: s.sessionId || "s",
+          ...s.agentId ? { agentId: s.agentId } : {},
+          actionHistory: s.actionHistory || []
+        });
       }
     }
-    formalSessions.push({ sessionId: "current", actionHistory: input.actionHistory });
+    formalSessions.push({ sessionId: "current", agentId: input.agentId, actionHistory: input.actionHistory });
     const formalResult = formalEngine.verify(formalSessions, input.aNext);
     if (!formalResult.verified) {
       const v = formalResult.violations[0];
@@ -9345,7 +9455,9 @@ async function runAnalysis(input) {
           riskType: "formal_verification",
           confidence: 90,
           source: "formal_engine",
-          violatedLayers: ["L2.2"]
+          violatedLayers: ["L2.2"],
+          violationGraph: v?.graph ?? null,
+          violationChain: (v?.path ?? []).map((p) => [p.sessionId, p.seq, p.detail])
         };
       }
     }