aztrx-cli 0.4.2 → 0.4.4

package/dist/core/heal/index.js

@@ -19,7 +19,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { redact, unredact } from "./redact.js";
 import { auditPatch } from "./gates.js";
-import { generatePatch, generateRulePatch, modelTiers, RULE_TIER } from "./llm.js";
+import { generatePatch, generateRulePatch, modelTiers, RULE_TIER, BudgetExhaustedError } from "./llm.js";
 import { hasLlmKey } from "../llm.js";
 import { applyHunks, createWorktree, diffWorktree, runTests, typecheckWorktree, writeWorktreeFile } from "./sandbox.js";
 import { bootServer, detectStartCommand } from "./boot.js";
@@ -154,12 +154,14 @@ export async function heal(finding, opts) {
             // 2. Generate (this tier).
             let patch;
             try {
-                patch = await generatePatch(ctx, { model: tier.model, patchFn: opts.patchFn });
+                patch = await generatePatch(ctx, { model: tier.model, patchFn: opts.patchFn, budget: opts.budget });
             }
             catch (e) {
-                // A transport/config failure isn't a model-quality failure — a pricier
-                // tier won't fix a dead endpoint or a missing key, so stop here.
-                last = { ...base, status: "no-llm", error: e.message, model: tier.model };
+                // A spent session budget stops everything paid; a transport/config failure
+                // won't be fixed by a pricier tier either, so both break out here.
+                last = e instanceof BudgetExhaustedError
+                    ? { ...base, status: "budget-exhausted", error: e.message, model: tier.model }
+                    : { ...base, status: "no-llm", error: e.message, model: tier.model };
                 break;
             }
             if (patch.hunks.length === 0) {

package/dist/core/heal/llm.js

@@ -45,6 +45,14 @@ Hard rules:
 - Do NOT add any new import/require/import(). Do NOT use eval or new Function. Do NOT write an empty catch block (catch {}). Do NOT touch child_process, exec, spawn, fork, process.exit.
 - If you see __AZTRX_REDACTED_N__ placeholders, treat them as opaque tokens and carry them through unchanged — do not invent values for them.
 - If you cannot fix the bug, return { "explanation": "cannot fix", "edits": [] }.`;
+/** Thrown when the shared session budget has no paid generations left. Heal
+ * maps this to a `budget-exhausted` status rather than a transport error. */
+export class BudgetExhaustedError extends Error {
+    constructor() {
+        super("spend budget exhausted");
+        this.name = "BudgetExhaustedError";
+    }
+}
 function buildPrompt(ctx) {
     const loc = ctx.finding.mappedLocation;
     const msg = redact(ctx.finding.rawMessage).text;
@@ -120,6 +128,12 @@ export async function generatePatch(ctx, opts = {}) {
             return rulePatch;
         throw new Error("no rule-based fix applicable");
     }
+    // Paid path — enforce the shared session budget before spending, and charge it
+    // on success. The free rule tier above never reaches this, so a spent budget
+    // still lets free fixes through.
+    if (opts.budget && opts.budget.remaining <= 0) {
+        throw new BudgetExhaustedError();
+    }
     const text = await complete({
         system: SYSTEM,
         prompt: buildPrompt(ctx),
@@ -127,5 +141,7 @@ export async function generatePatch(ctx, opts = {}) {
         maxTokens: 2048,
         temperature: 0,
     });
+    if (opts.budget)
+        opts.budget.remaining -= 1;
     return parsePatch(text);
 }

package/dist/core/heal/redact.js

@@ -42,7 +42,11 @@ const VALUE_MATCH = [
         label: "secret_value",
     },
     {
-        re: /((?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp|amqps):\/\/[^:/\s]+:)[^@\s]+(@)/gi,
+        // Captures the password as group 2 and stops at `@` with a lookahead so the
+        // `@` is never consumed. (The old form captured `(@)` instead — group 2 was
+        // the literal `@` — so the password was dropped and `unredact` restored `@`
+        // in its place, corrupting the URL.)
+        re: /((?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp|amqps):\/\/[^:/\s]+:)([^@\s]+)(?=@)/gi,
         label: "url_password",
     },
 ];

package/dist/core/heal/sandbox.js

@@ -43,7 +43,11 @@ export function applyHunks(content, hunks) {
         return { ok: false, patched: content, applied: 0, errors };
     let patched = content;
     for (const h of hunks) {
-        patched = patched.replace(h.search, h.replace);
+        // Function replacer: a plain `replace(search, replace)` treats `$&`, `$1`,
+        // `` $` ``, `$'`, `$$` in `replace` as substitution tokens, so a fix that
+        // introduces a literal `$5` (a price, a template fragment, a regex capture)
+        // would be silently mangled. The function form inserts `replace` verbatim.
+        patched = patched.replace(h.search, () => h.replace);
     }
     return { ok: true, patched, applied: hunks.length, errors: [] };
 }

