@clear-capabilities/agentic-security-scanner 0.74.0

package/dist/227.index.js

@@ -0,0 +1,192 @@
+export const id = 227;
+export const ids = [227];
+export const modules = {
+
+/***/ 7227:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   evaluatePolicy: () => (/* binding */ evaluatePolicy)
+/* harmony export */ });
+/* unused harmony export _internals */
+/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3024);
+/* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1421);
+// Policy-as-code gate (FR-SDLC-9).
+//
+// Today's CI gate is `--fail-on <severity>`. That's coarse. Customers want
+// to write nuanced rules: "fail if any sql-injection finding has
+// confidence ≥ 0.8 AND the file is under src/api/", or "fail if total
+// exploitability score across critical findings exceeds 5".
+//
+// We support two modes:
+//
+//   1. EXTERNAL OPA: if the `opa` binary is on PATH and `--policy <file.rego>`
+//      is supplied, we shell out to `opa eval -d <file> -i <findings.json>
+//      "data.<package>.deny"`. This is the right answer for customers who
+//      already use OPA elsewhere.
+//
+//   2. EMBEDDED MINI: when no opa binary is available, fall back to a tiny
+//      DSL that's a strict subset of rego. Rules read top-level
+//      `package`/`deny` blocks; each `deny` is a JS-evaluable expression
+//      over findings[]. This lets the v1 ship without an external binary
+//      dep while documenting the upgrade path.
+
+
+
+
+// ─── External OPA ─────────────────────────────────────────────────────────
+
+function _haveOpa() {
+  try {
+    const r = (0,node_child_process__WEBPACK_IMPORTED_MODULE_1__.spawnSync)('opa', ['version'], { stdio: 'ignore', timeout: 3000 });
+    return r.status === 0;
+  } catch { return false; }
+}
+
+function _runOpa(policyFile, findingsJsonPath, packageName) {
+  const r = (0,node_child_process__WEBPACK_IMPORTED_MODULE_1__.spawnSync)('opa', [
+    'eval', '-d', policyFile, '-i', findingsJsonPath,
+    `data.${packageName}.deny`,
+  ], { encoding: 'utf8', timeout: 10_000 });
+  if (r.error) return { ok: false, reason: `opa-error:${r.error.code || r.error.message}` };
+  if (r.status !== 0) return { ok: false, reason: `opa-exit:${r.status}`, stderr: r.stderr };
+  try {
+    const parsed = JSON.parse(r.stdout);
+    const result = parsed.result?.[0]?.expressions?.[0]?.value;
+    return { ok: true, denials: Array.isArray(result) ? result : [] };
+  } catch (e) {
+    return { ok: false, reason: `opa-output-parse:${e.message}` };
+  }
+}
+
+// ─── Embedded mini DSL ────────────────────────────────────────────────────
+//
+// Rego is too big to reimplement. We support a tiny shape:
+//
+//   # POLICY: agentic-security policy-gate v1
+//   deny[msg] {
+//     finding := input.findings[_]
+//     finding.severity == "critical"
+//     msg := sprintf("critical finding: %v at %v", [finding.vuln, finding.file])
+//   }
+//
+// Parser strategy: extract each `deny[msg] { ... }` block; translate the
+// body to a JS predicate. The grammar we accept is:
+//
+//   - `<lhs> == <value>` / `<lhs> != <value>` / `<lhs> > <num>` / `<lhs> < <num>`
+//   - `<lhs>` references `finding.<field>` or `input.<field>`
+//   - `msg := "..."` or `msg := sprintf("...", [args])` — the msg literal
+//   - newlines + `;` as separators
+//
+// Anything more complex requires the external OPA binary.
+
+function _parseEmbedded(policyText) {
+  const blocks = [];
+  // Match each `deny[NAME] { ... }` block (or `deny { ... }`).
+  const blockRe = /\bdeny(?:\s*\[\s*(\w+)\s*\])?\s*\{([\s\S]*?)\}/g;
+  let m;
+  while ((m = blockRe.exec(policyText))) {
+    const body = m[2];
+    const conditions = [];
+    let msgExpr = `"policy violation"`;
+    for (const line of body.split(/[\n;]/)) {
+      const ln = line.trim();
+      if (!ln || ln.startsWith('#')) continue;
+      // Assignment: `<id> := <expr>`
+      const asn = ln.match(/^(\w+)\s*:=\s*(.+)$/);
+      if (asn && asn[1] !== 'msg') continue;  // skip non-msg assignments
+      if (asn && asn[1] === 'msg') { msgExpr = asn[2].trim(); continue; }
+      // Comparison: `finding.<field> <op> <value>`
+      const cmp = ln.match(/^(finding|input)\.([a-zA-Z_][\w.]*)\s*(==|!=|<=|>=|<|>)\s*(.+)$/);
+      if (!cmp) continue;
+      const [, scope, field, op, valueRaw] = cmp;
+      let value = valueRaw.trim();
+      if (/^".*"$/.test(value)) value = JSON.stringify(value.slice(1, -1));
+      conditions.push({ scope, field, op, value });
+    }
+    blocks.push({ conditions, msgExpr });
+  }
+  return blocks;
+}
+
+function _evalBlock(block, finding) {
+  for (const c of block.conditions) {
+    const lhs = _resolvePath(finding, c.field);
+    let rhs;
+    try { rhs = JSON.parse(c.value); }
+    catch { rhs = c.value.replace(/^"|"$/g, ''); }
+    if (c.op === '==' && lhs !==  rhs) return null;
+    if (c.op === '!=' && lhs === rhs) return null;
+    if (c.op === '>'  && !(Number(lhs)  > Number(rhs))) return null;
+    if (c.op === '<'  && !(Number(lhs)  < Number(rhs))) return null;
+    if (c.op === '>=' && !(Number(lhs) >= Number(rhs))) return null;
+    if (c.op === '<=' && !(Number(lhs) <= Number(rhs))) return null;
+  }
+  return _renderMsg(block.msgExpr, finding);
+}
+
+function _resolvePath(obj, dotPath) {
+  return dotPath.split('.').reduce((o, k) => (o == null ? undefined : o[k]), obj);
+}
+
+function _renderMsg(expr, finding) {
+  // Strip outer quotes if string literal.
+  const m = expr.match(/^["'](.+)["']$/);
+  if (m) return m[1];
+  // sprintf shape: sprintf("...", [a, b])
+  const sf = expr.match(/^sprintf\s*\(\s*"([^"]+)"\s*,\s*\[(.+)\]\s*\)$/);
+  if (sf) {
+    const fmt = sf[1];
+    const args = sf[2].split(',').map(s => _resolvePath(finding, s.trim().replace(/^finding\./, '')));
+    let i = 0;
+    return fmt.replace(/%v/g, () => String(args[i++] ?? ''));
+  }
+  return expr;
+}
+
+function _runEmbedded(policyText, findings) {
+  const blocks = _parseEmbedded(policyText);
+  const denials = [];
+  for (const f of findings) {
+    for (const b of blocks) {
+      const msg = _evalBlock(b, f);
+      if (msg) denials.push(msg);
+    }
+  }
+  return { ok: true, denials };
+}
+
+// ─── Public API ────────────────────────────────────────────────────────────
+
+/**
+ * Evaluate a policy file against the findings list.
+ * Returns { ok, denials, runner } — denials is an array of human-readable
+ * strings (one per violation). When denials.length > 0, the gate fails.
+ */
+function evaluatePolicy(policyPath, findings, opts = {}) {
+  if (!policyPath || !node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(policyPath)) {
+    return { ok: false, reason: 'policy-file-missing' };
+  }
+  const policyText = node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(policyPath, 'utf8');
+  const useExternal = !opts.embeddedOnly && _haveOpa();
+  if (useExternal) {
+    // Write findings to a temp file the opa binary reads.
+    const tmp = `/tmp/as-policy-${Date.now()}.json`;
+    node_fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync(tmp, JSON.stringify({ findings }));
+    const pkgMatch = policyText.match(/^\s*package\s+([\w.]+)/m);
+    const pkg = pkgMatch ? pkgMatch[1] : 'main';
+    const r = _runOpa(policyPath, tmp, pkg);
+    try { node_fs__WEBPACK_IMPORTED_MODULE_0__.unlinkSync(tmp); } catch {}
+    if (r.ok) return { ...r, runner: 'opa' };
+    // Fall through to embedded on opa error.
+  }
+  const r = _runEmbedded(policyText, findings);
+  return { ...r, runner: 'embedded' };
+}
+
+const _internals = { _parseEmbedded, _evalBlock, _runEmbedded };
+
+
+/***/ })
+
+};

