aztrx-cli 0.1.0 → 0.2.0

package/dist/core/heal/childEnv.js

@@ -0,0 +1,60 @@
+/**
+ * Child-process environment isolation. The heal sandbox runs the project's own
+ * test suite, `tsc`, and dev server — which means it executes untrusted PR code.
+ * Handing that code the full `process.env` would leak the caller's secrets
+ * (ANTHROPIC_API_KEY, GH_TOKEN, NPM_TOKEN, AWS_*, …) into a process the PR author
+ * controls. Children therefore get only a minimal allow-list of harmless,
+ * platform-essential variables.
+ *
+ * Escape hatch: a caller whose dev server legitimately needs app config (e.g.
+ * `DATABASE_URL`) can pass it through by naming it in `AZTRX_ENV_ALLOW`
+ * (comma-separated) — without re-opening the leak for every secret in the env.
+ */
+const ALLOWED = new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "USERNAME",
+    "LOGNAME",
+    "SHELL",
+    "TMP",
+    "TEMP",
+    "TMPDIR",
+    "SystemRoot",
+    "SystemDrive",
+    "windir",
+    "COMSPEC",
+    "PATHEXT",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "TERM",
+    "NODE_ENV",
+    "CI",
+    "PORT",
+]);
+/** Build a minimal child environment: harmless platform vars, anything named in
+ * `AZTRX_ENV_ALLOW`, and any caller-supplied `extra` (e.g. `{ PORT: "4317" }`). */
+export function buildChildEnv(extra) {
+    const env = {};
+    for (const key of ALLOWED) {
+        const v = process.env[key];
+        if (v !== undefined)
+            env[key] = v;
+    }
+    const allow = process.env.AZTRX_ENV_ALLOW;
+    if (allow) {
+        for (const raw of allow.split(",")) {
+            const name = raw.trim();
+            if (!name)
+                continue;
+            const v = process.env[name];
+            if (v !== undefined)
+                env[name] = v;
+        }
+    }
+    if (extra)
+        for (const [k, v] of Object.entries(extra))
+            env[k] = v;
+    return env;
+}

package/dist/core/heal/index.js

@@ -7,8 +7,9 @@
  *   3. gate     — re-parse the patched file; reject new imports / eval /
  *                 child_process / empty catch
  *   4. sandbox  — apply the patch in a detached git worktree, never the tree
- *   5. verify   — replay the repro against the patched app; the bug must be gone
- *   6. hand off — write a unified-diff `.patch` for a human to review and commit
+ *   5. test     — run the repo's own test suite; reject the patch if it goes red
+ *   6. verify   — replay the repro against the patched app; the bug must be gone
+ *   7. hand off — write a unified-diff `.patch` for a human to review and commit
  *
  * Aztrx never commits. A patch that fails any gate, does not apply exactly, or
  * still reproduces the bug is rejected and reported, not silently kept.
@@ -19,7 +20,8 @@ import * as path from "path";
 import { redact, unredact } from "./redact.js";
 import { auditPatch } from "./gates.js";
 import { generatePatch, modelTiers } from "./llm.js";
