@clear-capabilities/agentic-security-scanner 0.145.0 → 0.147.0

package/dist/4547.index.js

@@ -0,0 +1,268 @@
+export const id = 4547;
+export const ids = [4547];
+export const modules = {
+
+/***/ 4547:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   applyScenario: () => (/* binding */ applyScenario)
+/* harmony export */ });
+/* harmony import */ var _protection_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(965);
+/* harmony import */ var _dataflow_privacy_sink_policy_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3138);
+// scenario-engine.js — M5 deliverable #3a (FR-502): the clone-and-
+// override engine. Deep-clones the base graph, applies each declared
+// Scenario operation, then re-runs the SAME two pure aggregators
+// graph-builder.js's own real pipeline uses (aggregateVerdicts,
+// isSinkPermitted) over only the flows an operation actually touched —
+// never re-running the taint/path pipeline, per this sub-project's own
+// scoping doc.
+//
+// The exact recomputation this module mirrors, confirmed by direct
+// read of graph-builder.js's own real edge/flow minting pass:
+//   flow.protectionSummary = aggregateVerdicts([
+//     edge.protection.transit.verdict,
+//     edge.protection.atRest.verdict,
+//     edge.protection.handling.verdict,
+//   ])
+//   flow.policyVerdict = isSinkPermitted(dataElement.dataClasses, sinkNode.subtype,
+//     opts.privacySinkPolicy, { environment: opts.environment, destination: sinkNode.destination?.literalValue ?? null })
+//     ? 'permitted' : 'prohibited'  (or 'not_evaluated' if no policy/classes/sinkKind)
+
+
+
+
+function _deepClone(v) { return JSON.parse(JSON.stringify(v)); }
+
+function _byId(arr) { return new Map((arr ?? []).map((x) => [x.id, x])); }
+
+// Aggregates protectionSummary across EVERY edge belonging to `flow`, not
+// just one of them — a flow's `edgeIds` can in principle name more than
+// one edge (graph-builder.js's own real flows are always single-edge
+// today, but the schema and this module both accept a multi-edge array
+// with no restriction), and aggregateVerdicts's own documented purpose is
+// exactly this cross-branch/cross-edge reduction (PRD §8.4). Picking a
+// single arbitrary edge here would silently go stale the moment a
+// scenario is built against a genuinely multi-hop flow.
+function _recomputeProtectionSummaryForFlow(flow, graph) {
+  const edges = graph.edges.filter((e) => flow.edgeIds.includes(e.id));
+  const verdicts = edges.flatMap((e) => [
+    e.protection.transit.verdict,
+    e.protection.atRest.verdict,
+    e.protection.handling.verdict,
+  ]);
+  return (0,_protection_js__WEBPACK_IMPORTED_MODULE_0__/* .aggregateVerdicts */ .SX)(verdicts);
+}
+
+function _recomputePolicyVerdict(flow, graph, opts) {
+  if (opts.privacySinkPolicy == null) return null; // signal: leave flow.policyVerdict untouched
+  const de = graph.dataElements.find((d) => flow.dataElementIds.includes(d.id));
+  const sinkNode = graph.nodes.find((n) => n.id === flow.sink);
+  const classes = de?.dataClasses ?? [];
+  const sinkKind = sinkNode?.subtype ?? null;
+  if (!classes.length || !sinkKind) return 'not_evaluated';
+  const ctx = {
+    environment: opts.environment ?? process.env.AGENTIC_SECURITY_ENVIRONMENT ?? null,
+    destination: sinkNode?.destination?.literalValue ?? null,
+  };
+  return (0,_dataflow_privacy_sink_policy_js__WEBPACK_IMPORTED_MODULE_1__/* .isSinkPermitted */ .i$)(classes, sinkKind, opts.privacySinkPolicy, ctx) ? 'permitted' : 'prohibited';
+}
+
+// Every flow using this edge (by edgeIds membership) gets protectionSummary
+// recomputed; policyVerdict only for flows whose sink node's destination
+// or the flow's own dataClasses could plausibly have changed — but since
+// applyScenario always calls this after ANY node/edge touch to be safe
+// (recomputation is cheap and idempotent), scope is simply "every flow
+// touching this edge or this node".
+function _touchedFlows(graph, { edgeId, nodeId }) {
+  return graph.flows.filter((f) =>
+    (edgeId && f.edgeIds.includes(edgeId)) ||
+    (nodeId && (f.source === nodeId || f.sink === nodeId)));
+}
+
+function _recomputeTouchedFlows(graph, touch, opts) {
+  for (const flow of _touchedFlows(graph, touch)) {
+    flow.protectionSummary = _recomputeProtectionSummaryForFlow(flow, graph);
+    const newPolicyVerdict = _recomputePolicyVerdict(flow, graph, opts);
+    if (newPolicyVerdict !== null) flow.policyVerdict = newPolicyVerdict;
+  }
+}
+
+function _applyRequireTransitProtection(graph, op) {
+  const edge = _byId(graph.edges).get(op.targetEdgeId);
+  if (!edge) return { ok: false, reason: `targetEdgeId "${op.targetEdgeId}" not found in graph.edges` };
+  edge.protection.transit = { verdict: 'protected', evidenceGrade: 'assumed' };
+  _recomputeTouchedFlows(graph, { edgeId: edge.id }, op._opts);
+  return { ok: true };
+}
+
+function _applyHandling(graph, op) {
+  const edge = _byId(graph.edges).get(op.targetEdgeId);
+  if (!edge) return { ok: false, reason: `targetEdgeId "${op.targetEdgeId}" not found in graph.edges` };
+  // Mirrors graph-builder.js's own gate (~line 757): 'encrypted' handling
+  // only earns the atRest 'protected' verdict when the edge's sink node
+  // is store-kind (database/file/object-storage/cache/client-storage/
+  // backup/export). For any other sink kind (e.g. 'external-api',
+  // 'queue') "at rest" isn't even a meaningful concept — falls through to
+  // the same 'handling' dimension the non-encrypted case already sets.
+  const sinkNode = graph.nodes.find((n) => n.id === edge.to);
+  if (op.handling === 'encrypted' && sinkNode?.kind === 'store') {
+    edge.protection.atRest = { verdict: 'protected', evidenceGrade: 'assumed' };
+  } else {
+    edge.protection.handling = { verdict: 'protected', evidenceGrade: 'assumed' };
+  }
+  _recomputeTouchedFlows(graph, { edgeId: edge.id }, op._opts);
+  return { ok: true };
+}
+
+function _applyRemoveEntity(graph, op) {
+  const node = _byId(graph.nodes).get(op.targetNodeId);
+  if (!node) return { ok: false, reason: `targetNodeId "${op.targetNodeId}" not found in graph.nodes` };
+  const removedEdgeIds = new Set(graph.edges.filter((e) => e.from === node.id || e.to === node.id).map((e) => e.id));
+  graph.edges = graph.edges.filter((e) => !removedEdgeIds.has(e.id));
+  graph.flows = graph.flows.filter((f) => f.source !== node.id && f.sink !== node.id
+    && !f.edgeIds.some((id) => removedEdgeIds.has(id)));
+  graph.nodes = graph.nodes.filter((n) => n.id !== node.id);
+  // Cascade-prune graph.recipientProfiles[] too — a RecipientProfile whose
+  // contributingGraphIds referenced ONLY this now-removed node must not
+  // survive dangling (a downstream `dataflow export --format recipients`
+  // consumer filters by exactly contributingGraphIds against surviving
+  // node ids); a profile with OTHER surviving contributing ids just loses
+  // this one id, never the whole record. Guarded on the array existing —
+  // the base graph shape used throughout this sub-project's own tests
+  // doesn't always include it. A profile with NO contributingGraphIds at
+  // all (null/undefined — real graph-builder.js output always mints a
+  // non-empty array, so this is defensive against a hand-built/external
+  // graph only) is left untouched rather than normalized to `[]` and
+  // dropped, since a missing array is not evidence the profile referenced
+  // this node.
+  // NOTE (final-review re-review N2, disclosed not fixed): this cascade
+  // is real graph mutation, but scenario-diff.js's WATCHED_SCENARIO_FIELDS
+  // has no `recipientProfile` kind, so diffScenarioGraph's own delta
+  // report stays silent about a recipient record that disappeared or lost
+  // a contributing id here — a future increment's fuller fix, not scope
+  // creep for this pass.
+  if (graph.recipientProfiles?.length) {
+    graph.recipientProfiles = graph.recipientProfiles
+      .map((rp) => (rp.contributingGraphIds == null ? rp
+        : { ...rp, contributingGraphIds: rp.contributingGraphIds.filter((id) => id !== node.id) }))
+      .filter((rp) => rp.contributingGraphIds == null || rp.contributingGraphIds.length > 0);
+  }
+  return { ok: true };
+}
+
+// Scoped, at the applier level, to exactly `node.destination` — this
+// sub-project's own scoping doc maps "replace a provider or move region"
+// onto node.destination, the graph-level equivalent of a recipient's
+// technical endpoint, and nothing else. scenario.js's own
+// SCENARIO_OPERATION_REQUIRED_FIELDS only requires `field` be a non-empty
+// string, never restricts its value — a real applied write to any other
+// top-level node field (e.g. 'subtype') would land on the node but be
+// completely invisible to scenario-diff.js's WATCHED_SCENARIO_FIELDS.node
+// (which only watches 'destination'/'storeDetail'), since that list can
+// only stay exhaustive if this applier never writes outside it. Rejecting
+// any other field here — never widening the watch list — is what keeps
+// that list exhaustive by construction. Mirrors the existing "skip a
+// target id it can't find" pattern: reported in skippedOperations, never
+// thrown.
+function _applyReplaceRecipientFact(graph, op) {
+  const node = _byId(graph.nodes).get(op.targetNodeId);
+  if (!node) return { ok: false, reason: `targetNodeId "${op.targetNodeId}" not found in graph.nodes` };
+  if (op.field !== 'destination') {
+    return { ok: false, reason: `replace_recipient_fact only supports field "destination" (got "${op.field}") — this operation is scoped to a node's recipient/destination fact only` };
+  }
+  node[op.field] = _deepClone(op.value);
+  // The destination just changed — any edge.protection.transit verdict INTO
+  // this node was derived from the OLD destination (transit-protection.js's
+  // resolveTransitProtectionForSite is keyed on the sink's own destination)
+  // and is now stale. Never let a stale verdict survive with a real (non-
+  // 'assumed') evidence grade — reset to the honest "we don't know anymore"
+  // state rather than re-derive (re-deriving needs transitEvidenceByFile,
+  // IR-level data unavailable post-build) or silently keep the old verdict.
+  // NOTE (final-review re-review N1, disclosed not fixed): this demotion is
+  // per-EDGE and is always honest at that level (and always visible in
+  // diffScenarioGraph's own delta, since edge.protection.transit is a
+  // WATCHED_SCENARIO_FIELDS.edge entry) — but flow.protectionSummary
+  // aggregates transit/atRest/handling via aggregateVerdicts, whose
+  // precedence ranks not_assessed LAST, so a scenario that ALSO sets this
+  // edge's own handling dimension to 'protected' (via apply_handling) in
+  // the SAME operations list can mask the demotion at the flow-summary
+  // level, even though the masking verdict itself is honestly graded
+  // 'assumed'. graph-builder.js's own cross-dimension aggregation is
+  // documented safe only because transit/atRest are mutually exclusive by
+  // construction and handling is "never written" by any real analyzer —
+  // this module (scenario-engine.js) is the one exception to that last
+  // clause, which is exactly what makes the masking reachable here.
+  for (const edge of graph.edges) {
+    if (edge.to === node.id) {
+      edge.protection.transit = { verdict: 'not_assessed', evidenceGrade: 'none' };
+    }
+  }
+  _recomputeTouchedFlows(graph, { nodeId: node.id }, op._opts);
+  return { ok: true };
+}
+
+function _applyChangeStorageFact(graph, op) {
+  const node = _byId(graph.nodes).get(op.targetNodeId);
+  if (!node) return { ok: false, reason: `targetNodeId "${op.targetNodeId}" not found in graph.nodes` };
+  node.storeDetail = { ...(node.storeDetail ?? {}), [op.field]: _deepClone(op.value) };
+  return { ok: true };
+}
+
+function _applyChangeGovernanceFact(graph, op) {
+  const flow = _byId(graph.flows).get(op.targetFlowId);
+  if (!flow) return { ok: false, reason: `targetFlowId "${op.targetFlowId}" not found in graph.flows` };
+  flow.governanceRefs = { ...(flow.governanceRefs ?? {}), [op.field]: _deepClone(op.value) };
+  return { ok: true };
+}
+
+const _APPLIERS = {
+  require_transit_protection: _applyRequireTransitProtection,
+  apply_handling: _applyHandling,
+  remove_entity: _applyRemoveEntity,
+  replace_recipient_fact: _applyReplaceRecipientFact,
+  change_storage_fact: _applyChangeStorageFact,
+  change_governance_fact: _applyChangeGovernanceFact,
+};
+
+/**
+ * Apply `scenario.operations` to a deep clone of `baseGraph`. Never
+ * mutates `baseGraph`. An operation whose target id does not exist in
+ * the graph is skipped (reported in `skippedOperations`), never thrown —
+ * a Scenario written against an older snapshot must degrade honestly.
+ * `opts.privacySinkPolicy`/`opts.environment` mirror graph-builder.js's
+ * own opts; omitting privacySinkPolicy means policyVerdict
+ * recomputation is skipped entirely (base value kept on every touched
+ * flow) rather than guessed.
+ *
+ * Scenario-shape validation (`validateScenario`, `scenario.js`) is the
+ * CALLER's responsibility, not this module's — this function does no
+ * upfront shape checking beyond each operation's own per-target `_byId`
+ * lookup. An unrecognized `op.kind` is skipped via the `_APPLIERS` map
+ * lookup below rather than validated against `SCENARIO_OPERATION_KINDS`
+ * ahead of time. This mirrors `recipient-profile.js`'s own precedent,
+ * where `validateRecipientProfile` is never called internally by any
+ * producer either — the CLI layer (Task 4) calls `validateScenario`
+ * before `applyScenario`, by design.
+ */
+function applyScenario(baseGraph, scenario, opts = {}) {
+  const graph = _deepClone(baseGraph);
+  const appliedOperations = [];
+  const skippedOperations = [];
+  for (const op of scenario.operations ?? []) {
+    const applier = _APPLIERS[op.kind];
+    if (!applier) {
+      skippedOperations.push({ operation: op, reason: `unrecognized operation kind "${op.kind}"` });
+      continue;
+    }
+    const result = applier(graph, { ...op, _opts: opts });
+    if (result.ok) appliedOperations.push({ operation: op });
+    else skippedOperations.push({ operation: op, reason: result.reason });
+  }
+  return { graph, appliedOperations, skippedOperations };
+}
+
+
+/***/ })
+
+};