blitzstrike 1.0.40 → 1.0.43

package/CHANGELOG.md

@@ -5,6 +5,59 @@ All notable changes to Blitz Strike are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [1.0.43] — 2026-09-13
+
+### Added
+
+- **Phase 8 — Production Hardening**:
+  - **Caching** (`src/cache.ts`, §46) — versioned result cache (`sha256(source) + engine_version`);
+    wired into `analyzeDataFlow2` so unchanged files skip re-parsing.
+  - **SARIF export** (`src/sarif.ts`, §32) — `toSarif()` emits a SARIF 2.1.0 document
+    (GitHub Code Scanning / GitLab / Azure DevOps).
+  - **Release validation** (`src/release.ts`, §49) — `validateRelease()` checks
+    package.json vs CHANGELOG (hard) + git tag / npm registry / lockfile (soft).
+  - **Dependency security** (`src/dependency.ts`, §50) — `checkDependencies()`
+    inspects install-time scripts and git/unusual dependency sources.
+  - **Incremental analysis** (`src/incremental.ts`, §47) — `analyzeChangedFiles()`
+    re-analyzes only the files a commit touched (git diff → changed files → engine).
+  - **CI/CD** (`.github/workflows/ci.yml`, §48) — typecheck, tests, build, npm pack,
+    release-consistency, and dependency-surface gates.
+  - `blitzstrike doctor` now reports release-metadata and dependency-surface health.
+
+## [1.0.42] — 2026-09-13
+
+### Added
+
+- **Phase 7 — MCP Orchestration** (`src/orchestration.ts`, wired into `run_engagement`):
+  - A data-driven **state machine** (10 states: scope_check → plan → recon →
+    analyze → hypothesis → select_chain → validate → evidence → finding → report).
+  - A deterministic **planner** (`buildPlan`) that emits an ordered plan with
+    per-step tool, risk level, evidence requirements, and done/pending/blocked status.
+  - A **risk policy** (`actionPermitted`) that gates high-risk actions
+    (strike_verify, confirm_finding) behind scope.
+  - **§34 agent guidance** (`computeGuidance`) — every result now exposes
+    current_state / confidence / blocking_reason / required_evidence /
+    recommended_next_action / recommended_tool.
+  - `run_engagement` output now includes `state`, `plan`, `guidance`, and
+    `risk_policy` (no new MCP tools added — the surface was deepened, not widened).
+
+## [1.0.41] — 2026-09-13
+
+### Added
+
+- **Phase 6 — Browser Validation** (`src/browser.ts` + MCP tool `browser_validate`):
+  - Playwright-based validation of static-analysis hypotheses (not a scanner —
+    gated, "use only when necessary").
+  - Checks: `dom_xss` (marker-payload execution), `open_redirect` (unexpected
+    redirect), `auth_bypass` (missing auth enforcement), `csrf` (tokenless
+    state-changing form).
+  - Each check returns structured evidence (verdict + final_url + dom/console/
+    page-error signals) suitable for attaching to a finding.
+  - `playwright-core` is an **optional peer dependency**; `browser_validate`
+    degrades to a clear `unavailable` result when it is not installed.
+  - Hermetic browser test suite (`bun run test:browser`, 8 checks) against a
+    local vulnerable server.
+
 ## [1.0.40] — 2026-09-13
 
 ### Changed (review + spec alignment)
@@ -116,6 +169,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
   now use `\b` word boundaries, so `outer_exec(...)` is no longer misclassified
   as command execution.
 
+## [1.0.34] — 2026-09-13
+
+### Fixed (Phase 1 review)
+
+- `hasSecrets` rewritten as `redactSecrets(text) !== text` — deterministic
+  (fixed the `g`-flag `.test()` state bug) and no false positive on already-redacted
+  content (`password=[REDACTED]` is no longer flagged).
+- Wired `finding_updated` audit event into `transition()` / `rejectFinding()`.
+
 ## [1.0.33] — 2026-09-13
 
 ### Added
@@ -142,6 +204,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 - Shared `src/version.ts` — single source of truth for the package version
   (removed the duplicate VERSION readers in `server.ts`).
 
+## [1.0.32] — 2026-09-13
+
+### Added
+
+- Self-update: `blitzstrike update` CLI command + `check_update` MCP tool
+  (`src/update.ts` with semver-aware version comparison).
+
+## [1.0.31] — 2026-09-13
+
+### Changed
+
+- npm publish pipeline debug (version bump only, no functional change).
+
+## [1.0.30] — 2026-09-13
+
+### Changed
+
+- Removed source attribution from the attack-vector taxonomy data (first-party
+  content; `_comment` and notices stripped).
+
+## [1.0.29] — 2026-09-13
+
+### Added
+
+- Attack-vector taxonomy (`intelligence/attack_vectors.json`, 34 categories /
+  588 vectors) + `list_attack_vectors` + `attack_vectors` MCP tools.
+
+## [1.0.28] — 2026-09-13
+
+### Fixed
+
+- Benchmark corpus writes to the OS temp directory (hermetic; no writes inside
+  the read-only package).
+
+## [1.0.27] — 2026-09-13
+
+### Added
+
+- Documentation milestone: CHANGELOG / ROADMAP / README + docs metrics.
+
 ## [1.0.26] — 2026-09-13
 
 The first hardening milestone: the whole roadmap is implemented, measured, and

