reshoot 0.3.0__tar.gz → 0.3.2__tar.gz

{reshoot-0.3.0 → reshoot-0.3.2}/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "reshoot",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Agent skills to create, refresh and review software demo videos. Use the reshoot CLI to record the app, export an MP4 and README GIF, and keep the demo source beside the code.",
   "author": { "name": "Mumit Khan", "url": "https://github.com/mumit" },
   "homepage": "https://github.com/mumit/reshoot",

reshoot-0.3.2/CHANGELOG.md

@@ -0,0 +1,93 @@
+# Changelog
+
+Each release names what changed for people making demos. Versions follow
+[semantic versioning](https://semver.org/); before 1.0, a minor version may
+change project files or commands.
+
+## 0.3.2 (2026-10-23)
+
+### Added
+
+- A `select` action chooses a dropdown option by its value or visible label,
+  and `reshoot rec` writes one for each dropdown choice.
+
+### Fixed
+
+- A result could appear a whole hold late in the video while every check passed: the evidence screenshot after
+  each beat could take the frame showing it. The evidence frame is now the last frame the video shows, saved at
+  the end of the hold. Frame times also no longer depend on when the first frame arrives.
+- Storyboard errors name the beat and the action or check, such as
+  `beat 'fill', action 2 (key): target needs exactly one of css, test_id, or role`.
+- The demo skill says to narrow the viewport or zoom when an app's content is
+  too small to read in the README GIF.
+- A port Chrome refuses, such as 5060, is explained with the flag that allows
+  it, and a failure while opening the page no longer reports `beat None`.
+- The demo skill and guides say how to write checks for apps that keep data
+  between takes and have no reset.
+
+## 0.3.1 (2026-10-23)
+
+### Added
+
+- `reshoot accept RUN` records the owner's verdict in one step: the exports,
+  every beat, every scan item and the scan checklist, bound to the run's exact
+  files and scan policy. Each flagged item must be named with `--flagged`, and
+  `--reject` marks an item that must not be shared. It asks for confirmation,
+  and without a terminal it refuses unless given `--yes`.
+- `reshoot run` and `reshoot preview` write the review page and print the
+  `reshoot accept` command for the run.
+- `reshoot runs PROJECT` lists a project's runs, newest first, with their
+  result and review status. Run paths accept `latest` (the newest successful
+  run) and `accepted` (the newest accepted run), such as `demo/accepted`.
+  Run reports record `finished_at`.
+- A refresh pull request in CI. `examples/github/refresh.yml` records the demo
+  when the app changes, compares it with the accepted run and opens a pull
+  request with the new MP4, GIF and a beat table. Merging it accepts the
+  recording.
+- `reshoot accept` writes `demo/accepted/`, a small committed record of the run
+  (report, beat results and evidence frames), so CI and fresh clones can
+  compare against it. `reshoot export --record DIR` writes one for any run.
+- `reshoot export --replace` updates media already in the destination, and
+  `reshoot compare --markdown FILE` writes a summary for a pull request.
+- In GitHub Actions, each run writes a job summary with its checks, scan and
+  errors.
+
+### Fixed
+
+- `reshoot init` moves the notes example off port 8765 when something else
+  is using it.
+- A busy port names its loopback address instead of a redacted hash.
+- `reshoot web --help` describes TOML storyboards, and `review`, `compare`
+  and `export` explain their arguments.
+- A target that matches no element, or several, names the target and the count.
+- A run's report includes the failed beat's error, not only the failed step.
+
+## 0.3.0 (2026-10-23)
+
+The first release on PyPI. Install it with `uv tool install 'reshoot[browser]'`.
+
+### Added
+
+- Published to PyPI, with a release workflow that builds, checks and publishes
+  each tagged version.
+- An agent-first entry point: a first-demo prompt in the README, the agent
+  quickstart and a skill catalog.
+- Guides for each stage after the first recording: features, customizing,
+  fuller demos and tutorials, publishing, CI and faster shoots.
+
+### Fixed
+
+- Review pages show baseline GIFs as images; MP4s keep their video players.
+- Joined title cards no longer vanish or freeze in GIF exports.
+- Clip joins keep an exact frame rate.
+- Captions stay visible across same-origin page loads.
+- Previews that mix web and VHS takes keep matching dimensions.
+- Runs leave incomplete expectations unverified instead of passing them.
+- `doctor` rejects a `RESHOOT_CHROME` that does not name a usable browser.
+
+## 0.2.0
+
+Repeatable demo projects: `reshoot.toml`, TOML storyboards with checked
+expectations, `init`, `doctor`, `preview`, isolated versioned runs, `compare`,
+`review` with bound decisions, `export`, and shared Claude Code and Codex skills
+installed by `reshoot skills`. Installed from Git only.

{reshoot-0.3.0 → reshoot-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: reshoot
-Version: 0.3.0
+Version: 0.3.2
 Summary: Agent skills and recording tools for repeatable software demo videos
 Project-URL: Homepage, https://github.com/mumit/reshoot
 Project-URL: Documentation, https://github.com/mumit/reshoot/tree/main/guide
@@ -182,8 +182,9 @@ takes outside it. Select an explicit baseline when comparing updates.
 
 Native demos keep their capture instructions and edit script separately; see
 the [macOS window workflow](https://github.com/mumit/reshoot/blob/main/guide/macos-window.md).
-Use the [CI workflow](https://github.com/mumit/reshoot/blob/main/guide/ci.md) to record browser and terminal candidates after
-app changes. Review the outputs before updating published demo media.
+The [CI workflow](https://github.com/mumit/reshoot/blob/main/guide/ci.md) records the demo again when the app changes and
+opens a pull request with the new video, GIF and a beat-by-beat comparison with
+the accepted run. Merging it accepts the new recording.
 
 ## Choose the recording for the task
 

{reshoot-0.3.0 → reshoot-0.3.2}/README.md

@@ -153,8 +153,9 @@ takes outside it. Select an explicit baseline when comparing updates.
 
 Native demos keep their capture instructions and edit script separately; see
 the [macOS window workflow](guide/macos-window.md).
-Use the [CI workflow](guide/ci.md) to record browser and terminal candidates after
-app changes. Review the outputs before updating published demo media.
+The [CI workflow](guide/ci.md) records the demo again when the app changes and
+opens a pull request with the new video, GIF and a beat-by-beat comparison with
+the accepted run. Merging it accepts the new recording.
 
 ## Choose the recording for the task
 

{reshoot-0.3.0 → reshoot-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reshoot"
-version = "0.3.0"
+version = "0.3.2"
 description = "Agent skills and recording tools for repeatable software demo videos"
 dynamic = ["readme"]
 license = "MIT"

{reshoot-0.3.0 → reshoot-0.3.2}/skills/check-privacy/SKILL.md

@@ -34,6 +34,10 @@ keeps a face, a name or a house number out of a public video.
    bytes, so the next round shows only what's new.
 6. Repeat until `reshoot check` says everything has been checked.
 
+For a versioned run, `reshoot accept RUN` replaces steps 4 and 5 when this CLI provides it: it records the scan
+checklist and the recording verdict together, and needs each flagged label named with `--flagged` or `--reject`.
+The person runs it, or tells you explicitly to.
+
 ## What fails an image
 
 - A person: faces, heads at the edge of the frame, tiny figures far away, reflections in glass, people behind

{reshoot-0.3.0 → reshoot-0.3.2}/skills/keep-current/SKILL.md

@@ -38,4 +38,4 @@ description: Set up a reshoot.toml so one command (`reshoot run`) records a proj
 
 The run report and Action outputs distinguish `scan_status` and `review_status`. `ok=true` means execution completed, not approval to publish. A required check error stops the run, and the app remains available until its URL-based checks finish.
 
-Versioned runs keep separate candidate files. Compare two explicit runs with `reshoot compare OLD NEW --out FILE`, then generate `reshoot review NEW --previous OLD`. Matching beat IDs do not imply matching results. No new run promotes itself to the baseline.
+For a versioned project (`schema_version = 1`), use `../../examples/github/refresh.yml` instead of the legacy workflow above. Accept a run locally first and commit the `demo/accepted/` record that `reshoot accept` writes; the workflow compares each new run with it, copies the new media to `docs/demo/` and opens a pull request whose merge accepts the recording. Changing repository settings, pushing, and merging are the person's call. Versioned runs keep separate candidate files. Compare two explicit runs with `reshoot compare OLD NEW --out FILE`, then generate `reshoot review NEW --previous OLD`. Matching beat IDs do not imply matching results. No new run promotes itself to the baseline.

{reshoot-0.3.0 → reshoot-0.3.2}/skills/reshoot-demo/SKILL.md

@@ -15,13 +15,13 @@ For a new browser project, use `reshoot init DIR --url DEMO_URL`; omit `--url` t
 
 For a native macOS app, save a brief, capture recipe and edit script in a demo folder. Use `reshoot window --list` to select the exact demo window, then `reshoot window APP NEW_TAKE.mov --id ID -s SECONDS`. Check Screen Recording permission for the command's host. Drive the app through app-specific automation or coordinate the owner's interaction during capture; the window command does not operate controls. Look up the ID each take and choose unused output paths. Versioned projects support web and VHS, not native window takes. Do not invent a native run manifest, browser overlay or result assertions. Export with `reshoot edit EDIT.toml NEW_TAKE.mov`, using numeric cuts, and a GIF export profile, or a Python edit. The primary skill can follow this route without supporting plugin skills.
 
-Use made-up data in a separate account, folder, or database. Document and run its reset before each take. Record only a headless browser page, VHS terminal, or one macOS window by ID. Never capture the whole screen or reuse a person's browser profile.
+Use made-up data in a separate account, folder, or database. Document and run its reset before each take. When a running app keeps data and offers no reset, ask for one before the first take, or write checks that pass however many times the task has run: check the item the take created, not totals that earlier takes change. Record only a headless browser page, VHS terminal, or one macOS window by ID. Never capture the whole screen or reuse a person's browser profile.
 
-For browser/VHS projects, run `reshoot preview CONFIG`, inspect frames and expected results, then `reshoot run CONFIG`. Read the printed run report. For native apps, inspect a standalone test take, then capture and edit a fresh final in a new folder. Generate check sheets for source and final media with `reshoot check SOURCES --full --review NEW_REVIEW_DIR`. Inspect actual outputs on either route. Execution success does not mean a scan passed or a person reviewed the video. When the owner wants a quicker refresh of checked data, follow the trade-offs in the guide's `speed.md` and say which checks were reduced; agent-written terminal text always needs reading. Fix failed inputs and actions rather than suppressing checks. Give the owner the final files and pending review items.
+For browser/VHS projects, run `reshoot preview CONFIG`, inspect frames and expected results, then `reshoot run CONFIG`. Read the printed run report. For native apps, inspect a standalone test take, then capture and edit a fresh final in a new folder. Generate check sheets for source and final media with `reshoot check SOURCES --full --review NEW_REVIEW_DIR`. Inspect actual outputs on either route. Execution success does not mean a scan passed or a person reviewed the video. When the owner wants a quicker refresh of checked data, follow the trade-offs in the guide's `speed.md` and say which checks were reduced; agent-written terminal text always needs reading. Fix failed inputs and actions rather than suppressing checks. Give the owner the final files and pending review items. For a versioned run, if this CLI provides `reshoot accept`, the run prints the command that records the owner's verdict; pass it on with `--flagged LABEL` for each flagged item. Run it, or pass `--yes`, only when the owner explicitly asks you to accept.
 
 For combined web and VHS edits, configure matching take dimensions. Mixed previews retain the browser's configured dimensions because VHS keeps its tape dimensions.
 
-Keep captions short and explain the result, not the click. Leave time to read. Identify mocked responses or shortened waits. Do not change the product claim merely to make a recording finish.
+Keep captions short and explain the result, not the click. Leave time to read. Judge text size in the README GIF, which is usually 800 px wide: when the app's content is a narrow column in the 1280x720 frame, set a narrower `size`, such as `"960x540"`, or `zoom = true`, so the result stays readable. A narrower viewport enlarges the text; a higher pixel ratio does not. For a dropdown, use a `select` action with the option's visible label, if this CLI supports it, rather than key presses. Identify mocked responses or shortened waits. Do not change the product claim merely to make a recording finish.
 
 Inspect captions after page navigation. The overlay restores the current caption on same-origin page loads; zoomed or styled captions are drawn after recording.
 

{reshoot-0.3.0 → reshoot-0.3.2}/skills/reshoot-refresh/SKILL.md

@@ -7,7 +7,7 @@ description: Update an existing reshoot demo after an app or release changes. Us
 
 For combined web and VHS edits, keep take dimensions matched. Mixed previews retain the configured browser dimensions to match the unchanged VHS output size.
 
-Requires reshoot CLI 0.2 or newer. Run `reshoot --version`. For a versioned browser/VHS project, read its brief, config, storyboard and previous run before changing anything, then run `reshoot doctor --config CONFIG`.
+Requires reshoot CLI 0.2 or newer. Run `reshoot --version`. For a versioned browser/VHS project, read its brief, config, storyboard and previous run before changing anything, then run `reshoot doctor --config CONFIG`. If this CLI provides `reshoot runs`, use it to list runs; a run path ending in `accepted` or `latest` resolves to the newest accepted or successful run. Record the exact ID of the baseline you compare against, since aliases move as new runs finish.
 
 For a standalone native recording, read the brief, capture/edit scripts and exact previous media instead of expecting a versioned config or run report. Look up the current demo window ID, reset synthetic data, and use `reshoot window APP NEW_TAKE.mov --id ID -s SECONDS` with app-specific automation or coordinated manual interaction. Keep test and fresh final takes in new folders; edit and scan final exports. Compare the old/new MP4s and animated GIFs manually. Disclose that browser assertions, versioned `preview`/`run`, and automated beat comparison do not apply. Follow the versioned flow below only for browser/VHS projects.
 
@@ -19,4 +19,4 @@ A failed or missing browser take leaves the overall expectations unverified unle
 
 If this CLI version provides `reshoot compare`, compare the previous and new runs by beat and inspect the actual frames. Otherwise, show the old and new recordings and disclose that comparison is manual. A successful run must not silently replace the chosen comparison baseline or inherit approval from it.
 
-Use only made-up data and page, terminal, or single-window capture. Call out changes to the story's claim, fixture meaning, speed, or narration. Present the new files and unresolved items. Publishing and repository changes follow the owner's existing authorization.
+Use only made-up data and page, terminal, or single-window capture. Call out changes to the story's claim, fixture meaning, speed, or narration. Present the new files and unresolved items. The new run needs its own verdict: give the owner its `reshoot accept RUN` command when this CLI provides it, and do not run it without their explicit instruction. Publishing and repository changes follow the owner's existing authorization.

{reshoot-0.3.0 → reshoot-0.3.2}/skills/reshoot-review/SKILL.md

@@ -19,7 +19,7 @@ For a versioned run, if this CLI provides `reshoot review`, use its local page t
 Previous and current GIFs display as images in the comparison page; inspect their
 animation and loop as well as the MP4 playback.
 
-The owner decides whether a recording is accepted. Do not run `check --ok`, import approval, or promote a baseline merely because your inspection found nothing. Carry out those actions when the owner explicitly authorizes the decision. Give the owner the files, evidence, and unresolved findings; do not publish without authorization.
+The owner decides whether a recording is accepted. For a versioned run, if this CLI provides `reshoot accept`, give the owner the exact command: `reshoot accept RUN`, plus `--flagged LABEL` for each flagged item they must inspect, or `--reject LABEL` for one that fails. Do not run `accept`, `check --ok` or an import, pass `--yes`, or promote a baseline merely because your inspection found nothing. Carry out those actions only when the owner explicitly authorizes the decision. Give the owner the files, evidence, and unresolved findings; do not publish without authorization.
 
 `check --text-file FINAL.srt` scans exact caption text. Runs also check generated
 subtitle and narration sidecars. Inspect text findings at their recorded cue times.

{reshoot-0.3.0 → reshoot-0.3.2}/src/reshoot/browser.py

@@ -37,8 +37,9 @@ async def action(page, entry, events, root):
     if kind == 'wait':
         await item.wait_for(state='visible', timeout=timeout)
         return
-    if await item.count() != 1:
-        raise ValueError('action target must match exactly one element')
+    if (found := await item.count()) != 1:
+        target = ', '.join(f'{k} = {v!r}' for k, v in entry['target'].items())
+        raise ValueError(f'{kind} target {{{target}}} matched {found} elements; it must match exactly one')
     await item.scroll_into_view_if_needed(timeout=timeout)
     box = await item.bounding_box()
     rect = [box[k] for k in ('x', 'y', 'width', 'height')] if box else None
@@ -52,6 +53,9 @@ async def action(page, entry, events, root):
         if entry.get('clear', True):
             await item.fill('', timeout=timeout)
         await item.press_sequentially(entry['text'], delay=65, timeout=timeout)
+    elif kind == 'select':
+        await page.wait_for_timeout(250)  # let the cursor rest on the control before the choice changes
+        await item.select_option(entry['option'], timeout=timeout)
     elif kind == 'key':
         await item.press(entry['key'], timeout=timeout)
     elif kind == 'upload':
@@ -59,6 +63,19 @@ async def action(page, entry, events, root):
     events.append((time.monotonic(), {'kind': 'act', 'phase': 'end', 'rect': rect}))
 
 
+async def evidence(page, frames, shot):
+    """Save the beat's evidence: the last frame the video shows, at the end of its hold. A screenshot taken during
+    capture can take the frame that shows a result, and a still page sends no other, so the video would show the old
+    page through the whole hold."""
+    last = frames[-1][1] if len(frames) else None
+    if last is not None:
+        import io
+        from PIL import Image
+        Image.open(io.BytesIO(last)).save(shot)
+    else:
+        await page.screenshot(path=str(shot))
+
+
 async def assertion(page, entry):
     from playwright.async_api import expect
     kind = entry['type']
@@ -150,11 +167,12 @@ async def capture(board, a, frames, out, metadata, spoken):
                        'mobile': bool(a.mobile or board.get('mobile')), 'screenWidth': w, 'screenHeight': h,
                        'dontSetVisibleSize': False})
         async def frame(event):
-            nonlocal clock
-            timestamp = event['metadata']['timestamp']
-            if clock is None:
-                clock = time.monotonic() - timestamp
-            frames.append((timestamp + clock, base64.b64decode(event['data'])))
+            # Chrome stamps each frame with the wall-clock time it was painted. Map that onto the beats' clock with
+            # an offset measured directly, not from when a frame arrives: large frames arrive late, and an offset
+            # taken from a late first frame would shift the whole video behind the actions.
+            timestamp = event['metadata'].get('timestamp')
+            painted = timestamp + clock if timestamp else time.monotonic()
+            frames.append((painted, base64.b64decode(event['data'])))
             await cdp.send('Page.screencastFrameAck', {'sessionId': event['sessionId']})
         frame_tasks = []
         frame_handler = lambda event: frame_tasks.append(asyncio.create_task(frame(event)))
@@ -172,6 +190,7 @@ async def capture(board, a, frames, out, metadata, spoken):
                     await assertion(page, entry)
             metadata['replayed_before'] = ids[:split]
             events.clear()
+            clock = time.monotonic() - time.time()
             await cdp.send('Page.startScreencast', {'format': 'jpeg', 'quality': 92, 'maxWidth': int(w*cap_dpr), 'maxHeight': int(h*cap_dpr)})
             for beat in board['beat'][split:]:
                 current = beat['id']
@@ -195,10 +214,10 @@ async def capture(board, a, frames, out, metadata, spoken):
                 result.update(verified_at=time.monotonic(), trim_wait=bool(beat.get('trim_wait')), min_reading=max(beat.get('min_reading', 0), board.get('caption', {}).get('min_seconds', 0)))
                 shot = out.parent / (out.stem + '.evidence') / (current + '.png')
                 shot.parent.mkdir(exist_ok=True)
-                await page.screenshot(path=str(shot))
                 result.update(status='passed' if beat.get('expect') else 'unverified', screenshot=str(shot.relative_to(out.parent)), start=start)
                 await asyncio.sleep(max(beat.get('hold', 1), beat.get('min_reading', 0), board.get('caption', {}).get('min_seconds', 0) if beat.get('caption') else 0, spoken.get(current, ('', 0))[1] + .3 - (time.monotonic() - start)))
                 result['end'] = time.monotonic()
+                await evidence(page, frames, shot)
             stop = time.monotonic()
             await cdp.send('Page.stopScreencast')
             cdp.remove_listener('Page.screencastFrame', frame_handler)
@@ -220,7 +239,12 @@ async def capture(board, a, frames, out, metadata, spoken):
                 metadata['failure_screenshot'] = str(failure.relative_to(out.parent))
             except Exception:
                 pass
-            raise RuntimeError(f'beat {current!r} failed: {redact(str(e))}') from None
+            where = f'beat {current!r}' if current else 'opening the storyboard url'
+            hint = ''
+            if 'ERR_UNSAFE_PORT' in str(e):
+                hint = ('. Chrome refuses some ports, such as 5060 and 6000: run the app on another port, or set '
+                        'RESHOOT_CHROME_FLAGS=--explicitly-allowed-ports=PORT')
+            raise RuntimeError(f'{where} failed: {redact(str(e))}{hint}') from None
         finally:
             cdp.remove_listener('Page.screencastFrame', frame_handler)
             page.remove_listener('response', resource_handler)

{reshoot-0.3.0 → reshoot-0.3.2}/src/reshoot/check.py

@@ -252,7 +252,8 @@ def perform(a, report):
         for label, flags in flagged.items():
             print(f"  {label}  {key[label][0]}: " + "; ".join(f"{why} {part}" for why, part in flags))
     print(f"{len(key)} frames, images, or text findings not checked yet, on {(len(todo) + 3) // 4} sheets in {review}/. Look at each one "
-          "at full size, then run `reshoot check --fail LABEL...` for any that fail and `reshoot check --ok`.")
+          "at full size. For a run, record the verdict with `reshoot accept RUN`; for these sheets alone, run "
+          "`reshoot check --fail LABEL...` for any that fail and `reshoot check --ok`.")
     return 1
 
 

{reshoot-0.3.0 → reshoot-0.3.2}/src/reshoot/cli.py

@@ -8,9 +8,10 @@ def main(argv=None):
     ap.add_argument("--version", action="version", version=version("reshoot"))
     sub = ap.add_subparsers(dest="cmd", required=True)
 
-    from reshoot import web, window, check
+    from reshoot import web, window, check, story
     p = sub.add_parser("web", help="record a web page acting out a storyboard, in headless Chrome",
-                       description=web.__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+                       description=story.__doc__ + "\nLegacy Python storyboards\n\n" + web.__doc__,
+                       formatter_class=argparse.RawDescriptionHelpFormatter)
     p.add_argument("storyboard"); p.add_argument("out", help="the video to write, such as takes/web.mp4")
     p.add_argument("--url", help="the page to open (default: the storyboard's URL)")
     p.add_argument("--size", help="CSS width x height @ device pixel ratio, such as 390x844@3 (default 1280x720@1.5)")
@@ -95,15 +96,46 @@ def main(argv=None):
     p.add_argument('--directory', default='.', help='project root receiving the skill bundle')
     p.set_defaults(run=skills.install)
     from reshoot import review
-    p = sub.add_parser('compare', help='compare matching beat IDs between two explicit runs')
-    p.add_argument('previous'); p.add_argument('current'); p.add_argument('--out')
+    runs = ('A run is its folder, such as demo/takes/runs/ID. End the path with `latest` for the newest successful '
+            'run or `accepted` for the newest accepted one, such as demo/latest.')
+    p = sub.add_parser('runs', help='list a project\'s runs, newest first, with their result and review status',
+                       description='List the runs of a versioned project, newest first. ' + runs)
+    p.add_argument('project', nargs='?', default='.', help='the project folder or its reshoot.toml (default: here)')
+    p.set_defaults(run=review.listing)
+    p = sub.add_parser('compare', help='compare matching beat IDs between two explicit runs',
+                       description='Compare two runs beat by beat: which beat IDs match, and whether each beat\'s '
+                       'definition, duration, evidence frame and results changed. A matched ID does not mean equal '
+                       'pixels. ' + runs)
+    p.add_argument('previous', help='the earlier run, usually the accepted one')
+    p.add_argument('current', help='the run to compare against it')
+    p.add_argument('--out', help='write the comparison JSON here instead of printing it')
+    p.add_argument('--markdown', metavar='FILE', help='also write a short Markdown summary, such as for a pull request')
     p.set_defaults(run=lambda a: (review.compare(a), 0)[1])
-    p = sub.add_parser('review', help='create a local review page or import owner decisions')
-    p.add_argument('run_path'); p.add_argument('--previous'); p.add_argument('--import-decisions')
+    p = sub.add_parser('review', help='create a local review page or import owner decisions',
+                       description='Write RUN/review.html: the exports, each beat\'s result and evidence, and the scan '
+                       'items, with a comparison when --previous is given. Runs write this page themselves; use this to '
+                       'add a comparison or rebuild it. ' + runs)
+    p.add_argument('run_path', help='the run to review')
+    p.add_argument('--previous', help='an earlier run to compare against, usually the accepted one')
+    p.add_argument('--import-decisions', metavar='FILE',
+                   help='record per-beat decisions downloaded from the page; `reshoot accept` is the one-step route')
     p.set_defaults(run=review.main)
-    p = sub.add_parser('export', help='copy explicitly chosen run media to a local directory')
-    p.add_argument('run_path'); p.add_argument('--directory', required=True)
-    p.add_argument('--file', action='append')
+    p = sub.add_parser('accept', help='accept a run after watching it: exports, beats and scan items in one step',
+                       description='Accept a run after watching its exports and looking at its scan sheets. Unflagged '
+                       'items are accepted together; each flagged item must be named with --flagged or --reject. The '
+                       'verdict is bound to the run\'s exact files and scan policy.')
+    p.add_argument('run_path', help='the run folder, such as demo/takes/runs/ID or demo/latest')
+    p.add_argument('--flagged', nargs='+', metavar='LABEL', help='flagged items you inspected and accept')
+    p.add_argument('--reject', nargs='+', metavar='LABEL', help='items that must not be shared; marks the run failed')
+    p.add_argument('--yes', action='store_true', help='skip the confirmation; only for the owner\'s own scripts')
+    p.set_defaults(run=review.accept)
+    p = sub.add_parser('export', help='copy explicitly chosen run media to a local directory', description=runs)
+    p.add_argument('run_path', help='the run to copy from, such as demo/latest')
+    p.add_argument('--directory', help='where to copy the chosen --file media')
+    p.add_argument('--file', action='append', help='a file listed in run.json, such as takes/demo-final.mp4')
+    p.add_argument('--replace', action='store_true', help='overwrite media already in --directory, such as the repo\'s demo')
+    p.add_argument('--record', metavar='DIR', help='also write the run\'s small record (report, beat results, evidence '
+                   'frames) to DIR, such as demo/accepted, for later comparisons')
     p.set_defaults(run=project.export)
     a = ap.parse_args(argv)
     try:

{reshoot-0.3.0 → reshoot-0.3.2}/src/reshoot/project.py

@@ -56,8 +56,11 @@ def init(a):
     if conflicts:
         raise ValueError('existing files would be overwritten: ' + ', '.join(conflicts))
     root.mkdir(parents=True, exist_ok=True)
+    port = None if a.url else free_port()
     for name in names:
         text = template.joinpath(name).read_text()
+        if port:
+            text = text.replace('8765', str(port))
         if a.url:
             if name == 'storyboard.toml':
                 text = 'schema_version = 1\nurl = ' + json.dumps(a.url) + '\n[[beat]]\nid = "intro"\ncaption = "Replace this with one useful task"\nhold = 2\n'
@@ -69,19 +72,39 @@ def init(a):
     return 0
 
 
+def free_port():
+    """8765 if nothing is using it, otherwise any free local port, so the notes example doesn't collide with another app."""
+    import socket
+    for port in (8765, 0):
+        with socket.socket() as s:
+            try:
+                s.bind(('127.0.0.1', port))
+            except OSError:
+                continue
+            return s.getsockname()[1]
+
+
 def export(a):
-    from reshoot.review import read
+    from reshoot.review import read, record
     root, report = read(a.run_path)
     selected = a.file or []
+    if not selected and not getattr(a, 'record', None):
+        raise ValueError('choose at least one --file from run.json files, or --record')
+    if selected and not a.directory:
+        raise ValueError('--file needs --directory')
+    if getattr(a, 'record', None):
+        print(record(root, report, a.record))
     if not selected:
-        raise ValueError('choose at least one --file from run.json files')
+        return 0
     known = {item['path'] for item in report.get('files', [])}
     if not set(selected) <= known:
         raise ValueError('export names an artifact not recorded in this run')
     destination = Path(a.directory).resolve()
     targets = [destination / Path(name).name for name in selected]
-    if len(set(targets)) != len(targets) or any(p.exists() for p in targets):
-        raise ValueError('export would overwrite a file or collide with another selected name')
+    if len(set(targets)) != len(targets):
+        raise ValueError('export would collide with another selected name')
+    if not getattr(a, 'replace', False) and any(p.exists() for p in targets):
+        raise ValueError('export would overwrite a file; pass --replace to update media already there')
     if any(p.suffix not in ('.mp4', '.gif', '.srt', '.mov', '.png') for p in targets):
         raise ValueError('export accepts final media and subtitle files')
     destination.mkdir(parents=True, exist_ok=True)

{reshoot-0.3.0 → reshoot-0.3.2}/src/reshoot/rec.js

@@ -74,7 +74,12 @@
     send({ kind: "key", key: ev.key, where: locate(ev.target) });
   }, true);
   addEventListener("change", ev => {
-    if (ev.isTrusted && ev.target.matches('select,input[type=checkbox],input[type=radio]'))
+    if (!ev.isTrusted) return;
+    const e = ev.target;
+    // A dropdown choice replays as a select action, found by the option's visible label.
+    if (e.matches("select:not([multiple])") && e.selectedOptions.length)
+      send({ kind: "select", where: locate(e), option: e.selectedOptions[0].label });
+    else if (e.matches("select,input[type=checkbox],input[type=radio]"))
       send({kind: "unsupported-change"});
   }, true);
   addEventListener("drop", ev => { if (ev.isTrusted) send({kind: "unsupported-drop"}); }, true);

{reshoot-0.3.0 → reshoot-0.3.2}/src/reshoot/rec.py

@@ -51,6 +51,11 @@ def steps_from(calls, include_tab=False):
                               secret=ev.get("secret")))
         elif kind == "click":
             steps.append(dict(start=t, verb="click", where=ev["where"]))