package/dist/core/httpFuzzer.js

@@ -90,7 +90,7 @@ function hostAllowed(url, allowHosts) {
     return false;
 }
 /** Harvest candidate endpoints the app actually uses — not blind probing. */
-async function collectEndpoints(page, origin) {
+async function collectEndpoints(page, origin, allowDestructive, seedUrls = []) {
     const seen = new Map();
     const push = (raw) => {
         let u;
@@ -104,11 +104,15 @@ async function collectEndpoints(page, origin) {
             return;
         if (STATIC_EXT.test(u.pathname))
             return;
-        if (DESTRUCTIVE_PATH.test(u.pathname))
+        if (!allowDestructive && DESTRUCTIVE_PATH.test(u.pathname))
             return;
         if (!seen.has(u.pathname))
             seen.set(u.pathname, u);
     };
+    // Endpoints observed live by the caller — e.g. a `fetch()` fired from a click
+    // handler that never appears in `performance` resources or the DOM.
+    for (const s of seedUrls)
+        push(s);
     // URLs the page already fetched (API calls, RSC/data endpoints).
     const resources = await page
         .evaluate(() => performance.getEntriesByType("resource").map((e) => e.name))
@@ -191,11 +195,11 @@ export async function httpFuzz(page, targetUrl, bus, opts = {}) {
     const allowHosts = opts.allowHosts ?? new Set();
     if (!hostAllowed(targetUrl, allowHosts))
         return 0;
-    if (!opts.dryRun) {
+    if (!opts.dryRun && opts.navigate !== false) {
         await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => { });
         await page.waitForTimeout(500);
     }
-    const endpoints = await collectEndpoints(page, new URL(targetUrl).origin);
+    const endpoints = await collectEndpoints(page, new URL(targetUrl).origin, Boolean(opts.allowDestructive), opts.seedUrls ?? []);
     endpoints.sort((a, b) => a.pathname.localeCompare(b.pathname));
     let sent = 0;
     outer: for (const endpoint of endpoints) {

package/dist/core/orchestrator.js

@@ -3,6 +3,7 @@ import pc from "picocolors";
 import { VERSION } from "./version.js";
 import { EventBus } from "./eventBus.js";
 import { loadBaseline } from "./classifier.js";
+import { diagnoseFinding } from "./diagnose.js";
 import { attachNetworkGuard, allowHostsFrom } from "./networkGuard.js";
 import { swarmDetect } from "./swarm.js";
 import { ReplayEngine } from "./replay.js";
@@ -14,18 +15,23 @@ import { RunLog } from "./events.js";
 import { heal } from "./heal/index.js";
 import { submitTelemetry } from "./telemetry/index.js";
 import { submitRun } from "./cloud/index.js";
+import { formatDiff } from "./diff.js";
 const SEVERITY_MARK = {
     crash: pc.red("● crash "),
     error: pc.red("● error "),
     warning: pc.yellow("○ warning "),
     noise: pc.dim("○ noise "),
 };
-function printFinding(f, write) {
+function printFinding(f, write, lang) {
     write(SEVERITY_MARK[f.severity] + pc.bold(f.rawMessage));
     if (f.mappedLocation) {
         write(pc.dim(`   ${f.mappedLocation.filePath}:${f.mappedLocation.line}:${f.mappedLocation.column}`));
         write(pc.dim(f.mappedLocation.codeContext));
     }
+    // F14 — the one-line "why + fix" diagnosis, inline with every crash/error.
+    const dx = diagnoseFinding(f, lang);
+    if (dx)
+        write(pc.cyan(`   ↳ ${dx}`));
     if (f.serverError) {
         write(pc.dim(`   server: ${f.serverError.message}`));
     }
@@ -78,6 +84,10 @@ export async function run(options) {
         say(pc.dim(`Net:    deny-by-default → allow ${[...allowHosts].join(", ") || "origin"}`));
     if (options.storageState)
         say(pc.dim(`Auth:   ${options.storageState}`));
+    if (options.allowDestructive) {
+        say(pc.yellow(pc.bold("⚠ DESTRUCTIVE MODE — delete/pay/logout/checkout controls are ENABLED.")));
+        say(pc.yellow("  This can mutate real data. Run only against a disposable/dev instance you own."));
+    }
     say("");
     emitPhase("launch", url);
     const runLog = new RunLog(repoRoot);
@@ -85,10 +95,11 @@ export async function run(options) {
     runLog.append({ type: "run_start", url, ts: Date.now() });
     const baseline = await loadBaseline(repoRoot);
     const workers = options.workers ?? 1;
-    // F-swarm — parallel detection. One worker is the legacy pass; `--http-fuzz`
-    // or `workers > 1` fan out into a swarm. Findings come back merged by
+    // F-swarm — parallel detection. One worker is the legacy pass; `workers > 1`
+    // fans out into a swarm. `--http-fuzz` folds into the walk/fuzz pass as a
+    // post-pass on the same page (no extra worker). Findings come back merged by
     // fingerprint, with per-worker action history already attached.
-    if (workers > 1 || options.httpFuzz) {
+    if (workers > 1) {
         emitPhase("swarm", `${workers} worker(s)`);
     }
     else if (options.fuzz) {
@@ -105,6 +116,7 @@ export async function run(options) {
         fuzz: options.fuzz,
         httpFuzz: options.httpFuzz,
         httpFuzzMutations: options.httpFuzzMutations,
+        allowDestructive: options.allowDestructive,
         seed: options.seed ?? 42,
         workers,
         allowHosts,
@@ -125,7 +137,7 @@ export async function run(options) {
     for (const f of findings) {
         bus.emit("finding", f);
         runLog.append({ type: "finding", finding: f });
-        printFinding(f, say);
+        printFinding(f, say, options.lang);
     }
     if (workerCount > 1) {
         say(pc.dim(`\nSwarm: ${totalActions} action(s) across ${workerCount} worker(s) — ${roles.join(", ")}.\n`));
@@ -235,7 +247,9 @@ export async function run(options) {
             f.type !== "network_timeout" &&
             f.repro &&
             f.repro.verdict !== "unreliable");
-        const healTargets = reproducible.filter((f) => f.mappedLocation?.isOwnCode);
+        const skip = new Set(options.skipHealFingerprints ?? []);
+        const candidates = reproducible.filter((f) => !skip.has(f.fingerprint));
+        const healTargets = candidates.filter((f) => f.mappedLocation?.isOwnCode);
         if (healTargets.length) {
             say(pc.cyan("— Closed-loop healing (redact → generate → gate → sandbox → test → verify) —"));
             emitPhase("heal");
@@ -254,6 +268,7 @@ export async function run(options) {
                         testTimeoutMs: options.testTimeoutMs,
                         skipTest: options.skipTest,
                         startCommand: options.startCommand,
+                        budget: options.budget,
                     });
                     f.heal = result;
                     bus.emit("heal", {
@@ -273,8 +288,14 @@ export async function run(options) {
                         ? pc.green("  ✓ healed")
                         : result.status === "unfixed"
                             ? pc.yellow("  ◐ unfixed")
-                            : pc.red(`  ✗ ${result.status}`);
+                            : result.status === "budget-exhausted"
+                                ? pc.dim("  ⏹ budget exhausted")
+                                : pc.red(`  ✗ ${result.status}`);
                     say(`${mark}  ${pc.bold(f.rawMessage.split("\n")[0].slice(0, 60))}`);
+                    if (result.status === "healed" && result.hunks.length > 0) {
+                        say(pc.dim(`        ${result.filePath}`));
+                        say(formatDiff(result.hunks));
+                    }
                     if (result.patchPath)
                         say(pc.dim(`        patch: ${path.relative(repoRoot, result.patchPath)}`));
                     if (result.error)
@@ -295,13 +316,14 @@ export async function run(options) {
                 }
             }
         }
-        else if (reproducible.length > 0) {
+        else if (candidates.length > 0) {
             // Reproducible crashes, but none mapped to source (wrong --repo?) — tell the
-            // user rather than silently doing nothing.
-            say(pc.yellow(`Found ${reproducible.length} reproducible crash(es) but couldn't map them to source files. Run from your project root (or pass --repo <dir>) so --fix can read the code.`));
+            // user rather than silently doing nothing. Already-handled fingerprints are
+            // excluded above, so this only fires for genuinely new findings.
+            say(pc.yellow(`Found ${candidates.length} reproducible crash(es) but couldn't map them to source files. Run from your project root (or pass --repo <dir>) so --fix can read the code.`));
         }
     }
-    const reportPath = writeReport(repoRoot, url, findings);
+    const reportPath = writeReport(repoRoot, url, findings, options.lang);
     say(pc.dim(`Report: ${path.relative(repoRoot, reportPath)}`));
     const counts = {};
     for (const f of findings)

package/dist/core/patrol/loop.js

@@ -0,0 +1,218 @@
+/**
+ * `aztrx patrol` — the autonomous bug-patrol loop. It wraps the existing
+ * `run()` detect → repro → heal pipeline in a supervisor loop with memory, so
+ * instead of "run it and read the output" the tool re-scans on an interval,
+ * fixes anything new, and opens a PR per bug — no human in the middle.
+ *
+ * Guardrails that keep an autonomous run from going off the rails:
+ *   - memory (PatrolState) — a handled fingerprint is never re-fixed/re-PR'd;
+ *   - per-session fix cap (`maxFixes`) — bounds LLM spend + PR spam;
+ *   - scoped staging — PRs carry only the files the patch touched;
+ *   - a liveness check — a dead target skips the cycle instead of burning a crawl.
+ */
+import pc from "picocolors";
+import { run } from "../orchestrator.js";
+import { applyVerifiedPatches } from "../heal/apply.js";
+import { PatrolState } from "./state.js";
+import { openPatrolPr, openPatrolBatchPr } from "./pr.js";
+import { recordFindingGif } from "./record.js";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Any HTTP response means the server is up; only a network failure is "down". */
+async function isAlive(url) {
+    try {
+        await fetch(url, { signal: AbortSignal.timeout(3000) });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function head(f) {
+    return f.rawMessage.split("\n")[0].slice(0, 50);
+}
+/** Best-effort GIF recording — a failed capture must never block a PR. */
+async function recordGif(repoRoot, url, f) {
+    try {
+        return await recordFindingGif(repoRoot, url, f);
+    }
+    catch (e) {
+        console.log(pc.dim(`  · recorded repro skipped: ${e.message}`));
+        return null;
+    }
+}
+export async function patrol(opts) {
+    const retryAfterMs = opts.retryAfterMs ?? 30 * 60 * 1000;
+    const state = new PatrolState(opts.repoRoot, opts.url, retryAfterMs);
+    const maxFixes = opts.maxFixes ?? 5;
+    let sessionFixes = 0;
+    let sessionPrs = 0;
+    const seenFp = new Set();
+    // One budget object is shared across every cycle so the cap spans the session,
+    // not just a single run.
+    const budget = opts.maxSpend && opts.maxSpend > 0 ? { remaining: opts.maxSpend } : undefined;
+    console.log(pc.cyan("Aztrx AI — patrol"));
+    console.log(pc.dim(`Target: ${opts.url}   interval: ${Math.round(opts.intervalMs / 1000)}s   max fixes/session: ${maxFixes}` +
+        `   retry unfixed after: ${Math.round(retryAfterMs / 1000)}s` +
+        (budget ? `   spend cap: ${budget.remaining} generations` : "")));
+    console.log("");
+    for (let cycle = 1;; cycle++) {
+        if (!(await isAlive(opts.url))) {
+            console.log(pc.dim(`[cycle ${cycle}] target not responding — skipping this pass.`));
+            if (opts.once)
+                break;
+            await sleep(opts.intervalMs);
+            continue;
+        }
+        console.log(pc.dim(`[cycle ${cycle}] scanning…`));
+        let findings;
+        try {
+            // `ui: true` silences the per-run console so patrol prints its own concise
+            // summary instead of the full pipeline log on every cycle.
+            findings = await run({
+                url: opts.url,
+                repoRoot: opts.repoRoot,
+                maxActions: opts.maxActions,
+                fuzz: opts.fuzz,
+                workers: opts.workers,
+                allowHosts: opts.allowHosts,
+                storageState: opts.storageState,
+                login: opts.login,
+                loginEmail: opts.loginEmail,
+                loginPassword: opts.loginPassword,
+                loginUrl: opts.loginUrl,
+                lang: opts.lang,
+                seed: opts.seed,
+                allowDestructive: opts.allowDestructive,
+                httpFuzz: opts.httpFuzz,
+                httpFuzzMutations: opts.httpFuzzMutations,
+                repro: true,
+                heal: true,
+                healModel: opts.healModel,
+                healFastModel: opts.healFastModel,
+                testCommand: opts.testCommand,
+                testTimeoutMs: opts.testTimeoutMs,
+                skipTest: opts.skipTest,
+                startCommand: opts.startCommand,
+                // Already-handled fingerprints from a prior cycle get skipped before heal,
+                // so a re-scan re-detects (to confirm they're still gone) without re-paying
+                // the LLM to re-fix them.
+                skipHealFingerprints: state.handled(),
+                budget,
+                ui: true,
+            });
+        }
+        catch (e) {
+            console.log(pc.red(`[cycle ${cycle}] run failed: ${e.message}`));
+            if (opts.once)
+                break;
+            await sleep(opts.intervalMs);
+            continue;
+        }
+        // "found" = distinct crash/error fingerprints ever seen this session.
+        for (const f of findings) {
+            if (f.severity === "crash" || f.severity === "error")
+                seenFp.add(f.fingerprint);
+        }
+        // Reproducible but not healed → mark unfixable so we don't re-burn the LLM on
+        // it every cycle; `PatrolState` backs off and retries it once the cooldown
+        // lapses. `budget-exhausted` / `no-llm` are NOT unfixable — they mean we never
+        // got a real attempt, so they must not be written into memory as "won't fix".
+        for (const f of findings) {
+            if ((f.severity === "crash" || f.severity === "error") &&
+                f.repro &&
+                f.heal &&
+                f.heal.status !== "healed" &&
+                f.heal.status !== "budget-exhausted" &&
+                f.heal.status !== "no-llm" &&
+                !state.isHandled(f.fingerprint)) {
+                state.markUnfixed(f.fingerprint);
+            }
+        }
+        const newHealed = findings.filter((f) => f.heal?.status === "healed" && !state.isHandled(f.fingerprint));
+        const toFix = newHealed.slice(0, Math.max(0, maxFixes - sessionFixes));
+        if (toFix.length === 0 && sessionFixes >= maxFixes && newHealed.length > 0) {
+            console.log(pc.yellow(`[cycle ${cycle}] reached max fixes (${maxFixes}) — no more this session.`));
+        }
+        if (opts.batch) {
+            // Batch: apply each patch, then open one PR carrying every fix that landed.
+            const landed = [];
+            const files = [];
+            for (const f of toFix) {
+                const applied = applyVerifiedPatches(opts.repoRoot, [f]);
+                if (applied.applied.length === 0) {
+                    state.markUnfixed(f.fingerprint);
+                    console.log(pc.yellow(`  ◐ ${head(f)} — apply conflict, marked unfixable.`));
+                    continue;
+                }
+                landed.push(f);
+                for (const a of applied.applied)
+                    files.push(a.filePath);
+            }
+            if (landed.length > 0) {
+                const mediaPaths = [];
+                for (const f of landed)
+                    mediaPaths.push(await recordGif(opts.repoRoot, opts.url, f));
+                const pr = await openPatrolBatchPr(opts.repoRoot, landed, opts.url, [...new Set(files)], mediaPaths);
+                if (pr.ok && pr.url) {
+                    sessionPrs++;
+                    sessionFixes += landed.length;
+                    for (const f of landed)
+                        state.markPr(f.fingerprint, pr.url, pr.branch ?? "");
+                    console.log(pc.green(`  ✓ batch PR opened ${pr.url} — ${landed.length} fix(es)`));
+                }
+                else if (pr.skipped) {
+                    for (const f of landed)
+                        state.markPr(f.fingerprint, "existing", pr.branch ?? "");
+                    console.log(pc.dim(`  — batch PR already exists (${pr.branch})`));
+                }
+                else {
+                    for (const f of landed)
+                        state.markUnfixed(f.fingerprint);
+                    console.log(pc.red(`  ✗ batch PR failed: ${pr.error}`));
+                }
+            }
+        }
+        else {
+            for (const f of toFix) {
+                const applied = applyVerifiedPatches(opts.repoRoot, [f]);
+                if (applied.applied.length === 0) {
+                    state.markUnfixed(f.fingerprint);
+                    console.log(pc.yellow(`  ◐ ${head(f)} — apply conflict, marked unfixable.`));
+                    continue;
+                }
+                const files = applied.applied.map((a) => a.filePath);
+                const mediaPath = await recordGif(opts.repoRoot, opts.url, f);
+                const pr = await openPatrolPr(opts.repoRoot, f, opts.url, files, mediaPath);
+                if (pr.ok && pr.url) {
+                    sessionPrs++;
+                    sessionFixes++;
+                    state.markPr(f.fingerprint, pr.url, pr.branch ?? "");
+                    console.log(pc.green(`  ✓ PR opened ${pr.url} — ${head(f)}`));
+                }
+                else if (pr.skipped) {
+                    state.markPr(f.fingerprint, "existing", pr.branch ?? "");
+                    console.log(pc.dim(`  — already has a PR (${pr.branch})`));
+                }
+                else {
+                    state.markUnfixed(f.fingerprint);
+                    console.log(pc.red(`  ✗ PR failed: ${pr.error}`));
+                }
+            }
+        }
+        // Rolling status — the "found / fixed / PRs" tally that makes the loop read
+        // as alive rather than a stream of isolated lines.
+        console.log(pc.dim(`[cycle ${cycle}] found ${seenFp.size} · fixed ${sessionFixes} · PRs ${sessionPrs}` +
+            (newHealed.length === 0 ? " · nothing new to fix" : "")));
+        // Once the session's paid budget is spent there's nothing left to fix — stop
+        // rather than silently re-detecting without healing.
+        if (budget && budget.remaining <= 0) {
+            console.log(pc.yellow(`\nSpend budget exhausted — ${sessionPrs} PR(s) opened this session.`));
+            break;
+        }
+        state.save();
+        if (opts.once)
+            break;
+        await sleep(opts.intervalMs);
+    }
+    console.log(pc.cyan(`patrol session done — found ${seenFp.size} bug(s) · fixed ${sessionFixes} · PRs ${sessionPrs}`));
+}