package/dist/index.js

@@ -30238,6 +30238,87 @@ function rejectFinding(finding, status, reason, evidence) {
   };
 }
 
+// src/orchestration.ts
+var STATE_MACHINE = [
+  { state: "scope_check", description: "Validate target against scope + risk policy.", recommended_tools: ["scope_check"], required_evidence: ["scope_decision"], next: ["plan"], confidence: "high" },
+  { state: "plan", description: "Derive the engagement plan from surface + scope.", recommended_tools: ["list_chains"], required_evidence: ["plan_steps"], next: ["recon"], confidence: "high" },
+  { state: "recon", description: "Map the attack surface (endpoints, tech, WAF).", recommended_tools: ["blitz_scan", "active_scan", "fofa_search", "detect_waf"], required_evidence: ["attack_surface"], next: ["analyze"], confidence: "medium" },
+  { state: "analyze", description: "Trace source→sink flows (interprocedural taint).", recommended_tools: ["eagle_eye2", "blitz_scan", "blitz_file"], required_evidence: ["sink_hits", "taint_flow"], next: ["hypothesis"], confidence: "medium" },
+  { state: "hypothesis", description: "Form defensible hypotheses (static finding).", recommended_tools: ["blitz_file", "enrich_scan"], required_evidence: ["static_finding"], next: ["select_chain"], blocking: "live_validation_required", confidence: "high" },
+  { state: "select_chain", description: "Match the hypothesis to an escalation chain.", recommended_tools: ["list_chains", "read_playbook"], required_evidence: ["matched_chain"], next: ["validate"], confidence: "high" },
+  { state: "validate", description: "Verify live with baseline + marker + negative control.", recommended_tools: ["strike_verify", "browser_validate"], required_evidence: ["baseline", "marker_reflection", "negative_control"], next: ["evidence"], confidence: "medium" },
+  { state: "evidence", description: "Attach hashable, provenance-bound evidence.", recommended_tools: ["finding_attach_evidence"], required_evidence: ["evidence_artifact"], next: ["finding"], confidence: "high" },
+  { state: "finding", description: "Confirm the finding (invariants enforced).", recommended_tools: ["confirm_finding"], required_evidence: ["confirmed_finding"], next: ["report"], confidence: "high" },
+  { state: "report", description: "Produce a reproducible report.", recommended_tools: ["report", "security-report"], required_evidence: ["report"], next: [], confidence: "high" }
+];
+function stateDefinition(state) {
+  return STATE_MACHINE.find((s) => s.state === state);
+}
+var RISK_POLICY = [
+  { action: "scope_check", risk: "low", requires_scope: false, destructive: false },
+  { action: "blitz_scan", risk: "low", requires_scope: false, destructive: false },
+  { action: "blitz_file", risk: "low", requires_scope: false, destructive: false },
+  { action: "eagle_eye2", risk: "low", requires_scope: false, destructive: false },
+  { action: "enrich_scan", risk: "low", requires_scope: false, destructive: false },
+  { action: "detect_waf", risk: "low", requires_scope: false, destructive: false },
+  { action: "fofa_search", risk: "low", requires_scope: false, destructive: false },
+  { action: "list_chains", risk: "low", requires_scope: false, destructive: false },
+  { action: "read_playbook", risk: "low", requires_scope: false, destructive: false },
+  { action: "active_scan", risk: "medium", requires_scope: true, destructive: false },
+  { action: "browser_validate", risk: "medium", requires_scope: true, destructive: false },
+  { action: "strike_verify", risk: "high", requires_scope: true, destructive: false },
+  { action: "confirm_finding", risk: "high", requires_scope: true, destructive: false }
+];
+function riskOf(action) {
+  return RISK_POLICY.find((r) => r.action === action) ?? null;
+}
+function actionPermitted(action, scopeAllowed, mode) {
+  const rule = riskOf(action);
+  if (!rule)
+    return true;
+  if (mode === "ctf" || mode === "offensive" || mode === "reverse-engineering")
+    return true;
+  if (rule.requires_scope && !scopeAllowed)
+    return false;
+  return true;
+}
+function buildPlan(scopeAllowed, mode, executedState) {
+  const order = ["scope_check", "plan", "recon", "analyze", "hypothesis", "select_chain", "validate", "evidence", "finding", "report"];
+  const executedIdx = order.indexOf(executedState);
+  return order.map((state, i) => {
+    const def = stateDefinition(state);
+    const tool = def.recommended_tools[0] ?? "";
+    const rule = riskOf(tool);
+    const permitted = actionPermitted(tool, scopeAllowed, mode);
+    const status = i <= executedIdx ? "done" : permitted ? "pending" : "blocked";
+    return {
+      order: i + 1,
+      state,
+      action: def.description,
+      tool,
+      evidence_required: def.required_evidence,
+      risk: rule?.risk ?? "low",
+      permitted,
+      status
+    };
+  });
+}
+function computeGuidance(state, scopeAllowed) {
+  const def = stateDefinition(state);
+  const next = def.next[0];
+  const nextDef = next ? stateDefinition(next) : null;
+  const tool = nextDef?.recommended_tools[0] ?? "";
+  const permitted = actionPermitted(tool, scopeAllowed, "bug-bounty");
+  return {
+    state,
+    confidence: def.confidence,
+    blocking_reason: !scopeAllowed && nextDef && riskOf(tool)?.requires_scope ? "scope_required" : def.blocking ?? null,
+    required_evidence: def.required_evidence,
+    recommended_next_action: nextDef?.description ?? "complete",
+    recommended_tool: permitted ? tool : ""
+  };
+}
+
 // src/orchestrator.ts
 var _chainsCache = null;
 function loadChains() {
@@ -30451,6 +30532,17 @@ function runEngagement(target, scope = "", mode = "bug-bounty", maxFiles = 2000,
   }));
   report.status = "COMPLETE";
   report.note = "All findings are HYPOTHESES until verified live with strike_verify. " + "Apply each chain's negative_control before reporting. Confidence reflects static evidence only.";