package/dist/301.index.js

@@ -0,0 +1,167 @@
+export const id = 301;
+export const ids = [301];
+export const modules = {
+
+/***/ 1301:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   describeTarget: () => (/* binding */ describeTarget),
+/* harmony export */   loadTargetManifest: () => (/* binding */ loadTargetManifest),
+/* harmony export */   validateTarget: () => (/* binding */ validateTarget)
+/* harmony export */ });
+/* unused harmony export _internals */
+/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3024);
+/* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6760);
+// Verifier target harness (FR-LIVE-HARNESS).
+//
+// Customer projects describe how to bring up the app they want the verifier
+// to execute PoCs against. The manifest lives at
+// `.agentic-security/verifier-target.yaml` and the verifier reads it before
+// running `--live` mode. v1 supports two manifest shapes:
+//
+//   shape: docker-compose
+//   compose: docker-compose.yml
+//   service: web
+//   port: 3000
+//   wait-for: http://localhost:3000/healthz
+//
+//   ─── or ───
+//
+//   shape: command
+//   start: npm run dev
+//   port: 3000
+//   wait-for: http://localhost:3000/healthz
+//   stop: pkill -f "npm run dev"
+//
+// We DO NOT execute the manifest in this module — that's the verifier
+// sandbox's job (and the customer's explicit opt-in via --live). This
+// module parses, validates, and surfaces a structured object the verifier
+// can act on (or refuse to act on).
+
+
+
+
+const MANIFEST_PATH = node_path__WEBPACK_IMPORTED_MODULE_1__.join('.agentic-security', 'verifier-target.yaml');
+
+// Minimal YAML subset parser — keep parity with the polyglot bench parser,
+// scoped to the small set of keys this manifest uses. Standalone here to
+// avoid a runtime dep.
+function _parse(text) {
+  const out = {};
+  for (const raw of String(text || '').split(/\r?\n/)) {
+    const line = raw.replace(/#.*$/, '').trim();
+    if (!line) continue;
+    const m = line.match(/^([\w-]+)\s*:\s*(.*)$/);
+    if (!m) continue;
+    const [, key, val] = m;
+    out[key] = _coerce(val);
+  }
+  return out;
+}
+
+function _coerce(v) {
+  if (v === undefined || v === null) return null;
+  v = String(v).trim();
+  if (/^".*"$/.test(v)) return v.slice(1, -1);
+  if (/^'.*'$/.test(v)) return v.slice(1, -1);
+  if (/^-?\d+$/.test(v)) return parseInt(v, 10);
+  return v;
+}
+
+/**
+ * Read the verifier-target manifest from scanRoot. Returns:
+ *   { ok: true, target } — successfully parsed and validated
+ *   { ok: false, reason } — manifest missing or invalid
+ *
+ * Never throws.
+ */
+function loadTargetManifest(scanRoot) {
+  const fp = node_path__WEBPACK_IMPORTED_MODULE_1__.join(scanRoot || process.cwd(), MANIFEST_PATH);
+  if (!node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(fp)) return { ok: false, reason: 'no-manifest' };
+  let raw;
+  try { raw = node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(fp, 'utf8'); }
+  catch (e) { return { ok: false, reason: `read-error:${e.message}` }; }
+  const parsed = _parse(raw);
+  const shape = parsed.shape;
+  if (shape !== 'docker-compose' && shape !== 'command') {
+    return { ok: false, reason: `unknown-shape:${shape || 'missing'}` };
+  }
+  if (shape === 'docker-compose') {
+    if (!parsed.compose || !parsed.service) {
+      return { ok: false, reason: 'docker-compose-shape-needs-compose-and-service' };
+    }
+  }
+  if (shape === 'command') {
+    if (!parsed.start) {
+      return { ok: false, reason: 'command-shape-needs-start' };
+    }
+  }
+  const target = {
+    shape,
+    compose: parsed.compose || null,
+    service: parsed.service || null,
+    start:   parsed.start   || null,
+    stop:    parsed.stop    || null,
+    port:    parsed.port    || null,
+    waitFor: parsed['wait-for'] || parsed.waitFor || null,
+    url:     parsed.url || (parsed.port ? `http://localhost:${parsed.port}` : null),
+  };
+  return { ok: true, target };
+}
+
+/**
+ * Render a quick summary for human consumption (CLI output, logs).
+ */
+function describeTarget(target) {
+  if (!target) return '(none)';
+  if (target.shape === 'docker-compose') {
+    return `docker-compose service ${target.service} from ${target.compose} on ${target.url || `:${target.port}`}`;
+  }
+  if (target.shape === 'command') {
+    return `command "${target.start}" on ${target.url || `:${target.port}`}`;
+  }
+  return `unknown-shape ${target.shape}`;
+}
+
+/**
+ * Pre-flight safety check: refuse to bring up a target whose start command
+ * looks dangerous. Curated allowlist of common shapes; everything else
+ * requires AGENTIC_SECURITY_VERIFY_TARGET_OK=1 to opt in explicitly.
+ */
+function validateTarget(target) {
+  if (!target) return { ok: false, reason: 'no-target' };
+  if (target.shape === 'docker-compose') {
+    // docker-compose is safe-ish by design.
+    return { ok: true };
+  }
+  if (target.shape === 'command') {
+    const SAFE_HINTS = [
+      /^npm\s+(?:run\s+)?(?:dev|start|serve)/,
+      /^yarn\s+(?:dev|start|serve)/,
+      /^pnpm\s+(?:run\s+)?(?:dev|start|serve)/,
+      /^node\s+/,
+      /^python(?:\d?)\s+-m\s+/,
+      /^python(?:\d?)\s+\S+\.py/,
+      /^uvicorn\s+/,
+      /^gunicorn\s+/,
+      /^flask\s+run/,
+      /^go\s+run\s+/,
+      /^java\s+-jar\s+/,
+      /^cargo\s+run/,
+    ];
+    if (process.env.AGENTIC_SECURITY_VERIFY_TARGET_OK === '1') return { ok: true, escaped: true };
+    if (!SAFE_HINTS.some(re => re.test(target.start))) {
+      return { ok: false, reason: `start-command-not-in-safe-allowlist (set AGENTIC_SECURITY_VERIFY_TARGET_OK=1 to override)` };
+    }
+    return { ok: true };
+  }
+  return { ok: false, reason: `unknown-shape:${target.shape}` };
+}
+
+const _internals = { MANIFEST_PATH };
+
+
+/***/ })
+
+};

