browser-workspace 0.4.2 → 0.4.5

package/src/browser_harness/video_render.py

@@ -1,524 +0,0 @@
-#!/usr/bin/env python3
-"""Prepare compact renderer review sheets, then export and verify an MP4."""
-
-from __future__ import annotations
-
-import contextlib
-import json
-import math
-import os
-import shutil
-import subprocess
-import sys
-import threading
-import time
-from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
-from pathlib import Path
-
-from PIL import Image, ImageDraw, ImageFont, ImageOps
-
-from . import video
-
-
-TEMPLATE = Path(__file__).with_name("video-template.html")
-MARKER = "__BH_VIDEO_RESULT__="
-REVIEW_ARTIFACTS = {
-    "composition.js",
-    "recording-summary.json",
-    "edit-brief.json",
-    video.SOURCE_MANIFEST,
-    "video.html",
-}
-OBSOLETE_REVIEW_FILES = {
-    "privacy-contact-sheet.jpg",
-    "renderer-normal-contact-sheet.jpg",
-    "renderer-reduced-contact-sheet.jpg",
-    "renderer-click-contact-sheet.jpg",
-    "video-audit.json",
-}
-
-
-def load_composition(recording: Path) -> dict:
-    return video.load_composition(recording / "composition.js")
-
-
-def compile_recording(recording: Path, write: bool) -> dict:
-    video.verify_source_manifest(recording)
-    summary = video.load_json(recording / "recording-summary.json")
-    brief = video.load_json(recording / "edit-brief.json")
-    composition = video.compile_brief(
-        summary, brief, video.HOUSE_STYLE, video.load_revealed_text(recording / "events.jsonl")
-    )
-    if write:
-        video.write_composition(recording / "composition.js", composition)
-    return composition
-
-
-def review_samples(comp: dict) -> list[dict]:
-    """One stable state per beat, plus every explanation reveal."""
-    samples = []
-    start = 0.0
-    for index, beat in enumerate(comp.get("beats") or [], 1):
-        duration = float(beat.get("dur") or 0)
-        if beat.get("kind") == "explanation" and beat.get("points"):
-            points = beat["points"]
-            first, final_hold = 1.1, 3.0
-            span = max(0.0, duration - first - final_hold)
-            gap = span / max(1, len(points) - 1)
-            for point_index, point in enumerate(points, 1):
-                local = min(max(0.05, duration - 0.05), first + (point_index - 1) * gap + 0.2)
-                samples.append({
-                    "time": round(start + local, 3),
-                    "label": f"beat {index} · {point.get('label') or point_index}",
-                })
-        else:
-            local = min(max(0.05, duration - 0.05), 1.0 if beat.get("card") else max(0.12, min(0.5, duration / 2)))
-            samples.append({"time": round(start + local, 3), "label": f"beat {index}"})
-        start += duration
-    return samples
-
-
-class _QuietHandler(SimpleHTTPRequestHandler):
-    def log_message(self, _format, *_args):
-        pass
-
-
-@contextlib.contextmanager
-def serve(recording: Path):
-    handler = lambda *args, **kwargs: _QuietHandler(  # noqa: E731
-        *args, directory=str(recording), **kwargs
-    )
-    server = ThreadingHTTPServer(("127.0.0.1", 0), handler)
-    thread = threading.Thread(target=server.serve_forever, daemon=True)
-    thread.start()
-    try:
-        yield f"http://127.0.0.1:{server.server_port}/video.html"
-    finally:
-        server.shutdown()
-        server.server_close()
-        thread.join(timeout=2)
-
-
-def _harness_command() -> list[str]:
-    return [sys.executable, "-m", "browser_harness.run"]
-
-
-def run_harness(code: str, timeout: float = 60) -> dict:
-    env = {**os.environ, "BH_RECORD": "0"}
-    proc = subprocess.run(
-        _harness_command(),
-        input=code,
-        text=True,
-        capture_output=True,
-        env=env,
-        timeout=timeout,
-        check=False,
-    )
-    if proc.returncode:
-        detail = (proc.stderr or proc.stdout).strip()
-        raise RuntimeError(f"browser review failed: {detail}")
-    for line in reversed(proc.stdout.splitlines()):
-        if line.startswith(MARKER):
-            return json.loads(line[len(MARKER):])
-    raise RuntimeError(f"browser review returned no result: {proc.stdout[-1000:]}")
-
-
-def _review_browser(recording: Path, url: str, samples: list[dict]) -> dict:
-    review_dir = recording / ".renderer-review"
-    payload = {
-        "url": url,
-        "samples": samples,
-        "reviewDir": str(review_dir),
-        "marker": MARKER,
-    }
-    code = f"""
-import json, os, time
-cfg = json.loads({json.dumps(json.dumps(payload))})
-os.makedirs(cfg['reviewDir'], exist_ok=True)
-
-def ready():
-    for _ in range(100):
-        if js('window.videoReady && window.videoReady()'):
-            return
-        time.sleep(0.05)
-    raise RuntimeError('video assets did not become ready')
-
-def inspect_mode(name, reduced):
-    features = [{{'name':'prefers-reduced-motion','value':'reduce'}}] if reduced else []
-    cdp('Emulation.setEmulatedMedia', media='', features=features)
-    cdp('Page.reload', ignoreCache=True)
-    wait_for_load()
-    ready()
-    preflight = js('window.videoPreflight()')
-    clicks = js('window.clickVisibility()')
-    captures = []
-    for index, sample in enumerate(cfg['samples'], 1):
-        js(f"window.seek({{sample['time']}})")
-        path = f"{{cfg['reviewDir']}}/{{name}}-beat-{{index:02d}}.png"
-        capture_screenshot(path)
-        captures.append({{'path': path, 'time': sample['time'], 'label': sample['label']}})
-    click_captures = []
-    for index, click in enumerate(clicks, 1):
-        for state, key in (('click', 'time'), ('result', 'resultTime')):
-            js(f"window.seek({{click[key]}})")
-            path = f"{{cfg['reviewDir']}}/{{name}}-click-{{index:02d}}-{{state}}.png"
-            capture_screenshot(path)
-            click_captures.append({{
-                'path': path, 'time': click[key],
-                'label': f"beat {{click['beat']}} · {{state}}",
-            }})
-    return {{'preflight': preflight, 'clicks': clicks, 'captures': captures,
-            'clickCaptures': click_captures}}
-
-try:
-    previous = current_tab()['targetId']
-except Exception:
-    previous = None
-target = None
-try:
-    target = new_tab()
-    goto_url(cfg['url'])
-    wait_for_load()
-    ready()
-    normal = inspect_mode('normal', False)
-    reduced = inspect_mode('reduced', True)
-    print(cfg['marker'] + json.dumps({{'normal': normal, 'reduced': reduced}}))
-finally:
-    try:
-        cdp('Emulation.setEmulatedMedia', media='', features=[])
-    except Exception:
-        pass
-    try:
-        switch_tab(previous) if previous else new_tab()
-    except Exception:
-        try:
-            new_tab()
-        except Exception:
-            pass
-    if target is not None:
-        try:
-            close_tab(target)
-        except Exception:
-            pass
-"""
-    return run_harness(code, timeout=max(60, len(samples) * 3))
-
-
-def contact_sheet(captures: list[dict], output: Path, title: str) -> None:
-    cols, tile_w, tile_h, label_h, gap, banner = 4, 400, 225, 34, 8, 42
-    rows = max(1, math.ceil(len(captures) / cols))
-    sheet = Image.new(
-        "RGB",
-        (cols * tile_w + (cols + 1) * gap, banner + rows * (tile_h + label_h + gap) + gap),
-        "#171a20",
-    )
-    draw, font = ImageDraw.Draw(sheet), ImageFont.load_default()
-    draw.text((gap, 15), title, fill="#ffffff", font=font)
-    for index, capture in enumerate(captures):
-        image = Image.open(capture["path"]).convert("RGB")
-        preview = ImageOps.contain(image, (tile_w, tile_h), Image.Resampling.LANCZOS)
-        col, row = index % cols, index // cols
-        x, y = gap + col * (tile_w + gap), banner + gap + row * (tile_h + label_h + gap)
-        sheet.paste(preview, (x + (tile_w - preview.width) // 2, y))
-        label = f"{capture['label']}  {float(capture['time']):.2f}s"
-        draw.text((x, y + tile_h + 9), label, fill="#d7dbe3", font=font)
-    sheet.save(output, quality=91)
-
-
-def masked_frame(recording: Path, comp: dict, frame: str) -> Image.Image:
-    viewport = comp["viewport"]
-    vw, vh = float(viewport["w"]), float(viewport["h"])
-    redactions = comp.get("redact") or {}
-    privacy = comp.get("privacy") or {}
-    mask = privacy.get("mask") or {}
-    pad = float(privacy.get("pad") or 8)
-    image = Image.open(recording / frame).convert("RGB")
-    sx, sy = image.width / vw, image.height / vh
-    draw = ImageDraw.Draw(image)
-    for rectangle in redactions.get(frame, []):
-        rect_pad = float(rectangle.get("pad", pad))
-        x0 = max(0, (float(rectangle["x"]) - rect_pad) * sx)
-        y0 = max(0, (float(rectangle["y"]) - rect_pad) * sy)
-        x1 = min(image.width, (float(rectangle["x"]) + float(rectangle["w"]) + rect_pad) * sx)
-        y1 = min(image.height, (float(rectangle["y"]) + float(rectangle["h"]) + rect_pad) * sy)
-        fill = rectangle.get("fill", mask.get("fill", "#f2f4f7"))
-        stroke = rectangle.get("stroke", mask.get("stroke", "#e2e7ec"))
-        radius = float(rectangle.get("radius", mask.get("radius", 7))) * min(sx, sy)
-        draw.rounded_rectangle(
-            (x0, y0, x1, y1), radius=radius, fill=fill,
-            outline=stroke or None, width=max(1, round(min(sx, sy))),
-        )
-    return image
-
-
-def privacy_review(recording: Path, comp: dict) -> tuple[Path, list[dict]]:
-    review_dir = recording / ".privacy-review"
-    review_dir.mkdir(exist_ok=True)
-    for stale in review_dir.glob("*.jpg"):
-        stale.unlink()
-    captures = []
-    redactions = comp.get("redact") or {}
-    for frame in video.used_frames(comp):
-        source = recording / frame
-        if not source.is_file():
-            raise RuntimeError(f"missing frame: {frame}")
-        output = review_dir / frame
-        masked_frame(recording, comp, frame).save(output, quality=94)
-        captures.append(
-            {
-                "path": str(output),
-                "time": 0,
-                "label": f"privacy · {frame} · masks:{len(redactions.get(frame, []))}",
-            }
-        )
-    return review_dir, captures
-
-
-def review(recording: Path) -> int:
-    started = time.monotonic()
-    for name in OBSOLETE_REVIEW_FILES:
-        (recording / name).unlink(missing_ok=True)
-    comp = compile_recording(recording, write=True)
-    shutil.copy2(TEMPLATE, recording / "video.html")
-    privacy_dir, privacy_captures = privacy_review(recording, comp)
-    samples = review_samples(comp)
-    review_dir = recording / ".renderer-review"
-    review_dir.mkdir(exist_ok=True)
-    for stale in review_dir.glob("*.png"):
-        stale.unlink()
-    with serve(recording) as url:
-        result = _review_browser(recording, url, samples)
-
-    errors = []
-    warnings = []
-    all_captures = list(privacy_captures)
-    for mode in ("normal", "reduced"):
-        errors.extend(f"{mode}: {error}" for error in result[mode]["preflight"].get("errors", []))
-        warnings.extend(
-            f"{mode}: {warning}"
-            for warning in result[mode]["preflight"].get("warnings", [])
-        )
-        errors.extend(
-            f"{mode}: beat {click['beat']} click is outside the safe viewport"
-            for click in result[mode]["clicks"] if not click.get("visible")
-        )
-        for capture in result[mode]["captures"]:
-            all_captures.append({**capture, "label": f"{mode} · {capture['label']}"})
-        for capture in result[mode]["clickCaptures"]:
-            all_captures.append({**capture, "label": f"{mode} · {capture['label']}"})
-
-    sheet = recording / "video-review-contact-sheet.jpg"
-    contact_sheet(all_captures, sheet, "PRIVACY · EVERY BEAT · EXACT CLICK + RESULT")
-
-    report = {
-        "errors": errors,
-        "warnings": warnings,
-        "duration": round(sum(float(beat.get("dur") or 0) for beat in comp.get("beats") or []), 3),
-        "artifactHashes": {
-            name: video.file_hash(recording / name) for name in sorted(REVIEW_ARTIFACTS)
-        },
-        "normal": result["normal"],
-        "reduced": result["reduced"],
-        "contactSheet": str(sheet),
-        "privacyReviewDir": str(privacy_dir),
-        "elapsedSeconds": round(time.monotonic() - started, 3),
-    }
-    report_path = recording / "renderer-review.json"
-    report_path.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
-    print(f"review sheet: {sheet}")
-    print(f"full-resolution privacy review: {privacy_dir}")
-    print(f"renderer review: {len(errors)} error(s) in {report['elapsedSeconds']:.1f}s")
-    return 1 if errors else 0
-
-
-def _start_export(recording: Path, url: str, webm: Path) -> dict:
-    webm.parent.mkdir(parents=True, exist_ok=True)
-    payload = {"url": url, "downloadPath": str(webm.parent.resolve()), "filename": webm.name, "marker": MARKER}
-    filename_js = json.dumps(webm.name)
-    code = f"""
-import json, time
-cfg = json.loads({json.dumps(json.dumps(payload))})
-try:
-    previous = current_tab()['targetId']
-except Exception:
-    previous = None
-target = new_tab()
-goto_url(cfg['url'])
-wait_for_load()
-for _ in range(100):
-    if js('window.videoReady && window.videoReady()'):
-        break
-    time.sleep(0.05)
-else:
-    raise RuntimeError('video assets did not become ready')
-preflight = js('window.videoPreflight()')
-clicks = js('window.clickVisibility()')
-cdp('Browser.setDownloadBehavior', behavior='allow', downloadPath=cfg['downloadPath'], eventsEnabled=True)
-cdp('Page.bringToFront')
-started = js('''(() => {{
-  window.__exported = null; window.__exportError = null;
-  window.exportVideo({filename_js})
-    .catch(error => window.__exportError = String(error));
-  return true;
-}})()''')
-print(cfg['marker'] + json.dumps({{'target': target, 'previous': previous, 'preflight': preflight, 'clicks': clicks, 'started': started}}))
-"""
-    return run_harness(code, timeout=30)
-
-
-def _close_editor(url: str, previous: str | None = None) -> bool:
-    payload = {"url": url, "previous": previous, "marker": MARKER}
-    code = f"""
-import json
-cfg = json.loads({json.dumps(json.dumps(payload))})
-downloads_reset = True
-try:
-    cdp('Browser.setDownloadBehavior', behavior='default', eventsEnabled=False)
-except Exception:
-    downloads_reset = False
-targets = [tab for tab in list_tabs() if tab.get('url') == cfg['url']]
-try:
-    switch_tab(cfg['previous']) if cfg.get('previous') else new_tab()
-except Exception:
-    new_tab()
-for tab in targets:
-    try:
-        close_tab(tab)
-    except Exception:
-        pass
-print(cfg['marker'] + json.dumps({{'closed': True, 'downloadsReset': downloads_reset}}))
-"""
-    try:
-        result = run_harness(code, timeout=15)
-    except Exception:
-        return False
-    return result.get("downloadsReset") is True
-
-
-def _run(command: list[str], cwd: Path, timeout: float = 120) -> subprocess.CompletedProcess:
-    proc = subprocess.run(command, cwd=cwd, text=True, capture_output=True, timeout=timeout, check=False)
-    if proc.returncode:
-        raise RuntimeError((proc.stderr or proc.stdout).strip())
-    return proc
-
-
-def _probe(path: Path) -> dict:
-    proc = _run([
-        "ffprobe", "-v", "error", "-show_entries",
-        "format=duration,size:stream=codec_name,width,height,pix_fmt,r_frame_rate",
-        "-of", "json", str(path),
-    ], path.parent)
-    return json.loads(proc.stdout)
-
-
-def export(recording: Path, output_name: str, reviewed: bool) -> int:
-    if not reviewed:
-        raise RuntimeError("inspect the review sheet and full-resolution privacy frames, then rerun with --reviewed")
-    if not shutil.which("ffmpeg") or not shutil.which("ffprobe"):
-        raise RuntimeError("ffmpeg and ffprobe are required")
-    review_path = recording / "renderer-review.json"
-    if not review_path.is_file():
-        raise RuntimeError("run browser-harness video review first")
-    review_report = json.loads(review_path.read_text(encoding="utf-8"))
-    if review_report.get("errors"):
-        raise RuntimeError("renderer review has blocking errors")
-    video.verify_source_manifest(recording)
-    comp = load_composition(recording)
-    expected_comp = compile_recording(recording, write=False)
-    if comp != expected_comp:
-        raise RuntimeError("composition.js is not the current compiled brief; rerun review")
-    artifact_hashes = review_report.get("artifactHashes") or {}
-    if set(artifact_hashes) != REVIEW_ARTIFACTS:
-        raise RuntimeError("renderer review lacks content hashes; rerun it")
-    for name, expected_hash in artifact_hashes.items():
-        path = recording / name
-        if not path.is_file() or video.file_hash(path) != expected_hash:
-            raise RuntimeError(f"{name} changed after review; rerun it")
-    renderer = recording / "video.html"
-    if video.file_hash(renderer) != video.file_hash(TEMPLATE):
-        raise RuntimeError("renderer is not the current shared template; rerun review")
-
-    output = Path(output_name)
-    if not output.is_absolute():
-        output = recording / output
-    if output.suffix.lower() != ".mp4":
-        raise RuntimeError("--output must end in .mp4")
-    webm = output.with_suffix(".webm")
-    for path in (webm, output):
-        if path.exists() or path.with_name(path.name + ".crdownload").exists():
-            raise RuntimeError(f"refusing to overwrite {path}")
-
-    expected = sum(float(beat.get("dur") or 0) for beat in comp.get("beats") or [])
-    started = time.monotonic()
-    with serve(recording) as url:
-        browser = None
-        try:
-            browser = _start_export(recording, url, webm)
-            if browser["preflight"].get("errors"):
-                raise RuntimeError(
-                    "export preflight failed: " + "; ".join(browser["preflight"]["errors"])
-                )
-            if any(not click.get("visible") for click in browser["clicks"]):
-                raise RuntimeError("export click visibility failed")
-            deadline = time.monotonic() + expected + 30
-            partial = webm.with_name(webm.name + ".crdownload")
-            while time.monotonic() < deadline:
-                if webm.is_file() and not partial.exists() and webm.stat().st_size:
-                    size = webm.stat().st_size
-                    time.sleep(0.25)
-                    if webm.stat().st_size == size:
-                        break
-                time.sleep(0.25)
-            else:
-                raise RuntimeError(f"timed out waiting for {webm}")
-        finally:
-            if not _close_editor(url, (browser or {}).get("previous")):
-                raise RuntimeError(
-                    "could not restore Chrome download behavior; restart Chrome"
-                )
-    capture_seconds = time.monotonic() - started
-
-    conversion_started = time.monotonic()
-    _probe(webm)
-    _run([
-        "ffmpeg", "-v", "error", "-i", str(webm), "-c:v", "libx264",
-        "-crf", "20", "-pix_fmt", "yuv420p", "-movflags", "+faststart", str(output),
-    ], recording)
-    conversion_seconds = time.monotonic() - conversion_started
-
-    verify_started = time.monotonic()
-    probe = _probe(output)
-    actual = float(probe["format"]["duration"])
-    if abs(actual - expected) > max(1.0, expected * 0.08):
-        raise RuntimeError(f"export duration {actual:.2f}s does not match composition {expected:.2f}s")
-    _run(["ffmpeg", "-v", "error", "-err_detect", "explode", "-i", str(output), "-f", "null", "-"], recording)
-
-    review_dir = recording / ".renderer-review"
-    final_captures = []
-    for index, at in enumerate((min(1.0, expected / 4), expected / 2, max(0.0, expected - 0.8)), 1):
-        path = review_dir / f"final-{index:02d}.jpg"
-        _run(["ffmpeg", "-v", "error", "-y", "-ss", f"{at:.3f}", "-i", str(output), "-frames:v", "1", str(path)], recording)
-        final_captures.append({"path": str(path), "time": at, "label": ("intro", "middle", "outcome")[index - 1]})
-    final_sheet = recording / "renderer-final-contact-sheet.jpg"
-    contact_sheet(final_captures, final_sheet, "FINAL MP4 SAMPLE")
-    verify_seconds = time.monotonic() - verify_started
-
-    report = {
-        "output": str(output),
-        "webm": str(webm),
-        "expectedDuration": round(expected, 3),
-        "actualDuration": actual,
-        "captureSeconds": round(capture_seconds, 3),
-        "conversionSeconds": round(conversion_seconds, 3),
-        "verificationSeconds": round(verify_seconds, 3),
-        "elapsedSeconds": round(time.monotonic() - started, 3),
-        "sha256": video.file_hash(output),
-        "probe": probe,
-        "finalContactSheet": str(final_sheet),
-    }
-    report_path = recording / "video-export.json"
-    report_path.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
-    print(f"video: {output}")
-    print(f"final review: {final_sheet}")
-    print(f"verified {actual:.2f}s MP4 in {report['elapsedSeconds']:.1f}s")
-    return 0