+  const executedState = "select_chain";
+  const scopeAllowed = report.scope?.allowed ?? false;
+  const plan = buildPlan(scopeAllowed, mode, executedState);
+  report.state = executedState;
+  report.state_description = stateDefinition(executedState).description;
+  report.plan = plan;
+  report.guidance = computeGuidance(executedState, scopeAllowed);
+  report.risk_policy = {
+    note: "High-risk actions (strike_verify, confirm_finding) require scope + are never run server-side automatically.",
+    gated: plan.filter((p) => !p.permitted).map((p) => p.tool)
+  };
   if (remember) {
     let captured = 0;
     for (const mc of blitz.matched_chains) {
@@ -31803,6 +31895,29 @@ function entryPoints(g) {
   return entries;
 }
 
+// src/cache.ts
+import { createHash as createHash3 } from "node:crypto";
+var mem = new Map;
+var hits = 0;
+var misses = 0;
+function cacheKey(kind, source) {
+  const h = createHash3("sha256").update(source).digest("hex").slice(0, 20);
+  return `${kind}:${VERSION}:${h}`;
+}
+function getCache(kind, source) {
+  const k = cacheKey(kind, source);
+  if (mem.has(k)) {
+    hits += 1;
+    return mem.get(k);
+  }
+  misses += 1;
+  return;
+}
+function setCache(kind, source, value) {
+  mem.set(cacheKey(kind, source), value);
+  return value;
+}
+
 // src/eagle2.ts
 var parser3 = new import_php_parser3.Engine({
   parser: { extractDoc: false, php7: true },
@@ -32230,6 +32345,15 @@ function resolveFuncId(name, summaries) {
   return null;
 }
 function analyzeDataFlow2(path) {
+  let cacheCode = "";
+  try {
+    cacheCode = readFileSync12(path, "utf8");
+  } catch {}
+  if (cacheCode) {
+    const cached = getCache("eagle2", cacheCode);
+    if (cached)
+      return cached;
+  }
   const cg = buildCallGraph(path);
   const entries = entryPoints(cg);
   const reachable = new Set;
@@ -32245,7 +32369,7 @@ function analyzeDataFlow2(path) {
   };
   let code;
   try {
-    code = readFileSync12(path, "utf8");
+    code = cacheCode || readFileSync12(path, "utf8");
   } catch {
     return result;
   }
@@ -32354,6 +32478,8 @@ function analyzeDataFlow2(path) {
         queue.push({ funcId: calleeId, param: calleeParam, source: item.source, sourceLine: item.sourceLine, viaReturn: false });
     }
   }
+  if (cacheCode)
+    setCache("eagle2", cacheCode, result);
   return result;
 }
 
@@ -51040,6 +51166,162 @@ function scanFramework(code, frameworkId) {
   };
 }
 
+// src/browser.ts
+var chromiumCache = null;
+async function ensureChromium() {
+  if (chromiumCache)
+    return chromiumCache;
+  try {
+    chromiumCache = await import("playwright-core");
+    return chromiumCache;
+  } catch {
+    return null;
+  }
+}
+function unavailable(check, target, reason) {
+  return {
+    check,
+    target: redactSecrets(target),
+    verdict: "unavailable",
+    detail: reason,
+    evidence: { console_errors: [], page_errors: [] }
+  };
+}
+function errorEvidence(check, target, e) {
+  return {
+    check,
+    target: redactSecrets(target),
+    verdict: "error",
+    detail: e instanceof Error ? e.message : String(e),
+    evidence: { console_errors: [], page_errors: [] }
+  };
+}
+async function validateDomXss(target, payload = '<img src=x onerror="window.__blitz_xss__=true">') {
+  const chr = await ensureChromium();
+  if (!chr)
+    return unavailable("dom_xss", target, "playwright-core not installed (optional peer dependency)");
+  const browser = await chr.chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    const consoleErrors = [];
+    const pageErrors = [];
+    page.on("console", (m) => {
+      if (m.type() === "error")
+        consoleErrors.push(m.text());
+    });
+    page.on("pageerror", (e) => pageErrors.push(String(e)));
+    const url = target.includes("{{payload}}") ? target.replace("{{payload}}", encodeURIComponent(payload)) : target;
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 15000 });
+    await page.waitForTimeout(600);
+    const marker = await page.evaluate(() => window.__blitz_xss__ === true);
+    return {
+      check: "dom_xss",
+      target: redactSecrets(target),
+      verdict: marker ? "confirmed" : "not_confirmed",
+      detail: marker ? "payload executed (marker set)" : "payload did not execute (no marker)",
+      evidence: { final_url: page.url(), dom_marker: marker, console_errors: consoleErrors, page_errors: pageErrors }
+    };
+  } catch (e) {
+    return errorEvidence("dom_xss", target, e);
+  } finally {
+    await browser.close();
+  }
+}
+async function validateOpenRedirect(target, payload) {
+  const chr = await ensureChromium();
+  if (!chr)
+    return unavailable("open_redirect", target, "playwright-core not installed (optional peer dependency)");
+  const browser = await chr.chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    const url = target.includes("{{payload}}") ? target.replace("{{payload}}", encodeURIComponent(payload)) : target;
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 15000 });
+    await page.waitForTimeout(400);
+    const finalUrl = page.url();
+    const redirected = finalUrl !== url && finalUrl.includes(payload);
+    return {
+      check: "open_redirect",
+      target: redactSecrets(target),
+      verdict: redirected ? "confirmed" : "not_confirmed",
+      detail: redirected ? `browser redirected to ${finalUrl}` : `no redirect to attacker URL (final: ${finalUrl})`,
+      evidence: { final_url: finalUrl, console_errors: [], page_errors: [] }
+    };
+  } catch (e) {
+    return errorEvidence("open_redirect", target, e);
+  } finally {
+    await browser.close();
+  }
+}
+async function validateAuthBypass(target) {
+  const chr = await ensureChromium();
+  if (!chr)
+    return unavailable("auth_bypass", target, "playwright-core not installed (optional peer dependency)");
+  const browser = await chr.chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    const resp = await page.goto(target, { waitUntil: "domcontentloaded", timeout: 15000 });
+    const status = resp?.status() ?? 0;
+    const finalUrl = page.url();
+    const enforced = status === 401 || status === 403 || /login|signin|auth/.test(finalUrl);
+    return {
+      check: "auth_bypass",
+      target: redactSecrets(target),
+      verdict: enforced ? "not_confirmed" : "confirmed",
+      detail: enforced ? `auth enforced (status ${status}, final ${finalUrl})` : `no auth enforcement observed (status ${status}, final ${finalUrl})`,
+      evidence: { final_url: finalUrl, status, console_errors: [], page_errors: [] }
+    };
+  } catch (e) {
+    return errorEvidence("auth_bypass", target, e);
+  } finally {
+    await browser.close();
+  }
+}
+async function validateCsrf(target) {
+  const chr = await ensureChromium();
+  if (!chr)
+    return unavailable("csrf", target, "playwright-core not installed (optional peer dependency)");
+  const browser = await chr.chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    await page.goto(target, { waitUntil: "domcontentloaded", timeout: 15000 });
+    const result = await page.evaluate(() => {
+      const forms = Array.from(document.querySelectorAll("form"));
+      const stateChanging = forms.filter((f) => /post/i.test(f.method) || f.method === "");
+      if (stateChanging.length === 0)
+        return { token: true, count: 0 };
+      for (const f of stateChanging) {
+        const token = f.querySelector('input[name*="csrf"], input[name*="token"], input[name*="_token"], input[name*="nonce"]');
+        if (!token)
+          return { token: false, count: stateChanging.length };
+      }
+      return { token: true, count: stateChanging.length };
+    });
+    return {
+      check: "csrf",
+      target: redactSecrets(target),
+      verdict: result.token ? "not_confirmed" : "confirmed",
+      detail: result.token ? `CSRF token present (${result.count} form(s))` : `state-changing form missing CSRF token (${result.count} form(s))`,
+      evidence: { csrf_token_present: result.token, forms_count: result.count, console_errors: [], page_errors: [] }
+    };
+  } catch (e) {
+    return errorEvidence("csrf", target, e);
+  } finally {
+    await browser.close();
+  }
+}
+async function browserValidate(check, target, payload) {
+  switch (check) {
+    case "dom_xss":
+      return validateDomXss(target, payload);
+    case "open_redirect":
+      return validateOpenRedirect(target, payload ?? "https://attacker.example/");
+    case "auth_bypass":
+      return validateAuthBypass(target);
+    case "csrf":
+      return validateCsrf(target);
+  }
+}
+
 // src/guidance.ts
 var SINK_DIRECTIVES = {
   sql_execution: "Validate the SQL injection live with strike_verify (use a unique MARKER and a NEGATIVE CONTROL that stays inert), or read_tool_manual for sqlmap. Only a reflected marker + inert control = confirmed.",
@@ -52843,6 +53125,18 @@ function createServer() {
       out.scan = scanFramework(code, framework);
     return { content: [{ type: "text", text: JSON.stringify(out) }] };
   });
