donobu 5.40.0 → 5.41.1

package/dist/esm/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;

package/dist/esm/envVars.d.ts

@@ -74,6 +74,7 @@ export declare const env: Env<{
     AWS_SECRET_ACCESS_KEY: z.ZodOptional<z.ZodString>;
     EXPERIMENTAL_FEATURES_ENABLED: z.ZodDefault<z.ZodBoolean>;
     DONOBU_API_KEY: z.ZodOptional<z.ZodString>;
+    DONOBU_PERSISTENCE_API_KEY: z.ZodOptional<z.ZodString>;
     GOOGLE_CLOUD_STORAGE_BUCKET: z.ZodOptional<z.ZodString>;
     SCREENSHOT_TIMEOUT_MS: z.ZodDefault<z.ZodNumber>;
     SELF_HEAL_TESTS_ENABLED: z.ZodOptional<z.ZodString>;
@@ -127,6 +128,7 @@ export declare const env: Env<{
     AWS_ACCESS_KEY_ID?: string | undefined;
     AWS_SECRET_ACCESS_KEY?: string | undefined;
     DONOBU_API_KEY?: string | undefined;
+    DONOBU_PERSISTENCE_API_KEY?: string | undefined;
     GOOGLE_CLOUD_STORAGE_BUCKET?: string | undefined;
     SELF_HEAL_TESTS_ENABLED?: string | undefined;
     PROXY_SERVER?: string | undefined;

package/dist/esm/envVars.js

@@ -188,6 +188,18 @@ flows. If specified, AWS credentials must also be present.`),
         .optional()
         .describe(`The API key for the Donobu API. Used to create GPT configurations backed
 by the Donobu API, and to persist flows via the Donobu API when set.`),
+    DONOBU_PERSISTENCE_API_KEY: v4_1.z
+        .string()
+        .optional()
+        .describe(`Persistence-only fallback for the Donobu API key. When set, the DONOBU
+persistence layer will instantiate using this key if DONOBU_API_KEY is
+absent — but unlike DONOBU_API_KEY, this value is NOT consulted by
+DonobuFlowsManager.createGptClient's env-var fallback chain.
+
+Intended for hosts (e.g. the Donobu Studio desktop app) that drive AI
+inference through an explicit gpt-config / flow-runner agent and want
+to enable Donobu Cloud persistence without their persistence credential
+silently overriding the user's flow-runner pick.`),
     GOOGLE_CLOUD_STORAGE_BUCKET: v4_1.z.string().optional()
         .describe(`Directs Donobu flows to be persisted using this Google Cloud Storage
 bucket.`),

package/dist/esm/lib/test/utils/donobuTestStack.js

@@ -20,7 +20,7 @@ function getEnvSnapshot() {
 }
 async function getOrCreateDonobuStack() {
     if (!donobuStack) {
-        donobuStack = await (0, DonobuStack_1.setupDonobuStack)('LOCAL', ControlPanel_1.NoOpControlPanelFactory, new EnvPersistenceVolatile_1.EnvPersistenceVolatile(getEnvSnapshot()), envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'));
+        donobuStack = await (0, DonobuStack_1.setupDonobuStack)('LOCAL', ControlPanel_1.NoOpControlPanelFactory, new EnvPersistenceVolatile_1.EnvPersistenceVolatile(getEnvSnapshot()), envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'));
         return donobuStack;
     }
     else {

package/dist/esm/main.d.ts

@@ -6,7 +6,6 @@ export { GptClient } from './clients/GptClient';
 export { type GptClientPlugin, GptClientPluginRegistry, } from './clients/GptClientPlugin';
 export { OpenAiGptClient } from './clients/OpenAiGptClient';
 export { VercelAiGptClient } from './clients/VercelAiGptClient';
-export { runGenerateSiteTests } from './codegen/runGenerateSiteTests';
 export { env } from './envVars';
 export * from './exceptions/DonobuException';
 export * from './exceptions/FlowIdCollisionException';
@@ -105,6 +104,7 @@ export declare function startDonobuServer({ port, controlPanelHost, environ, }?:
         AWS_ACCESS_KEY_ID: z.ZodOptional<z.ZodString>;
         AWS_SECRET_ACCESS_KEY: z.ZodOptional<z.ZodString>;
         DONOBU_API_KEY: z.ZodOptional<z.ZodString>;
+        DONOBU_PERSISTENCE_API_KEY: z.ZodOptional<z.ZodString>;
     }, {
         BASE64_GPT_CONFIG?: string | undefined;
         BROWSERBASE_API_KEY?: string | undefined;
@@ -124,6 +124,7 @@ export declare function startDonobuServer({ port, controlPanelHost, environ, }?:
         AWS_ACCESS_KEY_ID?: string | undefined;
         AWS_SECRET_ACCESS_KEY?: string | undefined;
         DONOBU_API_KEY?: string | undefined;
+        DONOBU_PERSISTENCE_API_KEY?: string | undefined;
     }> | undefined;
 }): Promise<void>;
 //# sourceMappingURL=main.d.ts.map

package/dist/esm/main.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TargetRuntimePluginRegistry = exports.PersistencePluginRegistry = exports.shutdownFileUploadWorkers = exports.getFileUploadAggregateStatus = exports.createDefaultToolRegistry = exports.ToolManager = exports.PluginLoader = exports.InteractionVisualizer = exports.setupDonobuStack = exports.prepareToolCallsForRerun = exports.DonobuFlowsManager = exports.distillAllowedEnvVariableNames = exports.DonobuFlow = exports.AdminApiController = exports.env = exports.runGenerateSiteTests = exports.VercelAiGptClient = exports.OpenAiGptClient = exports.GptClientPluginRegistry = exports.GptClient = exports.GoogleGenerativeAiGptClient = exports.fixAssertFields = exports.DonobuGptClient = exports.AnthropicGptClient = void 0;
+exports.TargetRuntimePluginRegistry = exports.PersistencePluginRegistry = exports.shutdownFileUploadWorkers = exports.getFileUploadAggregateStatus = exports.createDefaultToolRegistry = exports.ToolManager = exports.PluginLoader = exports.InteractionVisualizer = exports.setupDonobuStack = exports.prepareToolCallsForRerun = exports.DonobuFlowsManager = exports.distillAllowedEnvVariableNames = exports.DonobuFlow = exports.AdminApiController = exports.env = exports.VercelAiGptClient = exports.OpenAiGptClient = exports.GptClientPluginRegistry = exports.GptClient = exports.GoogleGenerativeAiGptClient = exports.fixAssertFields = exports.DonobuGptClient = exports.AnthropicGptClient = void 0;
 exports.startDonobuServer = startDonobuServer;
 const commander_1 = require("commander");
 const v4_1 = require("zod/v4");
@@ -39,8 +39,6 @@ var OpenAiGptClient_1 = require("./clients/OpenAiGptClient");
 Object.defineProperty(exports, "OpenAiGptClient", { enumerable: true, get: function () { return OpenAiGptClient_1.OpenAiGptClient; } });
 var VercelAiGptClient_1 = require("./clients/VercelAiGptClient");
 Object.defineProperty(exports, "VercelAiGptClient", { enumerable: true, get: function () { return VercelAiGptClient_1.VercelAiGptClient; } });
-var runGenerateSiteTests_1 = require("./codegen/runGenerateSiteTests");
-Object.defineProperty(exports, "runGenerateSiteTests", { enumerable: true, get: function () { return runGenerateSiteTests_1.runGenerateSiteTests; } });
 var envVars_2 = require("./envVars");
 Object.defineProperty(exports, "env", { enumerable: true, get: function () { return envVars_2.env; } });
 __exportStar(require("./exceptions/DonobuException"), exports);
@@ -113,7 +111,7 @@ const DEFAULT_PORT = 31000;
  * Starts a Donobu API server at the given port. The server assumes that the
  * Playwright browsers have been installed.
  */
-async function startDonobuServer({ port = DEFAULT_PORT, controlPanelHost = ControlPanel_1.NoOpControlPanelFactory, environ = envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_DEPLOYMENT_ENVIRONMENT', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'), } = {}) {
+async function startDonobuServer({ port = DEFAULT_PORT, controlPanelHost = ControlPanel_1.NoOpControlPanelFactory, environ = envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_DEPLOYMENT_ENVIRONMENT', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY'), } = {}) {
     try {
         const adminController = await AdminApiController_1.AdminApiController.create(environ.data.DONOBU_DEPLOYMENT_ENVIRONMENT ?? 'LOCAL', controlPanelHost, environ);
         await adminController.start(port);

package/dist/esm/managers/AdminApiController.d.ts

@@ -59,7 +59,7 @@ export declare class AdminApiController {
      * - no checking for flow ownership is performed, as all flows are considered owned by the
      *   local environment.
      */
-    static create(donobuDeploymentEnvironment: DonobuDeploymentEnvironment, controlPanelFactory: ControlPanelFactory, environ: EnvPick<typeof env, 'ANTHROPIC_API_KEY' | 'ANTHROPIC_MODEL_NAME' | 'AWS_ACCESS_KEY_ID' | 'AWS_BEDROCK_MODEL_NAME' | 'AWS_SECRET_ACCESS_KEY' | 'BASE64_GPT_CONFIG' | 'BROWSERBASE_API_KEY' | 'BROWSERBASE_PROJECT_ID' | 'DONOBU_API_BASE_URL' | 'DONOBU_API_KEY' | 'GOOGLE_GENERATIVE_AI_API_KEY' | 'GOOGLE_GENERATIVE_AI_MODEL_NAME' | 'OLLAMA_API_URL' | 'OLLAMA_MODEL_NAME' | 'OPENAI_API_KEY' | 'OPENAI_API_MODEL_NAME' | 'PERSISTENCE_PRIORITY'>): Promise<AdminApiController>;
+    static create(donobuDeploymentEnvironment: DonobuDeploymentEnvironment, controlPanelFactory: ControlPanelFactory, environ: EnvPick<typeof env, 'ANTHROPIC_API_KEY' | 'ANTHROPIC_MODEL_NAME' | 'AWS_ACCESS_KEY_ID' | 'AWS_BEDROCK_MODEL_NAME' | 'AWS_SECRET_ACCESS_KEY' | 'BASE64_GPT_CONFIG' | 'BROWSERBASE_API_KEY' | 'BROWSERBASE_PROJECT_ID' | 'DONOBU_API_BASE_URL' | 'DONOBU_API_KEY' | 'DONOBU_PERSISTENCE_API_KEY' | 'GOOGLE_GENERATIVE_AI_API_KEY' | 'GOOGLE_GENERATIVE_AI_MODEL_NAME' | 'OLLAMA_API_URL' | 'OLLAMA_MODEL_NAME' | 'OPENAI_API_KEY' | 'OPENAI_API_MODEL_NAME' | 'PERSISTENCE_PRIORITY'>): Promise<AdminApiController>;
     private constructor();
     /**
      * Binds the API/web-asset server to `port` and resolves once the socket is

package/dist/esm/managers/DonobuStack.d.ts

@@ -60,6 +60,7 @@ export declare function setupDonobuStack(donobuDeploymentEnvironment: DonobuDepl
     AWS_ACCESS_KEY_ID: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
     AWS_SECRET_ACCESS_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
     DONOBU_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+    DONOBU_PERSISTENCE_API_KEY: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
 }, {
     BASE64_GPT_CONFIG?: string | undefined;
     BROWSERBASE_API_KEY?: string | undefined;
@@ -78,5 +79,6 @@ export declare function setupDonobuStack(donobuDeploymentEnvironment: DonobuDepl
     AWS_ACCESS_KEY_ID?: string | undefined;
     AWS_SECRET_ACCESS_KEY?: string | undefined;
     DONOBU_API_KEY?: string | undefined;
+    DONOBU_PERSISTENCE_API_KEY?: string | undefined;
 }>): Promise<DonobuStack>;
 //# sourceMappingURL=DonobuStack.d.ts.map

package/dist/esm/managers/DonobuStack.js

@@ -33,7 +33,7 @@ const ToolRegistry_1 = require("./ToolRegistry");
  *       then having this snapshot is relevant so that tests can use normal
  *       environment variables.
  */
-async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory, envPersistenceVolatile, environ = envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY')) {
+async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory, envPersistenceVolatile, environ = envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_API_BASE_URL', 'DONOBU_API_KEY', 'DONOBU_PERSISTENCE_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OLLAMA_API_URL', 'OLLAMA_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY')) {
     const loadedPlugins = await loadDefaultPlugins();
     const resolvedToolRegistry = await (0, ToolRegistry_1.createDefaultToolRegistry)(loadedPlugins.tools);
     const persistencePlugins = new PersistencePlugin_1.PersistencePluginRegistry(loadedPlugins.persistencePlugins);

package/dist/esm/managers/TestsManager.js

@@ -174,8 +174,11 @@ class TestsManager {
             try {
                 await persistence.deleteTest(testId);
             }
-            catch {
-                // Ignore errors from layers that don't have this test.
+            catch (e) {
+                // Ignore TestNotFoundException errors from layers that don't have this test.
+                if (!(e instanceof TestNotFoundException_1.TestNotFoundException)) {
+                    throw e;
+                }
             }
         }
         // Cascade-delete flows belonging to this test. Paginate through all flows

package/dist/esm/persistence/DonobuApiClient.js

@@ -24,7 +24,7 @@ class DonobuApiClient {
     async jsonRequest(path, method, body) {
         return this.request(path, {
             method,
-            headers: { 'Content-Type': 'application/json' },
+            headers: body !== undefined ? { 'Content-Type': 'application/json' } : {},
             body: body !== undefined ? JSON.stringify(body) : undefined,
         });
     }