scenescout 3.20.1 → 3.20.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # scenescout
 
+## 3.20.2
+
+### Patch Changes
+
+- f8f7ad2: A recorded `scenescout check` (`--record` or `--video`) no longer overwrites a `replay.html` in the output folder that it did not write: it stops before it starts, with exit code 2 and a message naming the file. With `--video`, a video that fails to start no longer stops every later flow from being filmed.
+
 ## 3.20.1
 
 ### Patch Changes

package/dist/check-run.js

@@ -512,6 +512,27 @@ export function clearReplayOutput(outDir) {
     if (fs.readdirSync(root).length === 0)
         fs.rmdirSync(root);
 }
+/**
+ * Why a recorded check (--record or --video) must not start, or null: a
+ * replay.html in the output folder that a check did not write is the
+ * project's own, and is neither removed nor overwritten. Asked before the
+ * browser starts, so the run is not spent first.
+ */
+export function replayPageConflict(outDir) {
+    const page = path.join(outDir, REPLAY_FILE);
+    let text;
+    try {
+        text = fs.readFileSync(page, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+    if (isGeneratedReplay(text))
+        return null;
+    return `${page} is not a page SceneScout wrote, so a recorded check will not overwrite it. Move or rename it, or pass --out to write the check somewhere else`;
+}
 /**
  * The replay page's model for a recorded check, with its frames copied from
  * the browsers' scratch folders to replay-frames/ beside the report: routes

package/dist/cli.js

@@ -21,7 +21,7 @@ import { APPROX_DISK_MB, defaultAttachNote, defaultEngine, launchTarget, parseBr
 import { CLIENT_LABELS, firstMessageHint, manualFor, parseClients, registerWithClient, vscodeBinary } from "./clients.js";
 import { CLAUDE_CODE_NOT_NEEDED, CLI_NAME, desktopExtensionRoots, diagnose, doctorAllGood, findDesktopExtension, installClosing, ensureCommand, findOnUserPath, installSkill, isEphemeralRoot, launchCommand, manualRegisterCommand, planCommand, registerMcp, resolveClaudeDir, spawnRunner, } from "./installer.js";
 import { downloadBrowsers, presentBrowsers } from "./installer.js";
-import { baselinesDirOf, clearReplayOutput, defaultCheckDir, readCheckInputs, runCheck } from "./check-run.js";
+import { baselinesDirOf, clearReplayOutput, replayPageConflict, defaultCheckDir, readCheckInputs, runCheck } from "./check-run.js";
 import { buildCheckReplayHtml, commitOf, REPLAY_FILE, replayFrames, replayVideos } from "./engine/check-replay.js";
 import { recordChoice } from "./engine/capture.js";
 import { httpClient, httpJudgeAsk, runCi } from "./ci-run.js";
@@ -583,6 +583,10 @@ async function check(args) {
     try {
         // --record, else SCENESCOUT_RECORD, else off.
         options = { ...options, record: recordChoice(options.record, process.env) };
+        // A replay.html the project keeps there is its own: a recorded check refuses to start rather than overwrite it.
+        const conflict = options.record || options.video ? replayPageConflict(outDir) : null;
+        if (conflict)
+            throw new Error(conflict);
         // A replay page an earlier run left must never be read, or uploaded, as this run's.
         clearReplayOutput(outDir);
         inputs = readCheckInputs(options);

package/dist/engine/browser.js

@@ -16,6 +16,7 @@ import { extractCreatedIds, isOwnedResource, normalizeId } from "./ownership.js"
 import { formatJourney, journeyTime, measureJourney } from "./journey.js";
 import { describeStep, elementStateMatches, FLOW_AFTER_LAST_STEP_MS, isAction, matchRequest, notActionable, parseTarget, repeatFailure, splitRefusals, TARGET_HELP, urlMatches, } from "./flow.js";
 import { framePath, RECORD_MAX_FRAMES } from "./replay.js";
+import { film } from "./film.js";
 import { InFlightRequests, keepWatchingUrl, normalizePace, SETTLE_TICK_MS, shouldKeepWaiting } from "./settle.js";
 import { crawledRoute, crawlLine, isFileMediaType, isNonPageResource, mainStateFlag, mediaTypeOf } from "./crawl.js";
 import { authToRemember, BODY_FETCH_MAX, buildRequestScript, formatPageRequests, formatReplay, PageRequests, replaySignature, requestHeaders, resolveMethod, resolveRequestUrl, resolveTarget, staleCredentialNote, toReplayResult, wantsView, } from "./request.js";
@@ -1689,30 +1690,11 @@ export class BrowserEngine {
      */
     async filming(videoTo, work) {
         const page = this.requirePage();
-        const why = (err) => (err instanceof Error ? err.message.split("\n")[0] : String(err));
-        let videoError;
-        let filming = false;
-        try {
-            await fs.promises.mkdir(path.dirname(videoTo), { recursive: true });
-            await page.screencast.start({ path: videoTo, ...(page.viewportSize() ? { size: page.viewportSize() } : {}) });
-            filming = true;
-        }
-        catch (err) {
-            videoError = `the video could not be started: ${why(err)}`;
-        }
-        let value;
-        try {
-            value = await work();
-        }
-        finally {
-            // The page the filming began on, even if the work moved the session to a popup.
-            if (filming)
-                await page.screencast.stop().catch((err) => (videoError = `the video could not be saved: ${why(err)}`));
-        }
-        if (videoError)
-            return { value, video: null, videoError };
-        const saved = await fs.promises.stat(videoTo).then((st) => st.size > 0, () => false);
-        return saved ? { value, video: videoTo } : { value, video: null, videoError: "no video was written" };
+        // The page the filming began on is the one stopped, even if the work moved the session to a popup.
+        return film(page.screencast, videoTo, page.viewportSize(), work, {
+            prepare: (file) => fs.promises.mkdir(path.dirname(file), { recursive: true }).then(() => undefined),
+            written: (file) => fs.promises.stat(file).then((st) => st.size > 0, () => false),
+        });
     }
     requirePage() {
         if (!this.page || !this.memory) {

package/dist/engine/film.js

@@ -0,0 +1,41 @@
+/**
+ * Filming one piece of work into a video file (`scenescout check --video`):
+ * start, run the work, stop, and say whether a video was saved. The browser
+ * hands in its page's screencast; nothing here needs Playwright, so the
+ * failure paths are table-tested.
+ */
+const why = (err) => (err instanceof Error ? err.message.split("\n")[0] : String(err));
+/**
+ * Run `work` while `screencast` films it into `videoTo`. The work's own result
+ * and errors are never touched by the filming: a video that cannot be started
+ * or saved is reported in `videoError`, and the work runs regardless.
+ *
+ * A start that fails is followed by a stop, its error ignored: a screencast
+ * left half-started would refuse every later start ("already started"), so
+ * one failure would cost the video of every flow after it.
+ */
+export async function film(screencast, videoTo, size, work, io) {
+    let videoError;
+    let filming = false;
+    try {
+        await io.prepare(videoTo);
+        await screencast.start({ path: videoTo, ...(size ? { size } : {}) });
+        filming = true;
+    }
+    catch (err) {
+        videoError = `the video could not be started: ${why(err)}`;
+        // Whatever the failed start left running is stopped, so the next flow can start afresh; there is nothing to save.
+        await screencast.stop().catch(() => undefined);
+    }
+    let value;
+    try {
+        value = await work();
+    }
+    finally {
+        if (filming)
+            await screencast.stop().catch((err) => (videoError = `the video could not be saved: ${why(err)}`));
+    }
+    if (videoError)
+        return { value, video: null, videoError };
+    return (await io.written(videoTo)) ? { value, video: videoTo } : { value, video: null, videoError: "no video was written" };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scenescout",
-  "version": "3.20.1",
+  "version": "3.20.2",
   "description": "SceneScout — exploratory UI testing for AI coding agents. An MCP server that gives any agent (Claude Code, Cursor, VS Code Copilot, Codex, Gemini CLI and others) a structured view of a running web app, always-on oracles, a network-level write policy, memory across runs and a gap-checked report.",
   "license": "MIT",
   "author": "brunoboto96",