+  server.registerTool("browser_validate", {
+    title: "Browser validation (Playwright)",
+    description: "PHASE 6: validate a static-analysis HYPOTHESIS by driving a real headless Chromium. Checks: dom_xss, open_redirect, auth_bypass, csrf. Use only when necessary — to confirm a hypothesis with browser evidence, not as a first-pass scan. Requires playwright-core (optional peer dependency).",
+    inputSchema: {
+      check: _enum(["dom_xss", "open_redirect", "auth_bypass", "csrf"]).describe("Validation check to run"),
+      target: string2().describe("Target URL (use {{payload}} placeholder for dom_xss/open_redirect injection)"),
+      payload: string2().optional().describe("Payload to inject (defaults to an XSS marker for dom_xss)")
+    }
+  }, async ({ check, target, payload }) => {
+    const result = await browserValidate(check, target, payload);
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
   server.registerTool("taint_tree", {
     title: "Whole-tree taint scan",
     description: "EAGLE-EYE: run inter-procedural taint analysis across an entire source tree.",
@@ -52996,12 +53290,89 @@ async function serve() {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync18, existsSync as existsSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join13, dirname as dirname2 } from "node:path";
+import { readFileSync as readFileSync20, existsSync as existsSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join15, dirname as dirname2 } from "node:path";
 import { homedir as homedir5 } from "node:os";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
+import { fileURLToPath as fileURLToPath11 } from "node:url";
 import { spawnSync as spawnSync3 } from "node:child_process";
+
+// src/release.ts
+import { readFileSync as readFileSync18, existsSync as existsSync7 } from "node:fs";
+import { join as join13 } from "node:path";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
+import { execSync as execSync2 } from "node:child_process";
 var ROOT7 = join13(fileURLToPath9(new URL(".", import.meta.url)), "..");
+function validateRelease() {
+  const checks = [];
+  checks.push({ name: "package.json version", ok: true, detail: VERSION });
+  try {
+    const changelog = readFileSync18(join13(ROOT7, "CHANGELOG.md"), "utf8");
+    const m = changelog.match(/^##\s+\[([0-9]+\.[0-9]+\.[0-9]+)\]/m);
+    const changelogVersion = m?.[1] ?? null;
+    checks.push({
+      name: "CHANGELOG version",
+      ok: changelogVersion === VERSION,
+      detail: changelogVersion ?? "no version header found"
+    });
+  } catch {
+    checks.push({ name: "CHANGELOG version", ok: false, detail: "CHANGELOG.md not found" });
+  }
+  try {
+    const tag = execSync2("git describe --tags --abbrev=0", { cwd: ROOT7, encoding: "utf8" }).trim();
+    checks.push({ name: "Git tag", ok: tag === `v${VERSION}`, detail: tag, soft: true });
+  } catch {
+    checks.push({ name: "Git tag", ok: true, detail: "unavailable (no git)", soft: true });
+  }
+  try {
+    const published = execSync2("npm view blitzstrike version", { encoding: "utf8", timeout: 8000 }).trim();
+    checks.push({ name: "npm registry version", ok: published === VERSION, detail: published, soft: true });
+  } catch {
+    checks.push({ name: "npm registry version", ok: true, detail: "unavailable (offline)", soft: true });
+  }
+  checks.push({
+    name: "Lockfile",
+    ok: lockfilePresent(),
+    detail: lockfilePresent() ? "present (bun.lock / package-lock.json)" : "missing",
+    soft: true
+  });
+  return { version: VERSION, checks, consistent: checks.filter((c) => !c.soft).every((c) => c.ok) };
+}
+function lockfilePresent() {
+  return existsSync7(join13(ROOT7, "package-lock.json")) || existsSync7(join13(ROOT7, "bun.lock")) || existsSync7(join13(ROOT7, "bun.lockb"));
+}
+
+// src/dependency.ts
+import { readFileSync as readFileSync19 } from "node:fs";
+import { join as join14 } from "node:path";
+import { fileURLToPath as fileURLToPath10 } from "node:url";
+var ROOT8 = join14(fileURLToPath10(new URL(".", import.meta.url)), "..");
+function checkDependencies() {
+  let pkg = {};
+  try {
+    pkg = JSON.parse(readFileSync19(join14(ROOT8, "package.json"), "utf8"));
+  } catch {
+    return { install_scripts: [], git_dependencies: [], total_dependencies: 0, safe: false };
+  }
+  const installScriptNames = ["preinstall", "install", "postinstall", "prepare"];
+  const installScripts = installScriptNames.filter((n) => pkg.scripts?.[n]).map((n) => ({ name: n, command: pkg.scripts[n] }));
+  const allDeps = {
+    ...pkg.dependencies ?? {},
+    ...pkg.devDependencies ?? {},
+    ...pkg.peerDependencies ?? {},
+    ...pkg.optionalDependencies ?? {}
+  };
+  const gitDependencies = Object.entries(allDeps).filter(([, v]) => /^(git\+|git:|github:|gitlab:|bitbucket:|\w+:\/\/)/.test(v)).map(([name, v]) => `${name}@${v}`);
+  const total = Object.keys(allDeps).length;
+  return {
+    install_scripts: installScripts,
+    git_dependencies: gitDependencies,
+    total_dependencies: total,
+    safe: installScripts.length === 0 && gitDependencies.length === 0
+  };
+}
+
+// src/cli.ts
+var ROOT9 = join15(fileURLToPath11(new URL(".", import.meta.url)), "..");
 function which(cmd) {
   return spawnSync3(`command -v ${cmd}`, { shell: true }).status === 0;
 }
@@ -53036,13 +53407,27 @@ function runDoctor() {
     detail: fofa ? "set" : "FOFA_EMAIL/FOFA_KEY not set",
     fix: fofa ? undefined : "export FOFA_EMAIL=... && export FOFA_KEY=... (enables fofa_search)"
   });
-  const dataOk = existsSync7(join13(ROOT7, "chains.json")) && existsSync7(join13(ROOT7, "tools-catalog.json"));
+  const dataOk = existsSync8(join15(ROOT9, "chains.json")) && existsSync8(join15(ROOT9, "tools-catalog.json"));
   issues.push({
     name: "Data layers (chains + tools-catalog)",
     status: dataOk ? "ok" : "fail",
     detail: dataOk ? "present" : "chains.json or tools-catalog.json missing",
     fix: dataOk ? undefined : "re-install blitzstrike"
   });
+  const release = validateRelease();
+  issues.push({
+    name: "Release metadata",
+    status: release.consistent ? "ok" : "fail",
+    detail: release.consistent ? `v${release.version} consistent` : release.checks.filter((c) => !c.ok && !c.soft).map((c) => c.name).join(", ") || "drift",
+    fix: release.consistent ? undefined : "align package.json version with the latest CHANGELOG entry"
+  });
+  const deps = checkDependencies();
+  issues.push({
+    name: "Dependency surface",
+    status: deps.safe ? "ok" : "warn",
+    detail: deps.safe ? `${deps.total_dependencies} deps, no install scripts` : `${deps.install_scripts.length} install script(s) + ${deps.git_dependencies.length} git dep(s)`,
+    fix: deps.safe ? undefined : "remove install-time scripts and git dependencies"
+  });
   const symbol = { ok: "OK  ", warn: "WARN", fail: "FAIL" };
   for (const i of issues) {
     console.log(`${symbol[i.status]}  ${i.name}  ${i.detail}`);
@@ -53064,21 +53449,21 @@ BlitzStrike — ${verdict}`);
 function resolveCommand() {
   if (which("blitzstrike"))
     return { command: "blitzstrike", args: ["serve", "--mcp"] };
-  const src = join13(ROOT7, "src", "index.ts");
-  if (which("bun") && existsSync7(src))
+  const src = join15(ROOT9, "src", "index.ts");
+  if (which("bun") && existsSync8(src))
     return { command: "bun", args: ["run", src, "serve", "--mcp"] };
   if (which("npx"))
     return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
   if (which("bunx"))
     return { command: "bunx", args: ["blitzstrike", "serve", "--mcp"] };
-  const dist = join13(ROOT7, "dist", "index.js");
-  if (existsSync7(dist))
+  const dist = join15(ROOT9, "dist", "index.js");
+  if (existsSync8(dist))
     return { command: "bun", args: [dist, "serve", "--mcp"] };
   return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
 }
 function readJson(p) {
   try {
-    return JSON.parse(readFileSync18(p, "utf8"));
+    return JSON.parse(readFileSync20(p, "utf8"));
   } catch {
     return null;
   }
@@ -53086,7 +53471,7 @@ function readJson(p) {
 function jsonMcpServersWrite(p) {
   return (command, args) => {
     const dir = dirname2(p);
-    if (!existsSync7(dir))
+    if (!existsSync8(dir))
       mkdirSync4(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcpServers = {
@@ -53099,7 +53484,7 @@ function jsonMcpServersWrite(p) {
 function opencodeWrite(p) {
   return (_command, _args) => {
     const dir = dirname2(p);
-    if (!existsSync7(dir))
+    if (!existsSync8(dir))
       mkdirSync4(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcp = {
@@ -53111,26 +53496,26 @@ function opencodeWrite(p) {
   };
 }
 function copyOpenCodeAgents() {
-  const srcDir = join13(ROOT7, "opencode-agents");
-  const dstDir = join13(homedir5(), ".config", "opencode", "agents");
-  if (!existsSync7(srcDir))
+  const srcDir = join15(ROOT9, "opencode-agents");
+  const dstDir = join15(homedir5(), ".config", "opencode", "agents");
+  if (!existsSync8(srcDir))
     return;
-  if (!existsSync7(dstDir))
+  if (!existsSync8(dstDir))
     mkdirSync4(dstDir, { recursive: true });
   for (const f of ["Blitz Strike.md", "Blitz.md", "Eagle Eye.md", "Strike.md"]) {
-    const src = join13(srcDir, f);
-    const dst = join13(dstDir, f);
-    if (existsSync7(src)) {
-      writeFileSync5(dst, readFileSync18(src, "utf8"));
+    const src = join15(srcDir, f);
+    const dst = join15(dstDir, f);
+    if (existsSync8(src)) {
+      writeFileSync5(dst, readFileSync20(src, "utf8"));
     }
   }
 }
 function codexWrite(p) {
   return (command, args) => {
     const dir = dirname2(p);
-    if (!existsSync7(dir))
+    if (!existsSync8(dir))
       mkdirSync4(dir, { recursive: true });
-    let existing = existsSync7(p) ? readFileSync18(p, "utf8") : "";
+    let existing = existsSync8(p) ? readFileSync20(p, "utf8") : "";
     if (!existing.trimEnd().endsWith(`
 `))
       existing += `
@@ -53147,9 +53532,9 @@ args = ${JSON.stringify(args)}
 function hermesWrite(p) {
   return (command, args) => {
     const dir = dirname2(p);
-    if (!existsSync7(dir))
+    if (!existsSync8(dir))
       mkdirSync4(dir, { recursive: true });
-    let existing = existsSync7(p) ? readFileSync18(p, "utf8") : "";
+    let existing = existsSync8(p) ? readFileSync20(p, "utf8") : "";
     existing = existing.replace(/^  blitzstrike:\n(?:    .*\n?)*/m, "");
     if (!existing.trimEnd().endsWith(`
 `))
@@ -53176,74 +53561,74 @@ mcp_servers:
 function detectAgents() {
   const home = homedir5();
   const agents = [];
-  const claudeJson = join13(home, ".claude.json");
+  const claudeJson = join15(home, ".claude.json");
   agents.push({
     name: "Claude Code",
     detectPath: claudeJson,
-    installed: () => existsSync7(claudeJson) || which("claude"),
+    installed: () => existsSync8(claudeJson) || which("claude"),
     write: jsonMcpServersWrite(claudeJson)
   });
-  const claudeDesktop = join13(home, ".config", "Claude", "claude_desktop_config.json");
+  const claudeDesktop = join15(home, ".config", "Claude", "claude_desktop_config.json");
   agents.push({
     name: "Claude Desktop",
     detectPath: claudeDesktop,
-    installed: () => existsSync7(claudeDesktop),
+    installed: () => existsSync8(claudeDesktop),
     write: jsonMcpServersWrite(claudeDesktop)
   });
-  const cursor = join13(home, ".cursor", "mcp.json");
+  const cursor = join15(home, ".cursor", "mcp.json");
   agents.push({
     name: "Cursor",
     detectPath: cursor,
-    installed: () => existsSync7(join13(home, ".cursor")) || which("cursor"),
+    installed: () => existsSync8(join15(home, ".cursor")) || which("cursor"),
     write: jsonMcpServersWrite(cursor)
   });
-  const opencode = join13(home, ".config", "opencode", "opencode.jsonc");
+  const opencode = join15(home, ".config", "opencode", "opencode.jsonc");
   agents.push({
     name: "OpenCode",
     detectPath: opencode,
-    installed: () => existsSync7(join13(home, ".config", "opencode")) || which("opencode"),
+    installed: () => existsSync8(join15(home, ".config", "opencode")) || which("opencode"),
     write: opencodeWrite(opencode)
   });
-  const codex = join13(home, ".codex", "config.toml");
+  const codex = join15(home, ".codex", "config.toml");
   agents.push({
     name: "Codex",
     detectPath: codex,
-    installed: () => existsSync7(join13(home, ".codex")) || which("codex"),
+    installed: () => existsSync8(join15(home, ".codex")) || which("codex"),
     write: codexWrite(codex)
   });
-  const hermes = join13(home, ".hermes", "config.yaml");
+  const hermes = join15(home, ".hermes", "config.yaml");
   agents.push({
     name: "Hermes",
     detectPath: hermes,
-    installed: () => existsSync7(join13(home, ".hermes")) || which("hermes"),
+    installed: () => existsSync8(join15(home, ".hermes")) || which("hermes"),
     write: hermesWrite(hermes)
   });
-  const gemini = join13(home, ".gemini", "settings.json");
+  const gemini = join15(home, ".gemini", "settings.json");
   agents.push({
     name: "Gemini CLI",
     detectPath: gemini,
-    installed: () => existsSync7(join13(home, ".gemini")) || which("gemini"),
+    installed: () => existsSync8(join15(home, ".gemini")) || which("gemini"),
     write: jsonMcpServersWrite(gemini)
   });
-  const windsurf = join13(home, ".codeium", "windsurf", "mcp_config.json");
+  const windsurf = join15(home, ".codeium", "windsurf", "mcp_config.json");
   agents.push({
     name: "Windsurf",
     detectPath: windsurf,
-    installed: () => existsSync7(join13(home, ".codeium")) || which("windsurf"),
+    installed: () => existsSync8(join15(home, ".codeium")) || which("windsurf"),
     write: jsonMcpServersWrite(windsurf)
   });
-  const copilot = join13(home, ".copilot", "mcp.json");
+  const copilot = join15(home, ".copilot", "mcp.json");
   agents.push({
     name: "Copilot",
     detectPath: copilot,
-    installed: () => existsSync7(join13(home, ".copilot")),
+    installed: () => existsSync8(join15(home, ".copilot")),
     write: jsonMcpServersWrite(copilot)
   });
-  const cline = join13(home, ".cline", "mcp_settings.json");
+  const cline = join15(home, ".cline", "mcp_settings.json");
   agents.push({
     name: "Cline",
     detectPath: cline,
-    installed: () => existsSync7(join13(home, ".cline")),
+    installed: () => existsSync8(join15(home, ".cline")),
     write: jsonMcpServersWrite(cline)
   });
   return agents;
@@ -53287,15 +53672,15 @@ Registered with ${ok}/${installed.length} agent(s).`);
 }
 
 // src/index.ts
-import { readFileSync as readFileSync19, existsSync as existsSync8 } from "node:fs";
-import { join as join14 } from "node:path";
-import { fileURLToPath as fileURLToPath10 } from "node:url";
-var ROOT8 = join14(fileURLToPath10(new URL(".", import.meta.url)), "..");
+import { readFileSync as readFileSync21, existsSync as existsSync9 } from "node:fs";
+import { join as join16 } from "node:path";
+import { fileURLToPath as fileURLToPath12 } from "node:url";
+var ROOT10 = join16(fileURLToPath12(new URL(".", import.meta.url)), "..");
 function readVersion() {
   try {
-    const p = join14(ROOT8, "package.json");
-    if (existsSync8(p))
-      return JSON.parse(readFileSync19(p, "utf8")).version ?? "1.0.0";
+    const p = join16(ROOT10, "package.json");
+    if (existsSync9(p))
+      return JSON.parse(readFileSync21(p, "utf8")).version ?? "1.0.0";
   } catch {}
   return "1.0.0";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzstrike",
-  "version": "1.0.40",
+  "version": "1.0.43",
   "description": "Blitz Strike — a universal MCP security-audit toolbelt. BLITZ sweeps the attack surface, EAGLE-EYE traces source-to-sink, STRIKE verifies live. 57 attack chains, 130-tool catalog, intelligence data layer. One server, every agent.",
   "type": "module",
   "bin": {
@@ -25,12 +25,13 @@
     "tools-catalog.json"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node --format esm",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --external playwright-core",
     "typecheck": "tsc --noEmit",
     "serve": "bun run src/index.ts serve",
     "doctor": "bun run src/index.ts doctor",
     "compile": "bun build src/index.ts --compile --outfile dist/blitzstrike",
     "test": "bun run test/verify.ts",
+    "test:browser": "bun run test/browser-verify.ts",
     "prepublishOnly": "bun run typecheck && bun run build",
     "bench": "bun run test/verify.ts"
   },
@@ -74,6 +75,15 @@
   },
   "devDependencies": {
     "@types/node": "^22.20.2",
+    "playwright-core": "1.61.0",
     "typescript": "^5.5.0"
+  },
+  "peerDependencies": {
+    "playwright-core": ">=1.61.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright-core": {
+      "optional": true
+    }
   }
 }