package/dist/384.index.js

@@ -0,0 +1,18 @@
+export const id = 384;
+export const ids = [384];
+export const modules = {
+
+/***/ 4384:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   scanCredentials: () => (/* reexport safe */ _engine_js__WEBPACK_IMPORTED_MODULE_0__.Sv)
+/* harmony export */ });
+/* harmony import */ var _engine_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3291);
+// Secrets submodule view of the engine — credential + entropy + TODO scanning.
+
+
+
+/***/ })
+
+};

package/dist/476.index.js

@@ -0,0 +1,126 @@
+export const id = 476;
+export const ids = [476];
+export const modules = {
+
+/***/ 8476:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   synthesizeRules: () => (/* binding */ synthesizeRules)
+/* harmony export */ });
+/* unused harmony export _internals */
+/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3024);
+/* harmony import */ var node_path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6760);
+// Auto-rule synthesis from repeated FPs (FR-LEARN-6).
+//
+// Reads `.agentic-security/triage-feedback.json` (populated by the /triage
+// slash command). When 5+ findings sharing a similar shape get marked FP,
+// propose a YAML suppression rule and write it to
+// `.agentic-security/rules-proposed/auto-<timestamp>.yml`. The operator
+// reviews and either drops it into `rules/` (active) or deletes it.
+//
+// Honest scope:
+//   - We propose, we don't auto-activate. The customer decides.
+//   - Similar-shape = same (rule_id or vuln-family) AND same file glob root.
+//   - Threshold = 5 occurrences by default (env override).
+
+
+
+
+const TRIAGE_PATH = node_path__WEBPACK_IMPORTED_MODULE_1__.join('.agentic-security', 'triage-feedback.json');
+const PROPOSED_DIR = node_path__WEBPACK_IMPORTED_MODULE_1__.join('.agentic-security', 'rules-proposed');
+
+const DEFAULT_FP_THRESHOLD = 5;
+
+function _readTriage(scanRoot) {
+  const fp = node_path__WEBPACK_IMPORTED_MODULE_1__.join(scanRoot || process.cwd(), TRIAGE_PATH);
+  if (!node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(fp)) return null;
+  try { return JSON.parse(node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(fp, 'utf8')); } catch { return null; }
+}
+
+function _shapeKey(entry) {
+  // Group by rule/family + the dir prefix (first two path segments) so we
+  // suggest rules scoped to the same module — never project-wide.
+  const fam = entry.family || entry.cwe || entry.vuln || 'unknown';
+  const file = entry.file || '';
+  const dir = file.split('/').slice(0, 2).join('/') || '.';
+  return `${fam}::${dir}`;
+}
+
+function _summarizeGroup(entries) {
+  const e0 = entries[0];
+  return {
+    family: e0.family || null,
+    rule:   e0.cwe || e0.vuln || 'unknown',
+    dirGlob: (e0.file || '').split('/').slice(0, 2).join('/') + '/**',
+    count: entries.length,
+    examples: entries.slice(0, 3).map(e => `${e.file}:${e.line}`),
+  };
+}
+
+function _yamlProposal(group) {
+  const ruleId = `auto-suppress-${group.family || group.rule}-${Date.now().toString(36)}`;
+  return `# Auto-synthesised suppression proposal (FR-LEARN-6).
+# Generated from ${group.count} false-positive verdicts on ${group.family || group.rule}
+# in ${group.dirGlob}.
+#
+# Examples:
+${group.examples.map(e => '#   - ' + e).join('\n')}
+#
+# Review carefully BEFORE moving into rules/. This is a PROPOSAL.
+
+- id: ${ruleId}
+  title: "Auto-suppress: ${group.family || group.rule}"
+  description: "Repeated FP verdicts in ${group.dirGlob}"
+  shadow: true                  # never blocks CI; safe by default
+  match:
+    family: ${group.family || group.rule}
+    paths:
+      - "${group.dirGlob}"
+  action: suppress
+`;
+}
+
+/**
+ * Public entry: scan the triage history and emit a proposal YAML for any
+ * group with ≥ threshold FP verdicts. Returns the list of proposals written.
+ */
+function synthesizeRules(scanRoot, opts = {}) {
+  const threshold = parseInt(opts.threshold || process.env.AGENTIC_SECURITY_RULE_SYNTHESIS_THRESHOLD || String(DEFAULT_FP_THRESHOLD), 10);
+  const triage = _readTriage(scanRoot);
+  if (!triage) return [];
+  // triage format (per v0.46): { verdicts: [{file, line, vuln, family, verdict, ...}] }
+  const verdicts = triage.verdicts || [];
+  const fps = verdicts.filter(v => v.verdict === 'fp' || v.verdict === 'false-positive');
+  if (!fps.length) return [];
+  const groups = new Map();
+  for (const e of fps) {
+    const k = _shapeKey(e);
+    if (!groups.has(k)) groups.set(k, []);
+    groups.get(k).push(e);
+  }
+  const proposals = [];
+  const dir = node_path__WEBPACK_IMPORTED_MODULE_1__.join(scanRoot || process.cwd(), PROPOSED_DIR);
+  for (const [, group] of groups) {
+    if (group.length < threshold) continue;
+    const summary = _summarizeGroup(group);
+    const yaml = _yamlProposal(summary);
+    const name = `auto-${(summary.family || summary.rule).replace(/[^a-zA-Z0-9_-]/g, '-')}-${Date.now().toString(36)}.yml`;
+    const fp = node_path__WEBPACK_IMPORTED_MODULE_1__.join(dir, name);
+    if (!opts.dryRun) {
+      try {
+        node_fs__WEBPACK_IMPORTED_MODULE_0__.mkdirSync(dir, { recursive: true });
+        node_fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync(fp, yaml);
+      } catch { /* non-fatal */ }
+    }
+    proposals.push({ ...summary, file: fp, yaml });
+  }
+  return proposals;
+}
+
+const _internals = { DEFAULT_FP_THRESHOLD, TRIAGE_PATH, PROPOSED_DIR };
+
+
+/***/ })
+
+};