+        elif kind == "select":
+            if last and last["verb"] == "click" and last["where"] == ev["where"]:
+                steps.pop()  # the click that opened the dropdown; select replays the whole choice
+                t = last["start"]
+            steps.append(dict(start=t, verb="select", where=ev["where"], option=ev["option"]))
         elif kind == "key" and ev["key"] in (("Enter", "Escape", "Tab") if include_tab else ("Enter", "Escape")):
             steps.append(dict(start=t, verb="key", where=ev["where"], key=ev["key"]))
         elif kind == "scroll":
@@ -153,7 +158,7 @@ def main(a):
 
 
 def write_toml(path, url, size, calls):
-    unsupported = [ev['kind'] for _, ev in calls if ev['kind'] not in ('click', 'type', 'key', 'scroll')]
+    unsupported = [ev['kind'] for _, ev in calls if ev['kind'] not in ('click', 'type', 'select', 'key', 'scroll')]
     if unsupported:
         raise ValueError('recording includes unsupported interactions: ' + ', '.join(sorted(set(unsupported))))
     lines = ['schema_version = 1', 'url = ' + json.dumps(url), 'size = ' + json.dumps(size)]
@@ -173,6 +178,8 @@ def write_toml(path, url, size, calls):
         if step['verb'] == 'type':
             value = 'demo-password' if step.get('secret') else step['value']
             lines += ['text = ' + json.dumps(value), 'clear = true']
+        elif step['verb'] == 'select':
+            lines += ['option = ' + json.dumps(step['option'])]
         elif step['verb'] == 'key':
             lines += ['key = ' + json.dumps(step['key'])]
         elif step['verb'] == 'scroll':