-import { applyHunks, createWorktree, diffWorktree, typecheckWorktree, writeWorktreeFile } from "./sandbox.js";
+import { applyHunks, createWorktree, diffWorktree, runTests, typecheckWorktree, writeWorktreeFile } from "./sandbox.js";
+import { bootServer, detectStartCommand } from "./boot.js";
 import { verifyFix } from "./verify.js";
 const MIME = {
     ".html": "text/html; charset=utf-8",
@@ -94,6 +96,17 @@ export async function heal(finding, opts) {
     if (!finding.repro || finding.repro.verdict === "unreliable") {
         return { ...base, error: "no deterministic repro to verify against" };
     }
+    // Server findings (network_5xx) verify by *booting* the patched app, not static
+    // serving. That needs a start command — resolve it before paying the LLM so a
+    // missing one skips cleanly rather than after an expensive generation.
+    const isNetwork = finding.type === "network_5xx";
+    const startCommand = opts.startCommand ?? detectStartCommand(opts.repoRoot);
+    if (isNetwork && !startCommand) {
+        return {
+            ...base,
+            error: "no start command for server heal (set --start-command, or add scripts.dev / scripts.start)",
+        };
+    }
     const filePath = loc.filePath;
     const absPath = path.resolve(opts.repoRoot, filePath);
     let original;
@@ -124,6 +137,7 @@ export async function heal(finding, opts) {
     // The winning (or last) patch + verification, held back for the final save.
     let savedPatch = null;
     let savedVerification = null;
+    let savedTest = null;
     let savedGateOk = false;
     let last = base;
     try {
@@ -206,14 +220,41 @@ export async function heal(finding, opts) {
                 };
                 continue;
             }
-            // 4. Verify — the bug must stop reproducing.
-            const serve = opts.serve ?? ((dir, fp) => staticServe(dir, fp));
+            // 3c. Test gate — run the repo's own test suite against the patched
+            // worktree. A patch that breaks tests is rejected before we pay for the
+            // Playwright verification, so "autonomous fixing" never regresses checks.
+            const test = opts.skipTest
+                ? { ran: false, ok: true, command: "", output: "" }
+                : await runTests(wt.dir, opts.repoRoot, {
+                    command: opts.testCommand,
+                    timeoutMs: opts.testTimeoutMs,
+                });
+            if (test.ran)
+                savedTest = test;
+            if (test.ran && !test.ok) {
+                last = {
+                    ...base,
+                    status: "test-failed",
+                    hunks,
+                    explanation: patch.explanation,
+                    error: test.output.slice(0, 400) || `${test.command} failed`,
+                    model: tier.model,
+                };
+                continue;
+            }
+            // 4. Verify — the bug must stop reproducing. Server findings boot the
+            // patched app in the worktree (static serving can't run a server); client
+            // findings keep the static server.
+            const serve = isNetwork
+                ? (dir) => bootServer({ worktreeDir: dir, repoRoot: opts.repoRoot, startCommand: startCommand })
+                : opts.serve ?? ((dir, fp) => staticServe(dir, fp));
             const v = await verifyFix({
                 url: opts.url,
                 actions: opts.actions,
                 fingerprint: opts.fingerprint,
                 runs: opts.verifyRuns ?? 3,
                 serve: () => serve(wt.dir, filePath),
+                targetType: isNetwork ? finding.type : undefined,
             });
             savedPatch = patch;
             savedVerification = v;
@@ -234,7 +275,7 @@ export async function heal(finding, opts) {
         if (savedPatch && savedVerification) {
             last.patchPath = await saveArtifact(opts.repoRoot, finding, savedPatch, savedGateOk, savedVerification, wt.dir, filePath);
         }
-        return { ...last, tiers: tiers.map((t) => t.model) };
+        return { ...last, test: savedTest ?? undefined, tiers: tiers.map((t) => t.model) };
     }
     finally {
         await wt.cleanup();

package/dist/core/heal/redact.js

@@ -16,13 +16,29 @@ const WHOLE_MATCH = [
     { re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, label: "slack_token" },
     { re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, label: "jwt" },
     { re: /\bBearer [A-Za-z0-9._-]{20,}/g, label: "bearer_token" },
+    { re: /\bBasic [A-Za-z0-9+/=]{10,}\b/g, label: "basic_auth" },
+    { re: /\bAIza[0-9A-Za-z_-]{30,}\b/g, label: "google_api_key" },
+    { re: /\b(?:sk|rk|pk)_(?:live|test)_[0-9A-Za-z]{16,}\b/g, label: "stripe_key" },
 ];
 // Prefix-preserving: group 1 stays in place (so the code structure — the key
 // name, the scheme+user of a URL — remains visible to the model), group 2 is
 // the secret value that is replaced.
 const VALUE_MATCH = [
     {
-        re: /(["']?(?:password|passwd|pwd|secret|token|api[_-]?key|access[_-]?token|client[_-]?secret|private[_-]?key|auth[_-]?token)["']?\s*[:=]\s*)(["']?[^"'\s;,&}{=]{8,}["']?)/gi,
+        // `key = value` where the key is (or embeds) a secret-shaped word. Boundary
+        // is "not a letter/digit" — so `_`/`-`/`.` join compound names like
+        // `aws_secret_access_key` / `FOO_ACCESS_KEY`, while a plain `secret = x`
+        // still matches. (JS `\b` treats `_` as a word char, which would miss the
+        // compound forms — hence the explicit lookarounds.)
+        re: /(["']?[A-Za-z0-9._-]*(?<![A-Za-z0-9])(?:password|passwd|pwd|secret|token|api[_-]?key|access[_-]?key|access[_-]?token|client[_-]?secret|private[_-]?key|auth[_-]?token|credential|authorization)(?![A-Za-z0-9])[A-Za-z0-9._-]*["']?\s*[:=]\s*)(["']?(?!__AZTRX_REDACTED_)[^"'\s;,&}{=]{8,}["']?)/gi,
+        label: "secret_value",
+    },
+    {
+        // CamelCase / bare form (`apiKey`, `accessToken`, `secretKey`) — the
+        // lookaround form above misses these because the keyword is glued to a
+        // letter. No boundary here, so a keyword directly before `:`/`=` matches
+        // even mid-identifier.
+        re: /(["']?(?:password|passwd|pwd|secret|token|api[_-]?key|access[_-]?token|client[_-]?secret|private[_-]?key|auth[_-]?token|credential|authorization)["']?\s*[:=]\s*)(["']?(?!__AZTRX_REDACTED_)[^"'\s;,&}{=]{8,}["']?)/gi,
         label: "secret_value",
     },
     {
@@ -61,3 +77,17 @@ export function unredact(input, map) {
         out = out.split(ph).join(secret);
     return out;
 }
+const EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+/**
+ * Irreversible secret scrub for anything rendered to a human or written to a
+ * report / PR comment. Runs the same patterns as `redact()` but discards the
+ * map — every secret collapses to a fixed `[REDACTED]` token — then scrubs
+ * emails, which `redact()` deliberately leaves alone (they aren't secrets and
+ * the reversible layer must not mangle non-secret code it may need to patch).
+ */
+export function sanitizeSecrets(input) {
+    const { text } = redact(input);
+    return text
+        .replace(/__AZTRX_REDACTED_\d+__/g, "[REDACTED]")
+        .replace(EMAIL_RE, "[REDACTED]");
+}

package/dist/core/heal/sandbox.js

@@ -9,6 +9,7 @@ import { promisify } from "util";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+import { buildChildEnv } from "./childEnv.js";
 const execFileP = promisify(execFile);
 const preview = (s) => JSON.stringify(s.length > 60 ? s.slice(0, 57) + "…" : s);
 /** Create a detached worktree at HEAD in a temp dir (outside the repo). */
@@ -89,7 +90,7 @@ export async function typecheckWorktree(worktreeDir, repoRoot) {
         }
     }
     try {
-        const { stdout } = await execFileP(process.execPath, [tscBin, "--noEmit", "-p", worktreeDir], { cwd: worktreeDir, maxBuffer: 10 * 1024 * 1024 });
+        const { stdout } = await execFileP(process.execPath, [tscBin, "--noEmit", "-p", worktreeDir], { cwd: worktreeDir, maxBuffer: 10 * 1024 * 1024, env: buildChildEnv() });
         return { ok: true, ran: true, output: stdout.trim() };
     }
     catch (e) {
@@ -97,3 +98,54 @@ export async function typecheckWorktree(worktreeDir, repoRoot) {
         return { ok: false, ran: true, output: ((err.stdout ?? "") + (err.stderr ?? "")).trim() };
     }
 }
+/** Run the repo's own test suite inside the patched worktree. Best-effort: skips
+ * (passes by omission) when there is no `test` script to run, so untested or
+ * non-JS projects are never blocked. `CI=true` is set so watch-mode runners exit
+ * instead of hanging until the timeout. */
+export async function runTests(worktreeDir, repoRoot, opts = {}) {
+    const command = opts.command ?? "npm test";
+    // Auto-detect: without an explicit command, only run when package.json declares
+    // a `test` script — `npm test` otherwise errors "Missing script".
+    if (!opts.command) {
+        let hasTest = false;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(worktreeDir, "package.json"), "utf-8"));
+            hasTest = typeof pkg.scripts?.test === "string";
+        }
+        catch {
+            hasTest = false;
+        }
+        if (!hasTest)
+            return { ran: false, ok: true, command: "", output: "" };
+    }
+    // A fresh worktree has no node_modules — symlink the root's so the runner
+    // resolves (the same trick typecheckWorktree uses).
+    const rootNodeModules = path.join(repoRoot, "node_modules");
+    const wtNodeModules = path.join(worktreeDir, "node_modules");
+    if (!fs.existsSync(wtNodeModules) && fs.existsSync(rootNodeModules)) {
+        try {
+            fs.symlinkSync(rootNodeModules, wtNodeModules, process.platform === "win32" ? "junction" : "dir");
+        }
+        catch {
+            /* resolution errors surface in the run below */
+        }
+    }
+    const timeoutMs = opts.timeoutMs ?? 300000;
+    try {
+        const { stdout } = await execFileP(command, [], {
+            cwd: worktreeDir,
+            shell: true,
+            timeout: timeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
+            // Minimal allow-list — never hand the full `process.env` (and its
+            // ANTHROPIC_API_KEY / GH_TOKEN / AWS_* secrets) to untrusted PR test code.
+            env: buildChildEnv({ CI: "true" }),
+        });
+        return { ran: true, ok: true, command, output: stdout.trim().slice(0, 2000) };
+    }
+    catch (e) {
+        const err = e;
+        const output = `${err.stdout ?? ""}\n${err.stderr ?? ""}`.trim().slice(0, 2000);
+        return { ran: true, ok: false, command, output };
+    }
+}

package/dist/core/heal/verify.js

@@ -5,14 +5,43 @@
  * than handing the human a lie.
  */
 import { ReplayEngine } from "../replay.js";
+/** Rewrite an absolute URL's origin to `serveUrl`'s origin, keeping path + query.
+ * The booted server runs on a fresh port (and possibly host), so a replayed
+ * request addressed to the original origin would hit the *unpatched* app. */
+function rewriteOrigin(raw, serveUrl) {
+    try {
+        const u = new URL(raw);
+        const s = new URL(serveUrl);
+        u.protocol = s.protocol;
+        u.hostname = s.hostname;
+        u.port = s.port;
+        return u.toString();
+    }
+    catch {
+        return raw;
+    }
+}
 export async function verifyFix(opts) {
     const { url: serveUrl, close } = await opts.serve();
     const engine = new ReplayEngine();
     try {
         const runs = opts.runs ?? 3;
         let reproductions = 0;
+        const actions = opts.targetType
+            ? opts.actions.map((a) => {
+                if (a.type === "request" && a.request) {
+                    return { ...a, request: { ...a.request, url: rewriteOrigin(a.request.url, serveUrl) } };
+                }
+                if (a.type === "navigate" && a.value) {
+                    return { ...a, value: rewriteOrigin(a.value, serveUrl) };
+                }
+                return a;
+            })
+            : opts.actions;
         for (let i = 0; i < runs; i++) {
-            const res = await engine.run(serveUrl, opts.actions, opts.fingerprint);
+            const res = opts.targetType
+                ? await engine.run(serveUrl, actions, opts.fingerprint, { targetType: opts.targetType })
+                : await engine.run(serveUrl, actions, opts.fingerprint);
             if (res.reproduced)
                 reproductions += 1;
         }

package/dist/core/httpFuzzer.js

@@ -0,0 +1,258 @@
+import { network5xxMessage } from "./interceptor.js";
+import { extractServerFrame } from "./resolver.js";
+// Static assets carry no server-side logic worth mutating — skip them so we
+// spend the request budget on data/API routes.
+const STATIC_EXT = /\.(js|mjs|cjs|css|map|png|jpe?g|gif|svg|ico|webp|woff2?|ttf|otf|eot|mp4|webm)(\?|#|$)/i;
+// Mirror the DOM deny-list (domWalker.ts) at the path level: never throw
+// hostile requests at endpoints that mutate real state — delete, pay, logout, etc.
+const DESTRUCTIVE_PATH = /(delete|remove|logout|sign\s?out|log\s?out|pay|checkout|purchase|buy|unsubscribe|purge|drop|truncate|confirm|update|orders|users|settings|admin|invite|grant)/i;
+const HOSTILE_QUERY = [
+    ["id", "-1"],
+    ["id", "0"],
+    ["id", "99999999999999999999"],
+    ["q", "%00"],
+    ["q", "<script>alert(1)</script>"],
+    ["q", "'; DROP TABLE users;--"],
+    ["limit", "-1"],
+    ["page", "0"],
+    ["ids", "[1,2,3]"],
+];
+// JSON bodies that trip naive server handlers: type confusion, malformed
+// payloads, prototype-pollution probes, and overflow numerics.
+const JSON_BODIES = [
+    "{}",
+    "[]",
+    "null",
+    "0",
+    "99999999999999999999",
+    '{"id":[]}',
+    '{"__proto__":{"polluted":true}}',
+    '{"a":',
+];
+// Hostile but valid (undici-sendable) headers: oversized values and
+// content-type confusion are the two most likely to trip a server handler.
+const HOSTILE_HEADERS = [
+    ["x-forwarded-for", "x".repeat(8192)],
+    ["content-type", "application/json"],
+    ["content-type", "text/html"],
+    ["accept", "application/x-www-form-urlencoded"],
+    ["cookie", "a".repeat(4096)],
+];
+/** Read a response body as text, bounded so a huge (or gzip-bomb) 500 page can't
+ * balloon a finding. */
+async function readBodyText(res) {
+    // Bounded so a huge (or gzip-bomb) 500 page can't balloon a finding. The first
+    // few KB is all a server stack trace / error JSON ever needs — the rest is
+    // noise that only widens the secret-leak surface if it lands in a report.
+    const MAX = 8 * 1024;
+    try {
+        const text = await res.text();
+        return text.length > MAX ? text.slice(0, MAX) + "\n…(truncated)" : text;
+    }
+    catch {
+        return "";
+    }
+}
+/** Best-effort server error message from a 500 body: a JSON `error`/`message`
+ * field, else the first non-empty line (HTML tags stripped). */
+function extractServerMessage(body) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        return "(empty body)";
+    try {
+        const j = JSON.parse(trimmed);
+        const msg = j?.error?.message ?? j?.message ?? j?.error ?? j?.detail;
+        if (typeof msg === "string" && msg.trim())
+            return msg.trim().slice(0, 200);
+    }
+    catch {
+        // not JSON — fall through to plain-text extraction
+    }
+    const first = trimmed.split("\n").find((l) => l.trim()) ?? trimmed;
+    const text = first.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+    return text.slice(0, 200) || "(empty body)";
+}
+/** Is this host allowed under the deny-by-default policy (loopback always is)? */
+function hostAllowed(url, allowHosts) {
+    let host;
+    try {
+        host = new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    if (host === "localhost" || host === "127.0.0.1" || host === "::1")
+        return true;
+    for (const h of allowHosts) {
+        if (host === h || host.endsWith("." + h))
+            return true;
+    }
+    return false;
+}
+/** Harvest candidate endpoints the app actually uses — not blind probing. */
+async function collectEndpoints(page, origin) {
+    const seen = new Map();
+    const push = (raw) => {
+        let u;
+        try {
+            u = new URL(raw, origin);
+        }
+        catch {
+            return;
+        }
+        if (u.origin !== origin)
+            return;
+        if (STATIC_EXT.test(u.pathname))
+            return;
+        if (DESTRUCTIVE_PATH.test(u.pathname))
+            return;
+        if (!seen.has(u.pathname))
+            seen.set(u.pathname, u);
+    };
+    // URLs the page already fetched (API calls, RSC/data endpoints).
+    const resources = await page
+        .evaluate(() => performance.getEntriesByType("resource").map((e) => e.name))
+        .catch(() => []);
+    for (const r of resources)
+        push(r);
+    // Links and form actions in the DOM.
+    const domUrls = await page
+        .evaluate(() => {
+        const out = [];
+        document.querySelectorAll("a[href], form[action]").forEach((el) => {
+            const v = el.getAttribute("href") ?? el.getAttribute("action");
+            if (v)
+                out.push(v);
+        });
+        return out;
+    })
+        .catch(() => []);
+    for (const u of domUrls)
+        push(u);
+    push(origin + "/");
+    return [...seen.values()];
+}
+/** Expand one endpoint into a bounded set of hostile requests. Deterministic. */
+function buildRequests(endpoint, opts = {}) {
+    const reqs = [];
+    const base = endpoint.toString();
+    // Query mutations — rewrite existing params, or append hostile ones.
+    if (endpoint.search) {
+        const keys = [...endpoint.searchParams.keys()].slice(0, 2);
+        for (const key of keys) {
+            for (const val of ["-1", "0", "99999999999999999999", "%00"]) {
+                const u = new URL(base);
+                u.searchParams.set(key, val);
+                reqs.push({ method: "GET", url: u.toString() });
+            }
+        }
+    }
+    else {
+        for (const [key, val] of HOSTILE_QUERY) {
+            const u = new URL(base);
+            u.searchParams.set(key, val);
+            reqs.push({ method: "GET", url: u.toString() });
+        }
+    }
+    // Body mutations via method confusion (POST/PUT, never DELETE). Opt-in: these
+    // mutate server state, so they're off by default (GET-only).
+    if (opts.mutations) {
+        for (const body of JSON_BODIES) {
+            reqs.push({
+                method: "POST",
+                url: base,
+                headers: { "content-type": "application/json" },
+                body,
+            });
+        }
+        reqs.push({
+            method: "PUT",
+            url: base,
+            headers: { "content-type": "application/json" },
+            body: "{}",
+        });
+    }
+    // Header injection on a plain GET.
+    for (const [name, value] of HOSTILE_HEADERS) {
+        reqs.push({ method: "GET", url: base, headers: { [name]: value } });
+    }
+    return reqs;
+}
+/**
+ * F5-http — server-side mutation fuzzer. Harvests the endpoints the app really
+ * uses, then throws seeded hostile requests at them (query overflow, JSON type
+ * confusion, header injection, method confusion). A response `status >= 500`
+ * becomes a `network_5xx` finding — same type and message format the interceptor
+ * emits for in-browser requests — so it flows through the existing
+ * ddmin → spec → validate → heal pipeline unchanged.
+ */
+export async function httpFuzz(page, targetUrl, bus, opts = {}) {
+    const max = opts.maxRequests ?? 100;
+    const allowHosts = opts.allowHosts ?? new Set();
+    if (!hostAllowed(targetUrl, allowHosts))
+        return 0;
+    if (!opts.dryRun) {
+        await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => { });
+        await page.waitForTimeout(500);
+    }
+    const endpoints = await collectEndpoints(page, new URL(targetUrl).origin);
+    endpoints.sort((a, b) => a.pathname.localeCompare(b.pathname));
+    let sent = 0;
+    outer: for (const endpoint of endpoints) {
+        for (const req of buildRequests(endpoint, { mutations: opts.mutations })) {
+            if (sent >= max)
+                break outer;
+            const { pathname, search } = new URL(req.url);
+            const label = `${req.method} ${pathname}${search}`;
+            bus.emit("action", {
+                type: "request",
+                selectors: [],
+                value: label,
+                request: req,
+                timestamp: Date.now(),
+            });
+            if (opts.dryRun) {
+                sent++;
+                continue;
+            }
+            let status = 0;
+            let bodyText = "";
+            const ctrl = new AbortController();
+            const timer = setTimeout(() => ctrl.abort(), 8000);
+            try {
+                const res = await fetch(req.url, {
+                    method: req.method,
+                    headers: req.headers,
+                    body: req.body,
+                    signal: ctrl.signal,
+                });
+                status = res.status;
+                if (status >= 500)
+                    bodyText = await readBodyText(res);
+                else
+                    await res.arrayBuffer().catch(() => { });
+            }
+            catch {
+                // network error or timeout — hang detection is a follow-up slice
+                status = 0;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (status >= 500) {
+                bus.emit("telemetry", {
+                    type: "network_5xx",
+                    rawMessage: network5xxMessage(status, req.url),
+                    rawStack: "",
+                    serverError: {
+                        message: extractServerMessage(bodyText),
+                        body: bodyText,
+                        frame: extractServerFrame(bodyText) ?? undefined,
+                    },
+                });
+            }
+            sent++;
+        }
+    }
+    return sent;
+}

package/dist/core/init.js

@@ -37,7 +37,7 @@ function defaultPort(framework) {
     return 3000;
 }
 function configTemplate(framework, url) {
-    return `// aztrx.config.ts — generated by \`aztrx init\` (framework: ${framework})
+    return `// aztrx.config.ts — generated by \`aztrx-cli init\` (framework: ${framework})
 // Docs: https://aztrx.app/docs/config
 
 export default {
@@ -55,7 +55,7 @@ export default {
 };
 `;
 }
-/** `aztrx init` — detect framework + port, scaffold aztrx.config.ts, seed .gitignore. */
+/** `aztrx-cli init` — detect framework + port, scaffold aztrx.config.ts, seed .gitignore. */
 export async function initProject(opts) {
     const repoRoot = path.resolve(opts.repoRoot);
     const framework = opts.framework ?? detectFramework(repoRoot);

package/dist/core/interceptor.js

@@ -1,4 +1,13 @@
 import { extractFrame } from "./resolver.js";
+/**
+ * Canonical 5xx finding message. Shared by the interceptor (passive in-browser
+ * capture) and the HTTP mutation fuzzer (active Node-side capture) so the two
+ * produce byte-identical `rawMessage`s — otherwise a finding's fingerprint and
+ * its replay fingerprint would diverge and repro would never match.
+ */
+export function network5xxMessage(status, url) {
+    return `HTTP ${status} ${url}`;
+}
 // Route unhandled rejections through console.error so a single capture path
 // handles them alongside React Error Boundary logs (both land in console.error).
 const INIT_SCRIPT = `
@@ -84,7 +93,7 @@ export function attachInterceptor(page, bus) {
         if (res.status() >= 500) {
             bus.emit("telemetry", {
                 type: "network_5xx",
-                rawMessage: `HTTP ${res.status()} ${res.url()}`,
+                rawMessage: network5xxMessage(res.status(), res.url()),
                 rawStack: "",
             });
         }