donobu 5.28.0 → 5.30.0

package/dist/cli/donobu-cli.d.ts

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 declare function hasReporterArg(args: string[]): boolean;
-declare function injectJsonReporterIntoArgs(args: string[]): boolean;
+declare function injectJsonReporterIntoArgs(args: string[]): {
+    /** True when the args contained any `--reporter` / `-r` flag. */
+    reporterFlagFound: boolean;
+    /** True when the user's args already listed `json` — i.e. they configured
+     *  a JSON reporter themselves rather than us force-injecting one. */
+    userHadJson: boolean;
+};
 declare function ensureReporterValueHasJson(value: string): {
     value: string;
     changed: boolean;

package/dist/cli/donobu-cli.js

@@ -309,8 +309,13 @@ const noopAsync = async () => { };
  */
 async function ensureJsonReporter(originalArgs, options = {}) {
     const args = [...originalArgs];
-    if (injectJsonReporterIntoArgs(args)) {
-        return { args, cleanup: noopAsync };
+    const argInjection = injectJsonReporterIntoArgs(args);
+    if (argInjection.reporterFlagFound) {
+        return {
+            args,
+            cleanup: noopAsync,
+            resolveUserConfiguredJson: async () => argInjection.userHadJson,
+        };
     }
     const configPath = await resolvePlaywrightConfigPath(args);
     if (!configPath) {
@@ -322,13 +327,21 @@ async function ensureJsonReporter(originalArgs, options = {}) {
             args.push('--reporter=json');
         }
         Logger_1.appLogger.debug('No Playwright config detected; falling back to CLI --reporter=json injection.');
-        return { args, cleanup: noopAsync };
+        return {
+            args,
+            cleanup: noopAsync,
+            resolveUserConfiguredJson: async () => false,
+        };
     }
-    const { configPath: wrapperPath, cleanup } = await createConfigWrapperWithJsonReporter(configPath, options);
-    Logger_1.appLogger.debug(`Augmenting Playwright config at ${configPath} with temporary wrapper ${wrapperPath} to ensure JSON reporter.`);
+    const wrapper = await createConfigWrapperWithJsonReporter(configPath, options);
+    Logger_1.appLogger.debug(`Augmenting Playwright config at ${configPath} with temporary wrapper ${wrapper.configPath} to ensure JSON reporter.`);
     const strippedArgs = stripConfigArgs(args);
-    const finalArgs = insertConfigArg(strippedArgs, wrapperPath);
-    return { args: finalArgs, cleanup };
+    const finalArgs = insertConfigArg(strippedArgs, wrapper.configPath);
+    return {
+        args: finalArgs,
+        cleanup: wrapper.cleanup,
+        resolveUserConfiguredJson: wrapper.resolveUserConfiguredJson,
+    };
 }
 function hasReporterArg(args) {
     for (const arg of args) {
@@ -346,6 +359,7 @@ function hasReporterArg(args) {
 }
 function injectJsonReporterIntoArgs(args) {
     let reporterFlagFound = false;
+    let userHadJson = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
         if (arg === '--') {
@@ -357,8 +371,8 @@ function injectJsonReporterIntoArgs(args) {
             if (valueIndex < args.length) {
                 const { value, changed } = ensureReporterValueHasJson(args[valueIndex]);
                 args[valueIndex] = value;
-                if (changed) {
-                    reporterFlagFound = true;
+                if (!changed) {
+                    userHadJson = true;
                 }
             }
             i += 1;
@@ -367,11 +381,14 @@ function injectJsonReporterIntoArgs(args) {
         if (arg.startsWith('--reporter=') || arg.startsWith('-r=')) {
             reporterFlagFound = true;
             const [prefix, rawValue] = arg.split('=', 2);
-            const { value } = ensureReporterValueHasJson(rawValue ?? '');
+            const { value, changed } = ensureReporterValueHasJson(rawValue ?? '');
             args[i] = `${prefix}=${value}`;
+            if (!changed) {
+                userHadJson = true;
+            }
         }
     }
-    return reporterFlagFound;
+    return { reporterFlagFound, userHadJson };
 }
 function ensureReporterValueHasJson(value) {
     const segments = value
@@ -466,7 +483,8 @@ function insertConfigArg(args, configPath) {
 async function createConfigWrapperWithJsonReporter(originalConfigPath, options = {}) {
     const stagingDir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'donobu-playwright-config-'));
     const wrapperPath = path.join(stagingDir, 'playwright.config.cjs');
-    const content = buildConfigWrapperContent(originalConfigPath, options.jsonOutputFile);
+    const sentinelPath = path.join(stagingDir, '.donobu-user-had-json');
+    const content = buildConfigWrapperContent(originalConfigPath, sentinelPath, options.jsonOutputFile);
     await fs_1.promises.writeFile(wrapperPath, content, 'utf-8');
     const cleanup = async () => {
         try {
@@ -476,10 +494,25 @@ async function createConfigWrapperWithJsonReporter(originalConfigPath, options =
             Logger_1.appLogger.warn(`Failed to remove temporary Playwright config at ${stagingDir}.`, error);
         }
     };
-    return { configPath: wrapperPath, cleanup };
+    // The wrapper writes the sentinel inside its top-level config-load code, so
+    // it exists by the time Playwright has loaded the config. Read it after the
+    // wrapped run finishes and before `cleanup` tears the staging dir down.
+    const resolveUserConfiguredJson = async () => {
+        try {
+            const raw = await fs_1.promises.readFile(sentinelPath, 'utf8');
+            return raw.trim() === '1';
+        }
+        catch {
+            // Sentinel missing (wrapper never loaded, or already cleaned up). Err on
+            // the side of "no user JSON" so we don't leave a giant artifact behind.
+            return false;
+        }
+    };
+    return { configPath: wrapperPath, cleanup, resolveUserConfiguredJson };
 }
-function buildConfigWrapperContent(originalConfigPath, jsonOutputFileOverride) {
+function buildConfigWrapperContent(originalConfigPath, userHadJsonSentinelPath, jsonOutputFileOverride) {
     const sanitisedPath = originalConfigPath.replace(/\\/g, '\\\\');
+    const sentinelPath = userHadJsonSentinelPath.replace(/\\/g, '\\\\');
     const forcedJsonPath = jsonOutputFileOverride
         ? jsonOutputFileOverride.replace(/\\/g, '\\\\')
         : null;
@@ -489,6 +522,7 @@ function buildConfigWrapperContent(originalConfigPath, jsonOutputFileOverride) {
 
 const path = require('path');
 const forcedJsonOutputFile = ${forcedLiteral};
+const userHadJsonSentinelPath = '${sentinelPath}';
 
 function loadBaseConfig() {
   const imported = require('${sanitisedPath}');
@@ -604,6 +638,16 @@ const hasJsonReporter = reporters.some((entry) => {
   return false;
 });
 
+// Tell the parent orchestrator whether the user's own config defined a JSON
+// reporter (vs us about to force-inject one). The orchestrator reads this to
+// decide whether to persist the merged auto-heal report — we don't want to
+// leave a multi-megabyte JSON artifact behind for users who never asked for one.
+try {
+  require('fs').writeFileSync(userHadJsonSentinelPath, hasJsonReporter ? '1' : '0', 'utf8');
+} catch (_) {
+  // Non-fatal — the orchestrator falls back to "no user JSON" if missing.
+}
+
 if (!hasJsonReporter) {
   const outputFile =
     forcedJsonOutputFile ||
@@ -861,6 +905,35 @@ async function overwriteReportTargets(sourcePath, targets) {
         }
     }));
 }
+/**
+ * Remove the JSON artifacts Donobu wrote purely for its own use:
+ *
+ * - The Donobu reporter state file (`.donobu-report-state.json`) — internal
+ *   IPC between the HTML/Markdown/Slack reporters and this orchestrator.
+ *   Always safe to delete once orchestration finishes; nothing else reads it.
+ * - The Playwright JSON report — when the user did not configure a JSON
+ *   reporter themselves, this file is purely Donobu's by-product (we forced
+ *   the JSON reporter on to drive treatment plans and the merge step).
+ *
+ * Best-effort: missing files are ignored. Any failure is non-fatal — these
+ * cleanups don't affect test exit code.
+ */
+async function cleanupForceInjectedJsonArtifacts(params) {
+    const targets = [
+        path.join(params.playwrightOutputDir, model_1.DONOBU_REPORT_STATE_FILENAME),
+    ];
+    if (!params.userConfiguredJsonReporter && params.discoveredJsonPath) {
+        targets.push(params.discoveredJsonPath);
+    }
+    await Promise.all(targets.map(async (target) => {
+        try {
+            await fs_1.promises.rm(target, { force: true });
+        }
+        catch (error) {
+            Logger_1.appLogger.debug(`Failed to remove force-injected JSON artifact at ${target}: ${error}`);
+        }
+    }));
+}
 /**
  * Donobu always wants Playwright's JSON reporter enabled so we can build
  * treatment plans. If the user did not explicitly configure it we add the
@@ -1263,11 +1336,17 @@ async function attemptAutoHealRun(params) {
         finally {
             await reporterSetup.cleanup();
         }
-        const healReportDestination = path.join(params.playwrightOutputDir, `donobu-auto-heal-report-${Date.now()}.json`);
-        const healReportCopy = await copyJsonReport(staging.playwrightOutputDir, healReportDestination, {
-            envOverrides,
-            additionalCandidates: [healJsonReportPath],
-        });
+        // Persist the heal-run JSON next to the user's other reports only when
+        // they actually configured a JSON reporter — otherwise the file is just
+        // Donobu's by-product. The merge step below reads the report from the
+        // staging dir's state file, which is still alive at this point, so we
+        // don't need a persisted copy for our own use.
+        const healReportCopy = params.userConfiguredJsonReporter
+            ? await copyJsonReport(staging.playwrightOutputDir, path.join(params.playwrightOutputDir, `donobu-auto-heal-report-${Date.now()}.json`), {
+                envOverrides,
+                additionalCandidates: [healJsonReportPath],
+            })
+            : null;
         if (healTriageEnabled && healTriageContext && healExitCode !== 0) {
             await postProcessTriageRun(healTriageContext, healArgsForRun, healReportCopy?.destinationPath ?? undefined);
             const finalTriageBaseDir = params.options.triageOutputDir
@@ -1296,18 +1375,19 @@ async function attemptAutoHealRun(params) {
         // reporter output for configs that don't wire up the Donobu reporter.
         const healReport = await loadDonobuReportForMerge(staging.playwrightOutputDir, healReportCopy?.destinationPath ?? undefined);
         if (params.initialReport || healReport) {
-            // Write the merged report directly to the primary report target when
-            // available, avoiding a redundant intermediate file.
+            // Write the merged report directly to the user's primary JSON target
+            // when one exists. When the user did not configure a JSON reporter,
+            // `reportTargets` is empty — skip the disk write entirely rather than
+            // leaving a multi-megabyte fallback artifact behind. The HTML / Markdown
+            // / Slack regeneration below uses the in-memory merged object, so they
+            // don't depend on a JSON file landing on disk.
             const primaryTarget = params.reportTargets[0];
-            const mergedReportPath = primaryTarget
-                ? primaryTarget
-                : path.join(params.playwrightOutputDir, `donobu-merged-report-${Date.now()}.json`);
             const mergedReport = await mergePlaywrightJsonReports({
                 initialReport: params.initialReport ?? null,
                 initialReportSourcePath: params.initialReportSourcePath,
                 healReport,
                 healReportSourcePath: healReportCopy?.destinationPath ?? undefined,
-                mergedReportPath,
+                mergedReportPath: primaryTarget,
                 healedTests: evaluation.eligiblePlans.map((record) => ({
                     plan: record.plan,
                     testCase: record.evidence.failureContext.testCase,
@@ -1318,8 +1398,8 @@ async function attemptAutoHealRun(params) {
             });
             // Copy to any remaining report targets (skip the primary — already
             // written there).
-            if (mergedReport && params.reportTargets.length > 1) {
-                await overwriteReportTargets(mergedReportPath, params.reportTargets.slice(1));
+            if (mergedReport && primaryTarget && params.reportTargets.length > 1) {
+                await overwriteReportTargets(primaryTarget, params.reportTargets.slice(1));
             }
             if (mergedReport) {
                 await regenerateDonobuReports(mergedReport);
@@ -1482,10 +1562,14 @@ async function loadDonobuReportForMerge(outputDir, fallbackPath) {
 }
 /**
  * Combine the reports from the original failed run and any auto-heal rerun,
- * relocate any heal-run attachments to persistent storage, and write the
- * merged JSON to `mergedReportPath` for downstream dashboards. Returns the
- * in-memory merged report so the caller can drive HTML regeneration without
- * re-reading from disk.
+ * relocate any heal-run attachments to persistent storage, and optionally
+ * write the merged JSON to `mergedReportPath` for downstream dashboards.
+ * Returns the in-memory merged report so the caller can drive HTML
+ * regeneration without re-reading from disk.
+ *
+ * When `mergedReportPath` is omitted, the merge happens entirely in memory —
+ * useful when the user has not configured a JSON reporter and we don't want
+ * to leave a giant artifact on disk just for our internal use.
  *
  * Also forwards `metadata.donobuOutputs` from whichever input recorded it
  * (typically the initial run's state file), so regeneration lands every
@@ -1523,9 +1607,14 @@ async function mergePlaywrightJsonReports(params) {
     if (params.outputDir) {
         await relocateTemporaryAttachments(merged, params.outputDir);
     }
-    await ensureDirectory(path.dirname(params.mergedReportPath));
-    await fs_1.promises.writeFile(params.mergedReportPath, JSON.stringify(merged, null, 2), 'utf8');
-    Logger_1.appLogger.debug(`Saved merged Playwright report to ${params.mergedReportPath}.`);
+    if (params.mergedReportPath) {
+        await ensureDirectory(path.dirname(params.mergedReportPath));
+        // Compact JSON — these reports are machine-consumed (auto-heal merge,
+        // dashboards, downstream tooling), and pretty-printing inflates the file
+        // by 10–15% on a multi-megabyte payload for no human benefit.
+        await fs_1.promises.writeFile(params.mergedReportPath, JSON.stringify(merged), 'utf8');
+        Logger_1.appLogger.debug(`Saved merged Playwright report to ${params.mergedReportPath}.`);
+    }
     return merged;
 }
 async function readJsonIfExists(filePath) {
@@ -1640,8 +1729,12 @@ async function runTestCommand(cliArgs) {
     const runArgs = reporterSetup.args;
     Logger_1.appLogger.debug(`Initial Playwright args: ${JSON.stringify(runArgs)} with env overrides ${JSON.stringify(envOverrides)}`);
     let exitCode;
+    let userConfiguredJsonReporter = false;
     try {
         exitCode = await runPlaywright(runArgs, envOverrides);
+        // Read before cleanup, since the wrapper-sentinel lives in the staging dir.
+        userConfiguredJsonReporter =
+            await reporterSetup.resolveUserConfiguredJson();
     }
     finally {
         await reporterSetup.cleanup();
@@ -1652,68 +1745,86 @@ async function runTestCommand(cliArgs) {
     // can populate reportTargets regardless of whether auto-heal is needed.
     // Uses the same candidate-resolution order as loadJsonReport to avoid
     // accidentally picking up leftover donobu-*-report-*.json files.
+    // Only treat the discovered report as a real "target to overwrite" when the
+    // user actually configured a JSON reporter — when Donobu force-injected one
+    // for its own use, leaving a multi-megabyte JSON behind is just noise.
     const discoveredReport = await findJsonReportPath(playwrightOutputDir, {
         envOverrides,
         additionalCandidates: [
             path.join(playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME),
         ],
     });
-    if (discoveredReport) {
+    if (discoveredReport && userConfiguredJsonReporter) {
         reportTargets.add(discoveredReport);
     }
-    if (exitCode === 0 || !effectiveOptions.autoHeal) {
-        // Auto-heal wasn't attempted (either tests passed or the user disabled
-        // it). If a Slack reporter deferred its POST waiting for us, deliver the
-        // initial run's payload now — nothing further will be re-rendered.
-        if (effectiveOptions.autoHeal) {
+    try {
+        if (exitCode === 0 || !effectiveOptions.autoHeal) {
+            // Auto-heal wasn't attempted (either tests passed or the user disabled
+            // it). If a Slack reporter deferred its POST waiting for us, deliver the
+            // initial run's payload now — nothing further will be re-rendered.
+            if (effectiveOptions.autoHeal) {
+                await postDeferredSlackFromInitialRun(playwrightOutputDir);
+            }
+            return exitCode;
+        }
+        // Tests failed and auto-heal is enabled — load the initial report into
+        // memory so we can merge it with the heal-run report later without writing
+        // a redundant copy to disk.
+        let loadedPlaywrightJson = null;
+        let initialDonobuReport = null;
+        if (triageEnabled) {
+            loadedPlaywrightJson = await loadJsonReport(playwrightOutputDir, {
+                envOverrides,
+                additionalCandidates: [
+                    path.join(playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME),
+                ],
+            });
+            if (loadedPlaywrightJson && userConfiguredJsonReporter) {
+                reportTargets.add(loadedPlaywrightJson.sourcePath);
+            }
+            // Prefer the Donobu reporter's state file (carries the HTML output path
+            // and any Donobu-specific metadata); fall back to the Playwright JSON for
+            // configs that don't wire up the Donobu reporter.
+            const stateReport = await readJsonIfExists(path.join(playwrightOutputDir, model_1.DONOBU_REPORT_STATE_FILENAME));
+            initialDonobuReport =
+                stateReport ?? loadedPlaywrightJson?.data ?? null;
+        }
+        if (triageEnabled && triageContext) {
+            generatedPlans = await postProcessTriageRun(triageContext, playwrightArgs, loadedPlaywrightJson?.sourcePath);
+        }
+        const autoHealOutcome = await attemptAutoHealRun({
+            options: effectiveOptions,
+            playwrightArgs,
+            playwrightOutputDir,
+            generatedPlans,
+            currentExitCode: exitCode,
+            initialReport: initialDonobuReport,
+            initialReportSourcePath: loadedPlaywrightJson?.sourcePath,
+            triageRunDir: triageContext?.runDir,
+            reportTargets: Array.from(reportTargets),
+            userConfiguredJsonReporter,
+        });
+        // When auto-heal was eligible-checked but didn't actually run a rerun (no
+        // actionable directives), nothing downstream re-renders the Slack payload —
+        // deliver the pre-heal payload now so we honor the "one post per run"
+        // guarantee the reporter was deferring for.
+        if (!autoHealOutcome.attempted) {
             await postDeferredSlackFromInitialRun(playwrightOutputDir);
         }
-        return exitCode;
+        return autoHealOutcome.exitCode;
     }
-    // Tests failed and auto-heal is enabled — load the initial report into
-    // memory so we can merge it with the heal-run report later without writing
-    // a redundant copy to disk.
-    let loadedPlaywrightJson = null;
-    let initialDonobuReport = null;
-    if (triageEnabled) {
-        loadedPlaywrightJson = await loadJsonReport(playwrightOutputDir, {
-            envOverrides,
-            additionalCandidates: [
-                path.join(playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME),
-            ],
+    finally {
+        // Clean up the JSON artifacts Donobu created for its own internal use.
+        // Runs after every return path (early-exit when tests pass / auto-heal
+        // disabled, and the post-heal path) so we don't leave the state file or
+        // the force-injected JSON behind. Anything the user actually asked for
+        // (their own JSON reporter target, HTML, Markdown, Slack) is preserved.
+        await cleanupForceInjectedJsonArtifacts({
+            playwrightOutputDir,
+            discoveredJsonPath: discoveredReport,
+            userConfiguredJsonReporter,
         });
-        if (loadedPlaywrightJson) {
-            reportTargets.add(loadedPlaywrightJson.sourcePath);
-        }
-        // Prefer the Donobu reporter's state file (carries the HTML output path
-        // and any Donobu-specific metadata); fall back to the Playwright JSON for
-        // configs that don't wire up the Donobu reporter.
-        const stateReport = await readJsonIfExists(path.join(playwrightOutputDir, model_1.DONOBU_REPORT_STATE_FILENAME));
-        initialDonobuReport =
-            stateReport ?? loadedPlaywrightJson?.data ?? null;
-    }
-    if (triageEnabled && triageContext) {
-        generatedPlans = await postProcessTriageRun(triageContext, playwrightArgs, loadedPlaywrightJson?.sourcePath);
-    }
-    const autoHealOutcome = await attemptAutoHealRun({
-        options: effectiveOptions,
-        playwrightArgs,
-        playwrightOutputDir,
-        generatedPlans,
-        currentExitCode: exitCode,
-        initialReport: initialDonobuReport,
-        initialReportSourcePath: loadedPlaywrightJson?.sourcePath,
-        triageRunDir: triageContext?.runDir,
-        reportTargets: Array.from(reportTargets),
-    });
-    // When auto-heal was eligible-checked but didn't actually run a rerun (no
-    // actionable directives), nothing downstream re-renders the Slack payload —
-    // deliver the pre-heal payload now so we honor the "one post per run"
-    // guarantee the reporter was deferring for.
-    if (!autoHealOutcome.attempted) {
-        await postDeferredSlackFromInitialRun(playwrightOutputDir);
-    }
-    return autoHealOutcome.exitCode;
+    }
 }
 /**
  * When auto-heal was enabled but no rerun happened (tests passed, or no

package/dist/esm/cli/donobu-cli.d.ts

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 declare function hasReporterArg(args: string[]): boolean;
-declare function injectJsonReporterIntoArgs(args: string[]): boolean;
+declare function injectJsonReporterIntoArgs(args: string[]): {
+    /** True when the args contained any `--reporter` / `-r` flag. */
+    reporterFlagFound: boolean;
+    /** True when the user's args already listed `json` — i.e. they configured
+     *  a JSON reporter themselves rather than us force-injecting one. */
+    userHadJson: boolean;
+};
 declare function ensureReporterValueHasJson(value: string): {
     value: string;
     changed: boolean;