donobu 5.41.0 → 5.41.1

package/dist/cli/donobu-cli.js

@@ -309,14 +309,23 @@ const noopAsync = async () => { };
  * wrapper config when necessary so we can append the JSON reporter alongside
  * user-specified reporters.
  */
-async function ensureJsonReporter(originalArgs, options = {}) {
+async function ensureJsonReporter(originalArgs, options) {
     const args = [...originalArgs];
+    // For branches that don't use the config wrapper, the JSON reporter has no
+    // explicit `outputFile` and Playwright falls back to env vars — which we set
+    // in applyJsonReportEnv to (playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME).
+    // Either honour an explicit override or reconstruct that path here.
+    const envDerivedJsonOutputFile = options.jsonOutputFile ??
+        path.join(options.playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME);
     const argInjection = injectJsonReporterIntoArgs(args);
     if (argInjection.reporterFlagFound) {
         return {
             args,
             cleanup: noopAsync,
-            resolveUserConfiguredJson: async () => argInjection.userHadJson,
+            resolveJsonReporterInfo: async () => ({
+                userHadJson: argInjection.userHadJson,
+                jsonOutputFile: envDerivedJsonOutputFile,
+            }),
         };
     }
     const configPath = await resolvePlaywrightConfigPath(args);
@@ -332,17 +341,22 @@ async function ensureJsonReporter(originalArgs, options = {}) {
         return {
             args,
             cleanup: noopAsync,
-            resolveUserConfiguredJson: async () => false,
+            resolveJsonReporterInfo: async () => ({
+                userHadJson: false,
+                jsonOutputFile: envDerivedJsonOutputFile,
+            }),
         };
     }
-    const wrapper = await createConfigWrapperWithJsonReporter(configPath, options);
+    const wrapper = await createConfigWrapperWithJsonReporter(configPath, {
+        jsonOutputFile: options.jsonOutputFile,
+    });
     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, wrapper.configPath);
     return {
         args: finalArgs,
         cleanup: wrapper.cleanup,
-        resolveUserConfiguredJson: wrapper.resolveUserConfiguredJson,
+        resolveJsonReporterInfo: wrapper.resolveJsonReporterInfo,
     };
 }
 function hasReporterArg(args) {
@@ -499,18 +513,26 @@ async function createConfigWrapperWithJsonReporter(originalConfigPath, options =
     // 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 () => {
+    const resolveJsonReporterInfo = async () => {
         try {
             const raw = await fs_1.promises.readFile(sentinelPath, 'utf8');
-            return raw.trim() === '1';
+            const parsed = JSON.parse(raw);
+            return {
+                userHadJson: parsed?.userHadJson === true,
+                jsonOutputFile: typeof parsed?.jsonOutputFile === 'string' &&
+                    parsed.jsonOutputFile.length > 0
+                    ? parsed.jsonOutputFile
+                    : null,
+            };
         }
         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;
+            // Sentinel missing or malformed (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 { userHadJson: false, jsonOutputFile: null };
         }
     };
-    return { configPath: wrapperPath, cleanup, resolveUserConfiguredJson };
+    return { configPath: wrapperPath, cleanup, resolveJsonReporterInfo };
 }
 function buildConfigWrapperContent(originalConfigPath, userHadJsonSentinelPath, jsonOutputFileOverride) {
     const sanitisedPath = originalConfigPath.replace(/\\/g, '\\\\');
@@ -622,6 +644,17 @@ const reporters = Array.isArray(normalizedConfig.reporter)
   ? [normalizedConfig.reporter]
   : [];
 
+function computeEnvDerivedJsonOutputFile() {
+  const outputDir = process.env.PLAYWRIGHT_JSON_OUTPUT_DIR
+    ? path.resolve(process.cwd(), process.env.PLAYWRIGHT_JSON_OUTPUT_DIR)
+    : path.resolve(configDir, 'test-results');
+  const outputName =
+    process.env.PLAYWRIGHT_JSON_OUTPUT_NAME || '${defaultJsonName}';
+  return path.isAbsolute(outputName)
+    ? outputName
+    : path.join(outputDir, outputName);
+}
+
 const hasJsonReporter = reporters.some((entry) => {
   if (!entry) {
     return false;
@@ -640,30 +673,11 @@ 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 ||
-    (() => {
-      const outputDir = process.env.PLAYWRIGHT_JSON_OUTPUT_DIR
-        ? path.resolve(process.cwd(), process.env.PLAYWRIGHT_JSON_OUTPUT_DIR)
-        : path.resolve(configDir, 'test-results');
-      const outputName =
-        process.env.PLAYWRIGHT_JSON_OUTPUT_NAME || '${defaultJsonName}';
-      return path.isAbsolute(outputName)
-        ? outputName
-        : path.join(outputDir, outputName);
-    })();
-  reporters.push(['json', { outputFile }]);
+  reporters.push([
+    'json',
+    { outputFile: forcedJsonOutputFile || computeEnvDerivedJsonOutputFile() },
+  ]);
 }
 
 // Resolve a reporter name to an absolute path so that Playwright can find it
@@ -729,6 +743,57 @@ const normalisedReporters = reporters.map((entry) => {
   return entry;
 });
 
+// Walk the final reporter list to surface the JSON output path the orchestrator
+// should treat as the merge target — Playwright's JSON reporter accepts the
+// path via either reporter options or env var, so checking both keeps us in
+// sync with whatever Playwright will actually do.
+function extractJsonOutputFile(rep) {
+  for (const entry of rep) {
+    if (Array.isArray(entry) && entry[0] === 'json') {
+      if (
+        entry[1] &&
+        typeof entry[1] === 'object' &&
+        typeof entry[1].outputFile === 'string'
+      ) {
+        return entry[1].outputFile;
+      }
+      return computeEnvDerivedJsonOutputFile();
+    }
+    if (typeof entry === 'string') {
+      const segments = entry
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+      for (const segment of segments) {
+        const eqIndex = segment.indexOf('=');
+        const name = eqIndex === -1 ? segment : segment.slice(0, eqIndex);
+        const value = eqIndex === -1 ? '' : segment.slice(eqIndex + 1);
+        if (name === 'json') {
+          return value ? absolutify(value) : computeEnvDerivedJsonOutputFile();
+        }
+      }
+    }
+  }
+  return null;
+}
+
+// Tell the parent orchestrator (a) whether the user's own config defined a
+// JSON reporter and (b) the exact path that JSON will land at. The path lets
+// the orchestrator merge auto-heal results onto the user's file directly,
+// without filesystem-scanning heuristics that can pick the wrong file.
+try {
+  require('fs').writeFileSync(
+    userHadJsonSentinelPath,
+    JSON.stringify({
+      userHadJson: hasJsonReporter,
+      jsonOutputFile: extractJsonOutputFile(normalisedReporters),
+    }),
+    'utf8',
+  );
+} catch (_) {
+  // Non-fatal — the orchestrator falls back to "no user JSON" if missing.
+}
+
 module.exports = {
   ...normalizedConfig,
   reporter: normalisedReporters,
@@ -767,65 +832,6 @@ async function copyJsonReport(outputDir, destinationPath, options = {}) {
     }
     return null;
 }
-/**
- * Locate the canonical Playwright JSON report and read it into memory.
- * Uses the same candidate-resolution logic as {@link copyJsonReport} but
- * avoids writing a duplicate file to disk.
- */
-async function loadJsonReport(outputDir, options = {}) {
-    const candidatePaths = new Set();
-    const envDefinedPath = resolveEnvJsonReportPath(options.envOverrides);
-    if (envDefinedPath) {
-        candidatePaths.add(envDefinedPath);
-    }
-    candidatePaths.add(path.join(outputDir, PLAYWRIGHT_JSON_REPORT_FILENAME));
-    (options.additionalCandidates ?? []).forEach((candidate) => {
-        if (candidate) {
-            candidatePaths.add(candidate);
-        }
-    });
-    for (const sourcePath of candidatePaths) {
-        const data = await readJsonIfExists(sourcePath);
-        if (data) {
-            return { sourcePath, data };
-        }
-    }
-    const fallbackSource = await findJsonReportInDir(outputDir);
-    if (fallbackSource) {
-        const data = await readJsonIfExists(fallbackSource);
-        if (data) {
-            return { sourcePath: fallbackSource, data };
-        }
-    }
-    return null;
-}
-/**
- * Resolve the canonical Playwright JSON report path without reading or
- * copying. Uses the same candidate-resolution order as {@link loadJsonReport}.
- */
-async function findJsonReportPath(outputDir, options = {}) {
-    const candidatePaths = new Set();
-    const envDefinedPath = resolveEnvJsonReportPath(options.envOverrides);
-    if (envDefinedPath) {
-        candidatePaths.add(envDefinedPath);
-    }
-    candidatePaths.add(path.join(outputDir, PLAYWRIGHT_JSON_REPORT_FILENAME));
-    (options.additionalCandidates ?? []).forEach((candidate) => {
-        if (candidate) {
-            candidatePaths.add(candidate);
-        }
-    });
-    for (const candidate of candidatePaths) {
-        try {
-            await fs_1.promises.access(candidate, fs_1.constants.F_OK);
-            return candidate;
-        }
-        catch {
-            // not found, try next
-        }
-    }
-    return findJsonReportInDir(outputDir);
-}
 function resolveEnvJsonReportPath(envOverrides) {
     if (!envOverrides) {
         return null;
@@ -859,6 +865,16 @@ async function tryCopyReport(sourcePath, destinationPath) {
         return false;
     }
 }
+/** Files we write into the Playwright output dir ourselves. They happen to
+ *  share `suites`-shaped JSON with Playwright's own report, so the scan
+ *  fallback must exclude them or it can pick our own state file (or a
+ *  previous heal-run copy) as the "user's JSON report". */
+function isDonobuInternalJsonFile(fileName) {
+    return (fileName === model_1.DONOBU_REPORT_STATE_FILENAME ||
+        fileName.startsWith('donobu-auto-heal-report-') ||
+        fileName.startsWith('donobu-heal-report-') ||
+        fileName === 'donobu-heal-merged-report.json');
+}
 async function findJsonReportInDir(outputDir) {
     let entries;
     try {
@@ -869,6 +885,7 @@ async function findJsonReportInDir(outputDir) {
     }
     const candidates = entries
         .filter((entry) => entry.endsWith('.json'))
+        .filter((entry) => !isDonobuInternalJsonFile(entry))
         .sort((a, b) => {
         const aScore = a.includes('report') ? 0 : 1;
         const bScore = b.includes('report') ? 0 : 1;
@@ -895,18 +912,6 @@ async function isLikelyPlaywrightReport(filePath) {
         return false;
     }
 }
-async function overwriteReportTargets(sourcePath, targets) {
-    const uniqueTargets = Array.from(new Set(targets)).filter((target) => target && target !== sourcePath);
-    await Promise.all(uniqueTargets.map(async (targetPath) => {
-        try {
-            await ensureDirectory(path.dirname(targetPath));
-            await fs_1.promises.copyFile(sourcePath, targetPath);
-        }
-        catch (error) {
-            Logger_1.appLogger.warn(`Failed to copy merged Playwright report to ${targetPath}.`, error);
-        }
-    }));
-}
 /**
  * Remove the JSON artifacts Donobu wrote purely for its own use:
  *
@@ -924,8 +929,8 @@ 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);
+    if (!params.userHadJson && params.jsonOutputFile) {
+        targets.push(params.jsonOutputFile);
     }
     await Promise.all(targets.map(async (target) => {
         try {
@@ -1331,6 +1336,7 @@ async function attemptAutoHealRun(params) {
         const healJsonReportPath = path.join(staging.playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME);
         const reporterSetup = await ensureJsonReporter(healArgsForRun, {
             jsonOutputFile: healJsonReportPath,
+            playwrightOutputDir: staging.playwrightOutputDir,
         });
         try {
             healExitCode = await runPlaywright(reporterSetup.args, envOverrides);
@@ -1343,7 +1349,7 @@ async function attemptAutoHealRun(params) {
         // 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
+        const healReportCopy = params.userJsonOutputFile
             ? await copyJsonReport(staging.playwrightOutputDir, path.join(params.playwrightOutputDir, `donobu-auto-heal-report-${Date.now()}.json`), {
                 envOverrides,
                 additionalCandidates: [healJsonReportPath],
@@ -1377,19 +1383,18 @@ 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 user's primary JSON target
+            // Write the merged report directly to the user's JSON reporter 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];
+            // `userJsonOutputFile` is null — 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 mergedReport = await mergePlaywrightJsonReports({
                 initialReport: params.initialReport ?? null,
                 initialReportSourcePath: params.initialReportSourcePath,
                 healReport,
                 healReportSourcePath: healReportCopy?.destinationPath ?? undefined,
-                mergedReportPath: primaryTarget,
+                mergedReportPath: params.userJsonOutputFile ?? undefined,
                 healedTests: evaluation.eligiblePlans.map((record) => ({
                     plan: record.plan,
                     testCase: record.evidence.failureContext.testCase,
@@ -1398,11 +1403,6 @@ async function attemptAutoHealRun(params) {
                 outputDir: params.playwrightOutputDir,
                 triageRunDir: params.triageRunDir,
             });
-            // Copy to any remaining report targets (skip the primary — already
-            // written there).
-            if (mergedReport && primaryTarget && params.reportTargets.length > 1) {
-                await overwriteReportTargets(primaryTarget, params.reportTargets.slice(1));
-            }
             if (mergedReport) {
                 await regenerateDonobuReports(mergedReport);
                 await writeAutoHealPullRequestBody(mergedReport, params.playwrightOutputDir);
@@ -1772,38 +1772,26 @@ async function runTestCommand(cliArgs) {
     if (effectiveOptions.autoHeal) {
         envOverrides.DONOBU_AUTO_HEAL_ORCHESTRATED = '1';
     }
-    const reporterSetup = await ensureJsonReporter(playwrightArgs);
+    const reporterSetup = await ensureJsonReporter(playwrightArgs, {
+        playwrightOutputDir,
+    });
     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;
+    let jsonReporterInfo = {
+        userHadJson: false,
+        jsonOutputFile: null,
+    };
     try {
         exitCode = await runPlaywright(runArgs, envOverrides);
         // Read before cleanup, since the wrapper-sentinel lives in the staging dir.
-        userConfiguredJsonReporter =
-            await reporterSetup.resolveUserConfiguredJson();
+        jsonReporterInfo = await reporterSetup.resolveJsonReporterInfo();
     }
     finally {
         await reporterSetup.cleanup();
     }
+    const { userHadJson, jsonOutputFile } = jsonReporterInfo;
     let generatedPlans = [];
-    const reportTargets = new Set();
-    // Discover the canonical report path eagerly (cheap — no file read) so we
-    // 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 && userConfiguredJsonReporter) {
-        reportTargets.add(discoveredReport);
-    }
     try {
         if (exitCode === 0 || !effectiveOptions.autoHeal) {
             // Auto-heal wasn't attempted (either tests passed or the user disabled
@@ -1815,29 +1803,20 @@ async function runTestCommand(cliArgs) {
             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;
+        // memory so we can merge it with the heal-run report later. Prefer the
+        // Donobu reporter's state file (carries Donobu-specific metadata like the
+        // HTML output path); fall back to reading the user's JSON file directly.
         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;
+                stateReport ??
+                    (jsonOutputFile
+                        ? await readJsonIfExists(jsonOutputFile)
+                        : null);
         }
         if (triageEnabled && triageContext) {
-            generatedPlans = await postProcessTriageRun(triageContext, playwrightArgs, loadedPlaywrightJson?.sourcePath);
+            generatedPlans = await postProcessTriageRun(triageContext, playwrightArgs, jsonOutputFile ?? undefined);
         }
         const autoHealOutcome = await attemptAutoHealRun({
             options: effectiveOptions,
@@ -1846,10 +1825,9 @@ async function runTestCommand(cliArgs) {
             generatedPlans,
             currentExitCode: exitCode,
             initialReport: initialDonobuReport,
-            initialReportSourcePath: loadedPlaywrightJson?.sourcePath,
+            initialReportSourcePath: jsonOutputFile ?? undefined,
             triageRunDir: triageContext?.runDir,
-            reportTargets: Array.from(reportTargets),
-            userConfiguredJsonReporter,
+            userJsonOutputFile: userHadJson ? jsonOutputFile : null,
         });
         // When auto-heal was eligible-checked but didn't actually run a rerun (no
         // actionable directives), nothing downstream re-renders the Slack payload —
@@ -1868,8 +1846,8 @@ async function runTestCommand(cliArgs) {
         // (their own JSON reporter target, HTML, Markdown, Slack) is preserved.
         await cleanupForceInjectedJsonArtifacts({
             playwrightOutputDir,
-            discoveredJsonPath: discoveredReport,
-            userConfiguredJsonReporter,
+            userHadJson,
+            jsonOutputFile,
         });
     }
 }
@@ -1971,6 +1949,7 @@ async function runHealCommand(cliArgs) {
     const healJsonReportPath = path.join(playwrightOutputDir, PLAYWRIGHT_JSON_REPORT_FILENAME);
     const reporterSetup = await ensureJsonReporter(healArgsWithDirectives, {
         jsonOutputFile: healJsonReportPath,
+        playwrightOutputDir,
     });
     Logger_1.appLogger.debug(`Heal command Playwright args: ${JSON.stringify(reporterSetup.args)} with env overrides ${JSON.stringify(envOverrides)}`);
     let exitCode;