@remixmate/cli 0.1.0 → 0.1.1

package/skills/web-capture/scripts/_media_screenshot/scenes/focus.py

@@ -0,0 +1,24 @@
+"""Focus scene: dim the page with a spotlight cut-out around the target."""
+from __future__ import annotations
+
+from .. import js_loader
+from ..browser import resolve_locator
+from . import register
+
+
+@register("focus")
+def scene_focus(page, scene: dict) -> None:
+    locator = resolve_locator(page, scene["selector"])
+    box = locator.bounding_box()
+    if not box:
+        raise RuntimeError(f"focus: no bounding box for {scene['selector']}")
+    page.evaluate(
+        js_loader.load("focus"),
+        {
+            "box": box,
+            "pad": scene.get("padding", 12),
+            "label": scene.get("label", ""),
+            "color": scene.get("color", "#ff3b30"),
+        },
+    )
+    page.wait_for_timeout(scene.get("duration", 3000))

package/skills/web-capture/scripts/_media_screenshot/scenes/highlight.py

@@ -0,0 +1,54 @@
+"""Highlight scene: rectangle around a target element (or union of several)."""
+from __future__ import annotations
+
+from .. import js_loader
+from ..browser import resolve_locator
+from . import register
+
+
+def _union_box(page, selectors: list[str]) -> dict | None:
+    """Compute the union bounding box of every matching selector. Skips misses."""
+    # Make sure the first one is visible / on-screen before measuring.
+    resolve_locator(page, selectors[0])
+    boxes: list[dict] = []
+    for sel in selectors:
+        try:
+            loc = page.locator(sel).first
+            b = loc.bounding_box()
+        except Exception:
+            continue
+        if b:
+            boxes.append(b)
+    if not boxes:
+        return None
+    x = min(b["x"] for b in boxes)
+    y = min(b["y"] for b in boxes)
+    right = max(b["x"] + b["width"] for b in boxes)
+    bottom = max(b["y"] + b["height"] for b in boxes)
+    return {"x": x, "y": y, "width": right - x, "height": bottom - y}
+
+
+@register("highlight")
+def scene_highlight(page, scene: dict) -> None:
+    selectors = scene.get("selectors")
+    if selectors:
+        box = _union_box(page, list(selectors))
+        if not box:
+            raise RuntimeError(f"highlight: no bounding boxes for {selectors}")
+    else:
+        locator = resolve_locator(page, scene["selector"])
+        box = locator.bounding_box()
+        if not box:
+            raise RuntimeError(f"highlight: no bounding box for {scene['selector']}")
+    page.evaluate(
+        js_loader.load("highlight"),
+        {
+            "box": box,
+            "pad": scene.get("padding", 8),
+            "color": scene.get("color", "#ff3b30"),
+            "lw": scene.get("lineWidth", 4),
+            "label": scene.get("label", ""),
+            "drawOnMs": int(scene.get("drawOnMs", 0)),
+        },
+    )
+    page.wait_for_timeout(scene.get("duration", 3000))

package/skills/web-capture/scripts/_media_screenshot/scenes/hover.py

@@ -0,0 +1,28 @@
+"""Hover scene: move cursor onto target and hold so tooltips/cards reveal."""
+from __future__ import annotations
+
+from .. import js_loader
+from ..browser import resolve_locator
+from . import register
+
+
+@register("hover")
+def scene_hover(page, scene: dict) -> None:
+    locator = resolve_locator(page, scene["selector"])
+    box = locator.bounding_box()
+    if not box:
+        raise RuntimeError(f"hover: no bounding box for {scene['selector']}")
+    cx = box["x"] + box["width"] / 2
+    cy = box["y"] + box["height"] / 2
+
+    move_ms = int(scene.get("moveMs", 700))
+    hold_ms = int(scene.get("holdMs", 2500))
+
+    page.evaluate(js_loader.load("cursor_bootstrap"))
+    page.evaluate(js_loader.load("cursor_move"), {"x": cx, "y": cy, "ms": move_ms})
+    page.wait_for_timeout(move_ms + 80)
+    try:
+        locator.hover()
+    except Exception:
+        pass
+    page.wait_for_timeout(hold_ms)

package/skills/web-capture/scripts/_media_screenshot/scenes/redact.py

@@ -0,0 +1,32 @@
+"""Redact scene: blur / pixelate / solid-cover sensitive regions."""
+from __future__ import annotations
+
+from .. import js_loader
+from ..browser import resolve_locator
+from . import register
+
+
+@register("redact")
+def scene_redact(page, scene: dict) -> None:
+    selectors: list[str] = list(scene.get("selectors") or [])
+    if not selectors and scene.get("selector"):
+        selectors.append(scene["selector"])
+    items: list[dict] = []
+    for sel in selectors:
+        try:
+            loc = resolve_locator(page, sel)
+            box = loc.bounding_box()
+        except Exception:
+            continue
+        if box:
+            items.append({"box": box, "color": scene.get("color", "#222")})
+    if not items:
+        raise RuntimeError("redact: no resolvable targets")
+    page.evaluate(
+        js_loader.load("redact"),
+        {
+            "items": items,
+            "mode": scene.get("mode", "blur"),
+        },
+    )
+    page.wait_for_timeout(scene.get("duration", 2500))

package/skills/web-capture/scripts/_media_screenshot/scenes/scroll.py

@@ -0,0 +1,32 @@
+"""Scroll scene: step-scroll for ``duration`` or until ``toSelector`` is hit."""
+from __future__ import annotations
+
+import time
+
+from .. import js_loader
+from ..browser import resolve_locator
+from . import register
+
+
+@register("scroll")
+def scene_scroll(page, scene: dict) -> None:
+    step = scene.get("step", 50)
+    interval = scene.get("interval", 60)
+    if scene.get("fromSelector"):
+        from_loc = resolve_locator(page, scene["fromSelector"])
+        from_loc.scroll_into_view_if_needed()
+        page.wait_for_timeout(300)
+    elif scene.get("startTop"):
+        page.evaluate("() => window.scrollTo(0, 0)")
+        page.wait_for_timeout(200)
+    duration = scene.get("duration", 8000)
+    page.evaluate(
+        js_loader.load("scroll"),
+        {
+            "step": step,
+            "interval": interval,
+            "endTime": int(time.time() * 1000) + duration,
+            "toSelector": scene.get("toSelector"),
+        },
+    )
+    page.wait_for_timeout(scene.get("holdAtEnd", 600))

package/skills/web-capture/scripts/_media_screenshot/scenes/sequence.py

@@ -0,0 +1,43 @@
+"""Sequence scene: multiple targets get numbered outlines, revealed in order."""
+from __future__ import annotations
+
+from .. import js_loader
+from ..browser import resolve_locator
+from . import register
+
+
+@register("sequence")
+def scene_sequence(page, scene: dict) -> None:
+    raw = scene.get("items") or []
+    items: list[dict] = []
+    for it in raw:
+        if isinstance(it, str):
+            sel, label = it, ""
+        else:
+            sel = it.get("selector")
+            label = it.get("label", "")
+        if not sel:
+            continue
+        try:
+            loc = resolve_locator(page, sel)
+            box = loc.bounding_box()
+        except Exception:
+            continue
+        if not box:
+            continue
+        items.append({"box": box, "label": label})
+    if not items:
+        raise RuntimeError("sequence: no resolvable items")
+    step_ms = int(scene.get("stepMs", 500))
+    page.evaluate(
+        js_loader.load("sequence"),
+        {
+            "items": items,
+            "color": scene.get("color", "#ff3b30"),
+            "lineWidth": scene.get("lineWidth", 3),
+            "padding": scene.get("padding", 6),
+            "stepMs": step_ms,
+        },
+    )
+    total = step_ms * len(items) + int(scene.get("holdMs", 1500))
+    page.wait_for_timeout(total)

package/skills/web-capture/scripts/_media_screenshot/scenes/title_card.py

@@ -0,0 +1,20 @@
+"""Title card scene: full-screen opener/outro with title + subtitle + accent."""
+from __future__ import annotations
+
+from .. import js_loader
+from . import register
+
+
+@register("title-card")
+def scene_title_card(page, scene: dict) -> None:
+    page.evaluate(
+        js_loader.load("title_card"),
+        {
+            "title": scene.get("title", ""),
+            "subtitle": scene.get("subtitle", ""),
+            "bg": scene.get("background", "rgba(15,17,21,0.96)"),
+            "fg": scene.get("color", "#fff"),
+            "accent": scene.get("accent", "#ff3b30"),
+        },
+    )
+    page.wait_for_timeout(scene.get("duration", 2500))

package/skills/web-capture/scripts/_media_screenshot/scenes/type.py

@@ -0,0 +1,42 @@
+"""Type scene: move cursor to an input, focus, then typewriter the text."""
+from __future__ import annotations
+
+from .. import js_loader
+from ..browser import resolve_locator
+from . import register
+
+
+@register("type")
+def scene_type(page, scene: dict) -> None:
+    locator = resolve_locator(page, scene["selector"])
+    text = scene.get("text", "")
+    delay = int(scene.get("delay", 80))
+    clear_first = bool(scene.get("clearFirst", True))
+    move_cursor = bool(scene.get("moveCursor", True))
+    move_ms = int(scene.get("moveMs", 600))
+    pre_hold = int(scene.get("preHoldMs", 200))
+    post_hold = int(scene.get("postHoldMs", 800))
+
+    if move_cursor:
+        box = locator.bounding_box()
+        if box:
+            cx = box["x"] + box["width"] / 2
+            cy = box["y"] + box["height"] / 2
+            page.evaluate(js_loader.load("cursor_bootstrap"))
+            page.evaluate(js_loader.load("cursor_move"), {"x": cx, "y": cy, "ms": move_ms})
+            page.wait_for_timeout(move_ms + pre_hold)
+
+    try:
+        locator.click()
+    except Exception:
+        pass
+    if clear_first:
+        try:
+            locator.fill("")
+        except Exception:
+            pass
+    try:
+        locator.type(text, delay=delay)
+    except Exception:
+        page.keyboard.type(text, delay=delay)
+    page.wait_for_timeout(post_hold)

package/skills/web-capture/scripts/_media_screenshot/scenes/wait.py

@@ -0,0 +1,9 @@
+"""Wait scene: a simple pause between other scenes."""
+from __future__ import annotations
+
+from . import register
+
+
+@register("wait")
+def scene_wait(page, scene: dict) -> None:
+    page.wait_for_timeout(scene.get("duration", 1000))

package/skills/web-capture/scripts/_media_screenshot/scenes/zoom.py

@@ -0,0 +1,72 @@
+"""Zoom scene: element-level OR page-level (browser-like) zoom animation."""
+from __future__ import annotations
+
+from .. import js_loader
+from ..browser import resolve_locator
+from . import register
+
+
+def _run_page_zoom(page, scene: dict) -> None:
+    target_scale = scene.get("scale", 2.5)
+    ramp_in_ms = scene.get("rampInMs", scene.get("rampMs", 700))
+    ramp_out_ms = scene.get("rampOutMs", 0)
+    hold_ms = scene.get("holdMs", 2500)
+    color = scene.get("color", "#ff9500")
+    label = scene.get("label", "")
+    page.evaluate(
+        js_loader.load("page_zoom_in"),
+        {
+            "selector": scene["selector"],
+            "targetScale": target_scale,
+            "rampInMs": ramp_in_ms,
+            "label": label,
+            "color": color,
+        },
+    )
+    page.wait_for_timeout(ramp_in_ms + hold_ms)
+    if ramp_out_ms > 0:
+        page.evaluate(js_loader.load("page_zoom_out"), {"rampOutMs": ramp_out_ms})
+        page.wait_for_timeout(ramp_out_ms + 100)
+    page.evaluate(js_loader.load("page_zoom_restore"))
+
+
+def _run_element_zoom(page, scene: dict) -> None:
+    target_scale = scene.get("scale", 2.5)
+    ramp_ms = scene.get("rampMs", 700)
+    hold_ms = scene.get("holdMs", 2500)
+    color = scene.get("color", "#ff9500")
+    label = scene.get("label", "")
+    dim = scene.get("dim", True)
+    line_width = scene.get("lineWidth", 3)
+
+    page.evaluate(
+        js_loader.load("element_zoom"),
+        {
+            "selector": scene["selector"],
+            "targetScale": target_scale,
+            "rampMs": ramp_ms,
+            "color": color,
+            "label": label,
+            "dim": dim,
+            "lineWidth": line_width,
+        },
+    )
+    page.wait_for_timeout(ramp_ms + hold_ms)
+    page.evaluate(js_loader.load("element_zoom_restore"), scene["selector"])
+
+
+@register("zoom")
+def scene_zoom(page, scene: dict) -> None:
+    target = scene.get("target", "element")
+    locator = resolve_locator(page, scene["selector"])
+    locator.scroll_into_view_if_needed()
+    # Center in viewport so the element has room to grow.
+    locator.evaluate(
+        "el => el.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' })"
+    )
+    page.wait_for_timeout(250)
+
+    if target == "page":
+        _run_page_zoom(page, scene)
+    else:
+        _run_element_zoom(page, scene)

package/skills/web-capture/scripts/_media_screenshot/screenshot.py

@@ -0,0 +1,166 @@
+"""Screenshot operation: full-page / element / region, with optional
+hide-before / native mask / drawn annotations.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from . import scenes
+from .bootstrap import ensure_runtime
+from .browser import (
+    apply_pre_action_waits,
+    build_context_options,
+    launch_with_browser_install,
+)
+from .overlay import ensure_overlay
+
+
+def _apply_hide(page, selectors: list[str]) -> None:
+    """display:none every match of every selector (idempotent, scoped to this page)."""
+    if not selectors:
+        return
+    page.evaluate(
+        """(sels) => {
+          sels.forEach((s) => {
+            try {
+              document.querySelectorAll(s).forEach((el) => {
+                el.style.setProperty('display', 'none', 'important');
+              });
+            } catch (e) { /* invalid selector — skip */ }
+          });
+        }""",
+        selectors,
+    )
+
+
+def _apply_annotations(page, annotations: list[dict], settle_ms: int) -> None:
+    """Reuse scene handlers to draw static overlays before snapshotting."""
+    if not annotations:
+        return
+    ensure_overlay(page)
+    for ann in annotations:
+        handler = scenes.get_handler(ann.get("type", ""))
+        if not handler:
+            print(
+                f"[annotate] skip unknown type: {ann.get('type')!r} "
+                f"(known: {', '.join(scenes.known_types())})",
+                file=sys.stderr,
+            )
+            continue
+        # Scene handlers wait on `duration`; for static annotations we want
+        # 0-wait so they all stack up before the snapshot fires.
+        ann_copy = dict(ann)
+        ann_copy.setdefault("duration", 0)
+        ann_copy.setdefault("holdMs", 0)
+        try:
+            handler(page, ann_copy)
+        except Exception as e:
+            print(f"[annotate] {ann.get('type')} failed: {e}", file=sys.stderr)
+    if settle_ms > 0:
+        page.wait_for_timeout(settle_ms)
+
+
+def _load_annotations(spec) -> tuple[list[dict], int]:
+    """Accept either a list, a dict with 'annotations' key, or a path to such."""
+    if spec is None:
+        return [], 0
+    settle_ms = 900
+    if isinstance(spec, (str, Path)):
+        p = Path(spec)
+        if p.exists():
+            data = json.loads(p.read_text())
+        else:
+            data = json.loads(str(spec))
+    else:
+        data = spec
+    if isinstance(data, list):
+        return data, settle_ms
+    if isinstance(data, dict):
+        return list(data.get("annotations") or []), int(data.get("settleMs", settle_ms))
+    return [], settle_ms
+
+
+def _build_mask_locators(page, selectors: list[str]):
+    out = []
+    for s in selectors or []:
+        try:
+            out.append(page.locator(s))
+        except Exception:
+            continue
+    return out
+
+
+def do_screenshot(cfg: dict) -> Path:
+    """Take a screenshot per cfg. Returns the absolute output path."""
+    ensure_runtime()
+    from playwright.sync_api import sync_playwright
+
+    output = Path(cfg["output"]).resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+
+    annotations, settle_ms = _load_annotations(cfg.get("annotate"))
+
+    with sync_playwright() as p:
+        browser = launch_with_browser_install(p, cfg.get("browser"))
+        try:
+            context = browser.new_context(**build_context_options(p, cfg, None))
+            if cfg.get("timeout"):
+                context.set_default_timeout(cfg["timeout"])
+            page = context.new_page()
+            try:
+                page.goto(cfg["url"], wait_until="domcontentloaded")
+                apply_pre_action_waits(page, cfg)
+
+                _apply_hide(page, cfg.get("hideSelectors") or [])
+                _apply_annotations(page, annotations, settle_ms)
+
+                mask_locators = _build_mask_locators(page, cfg.get("maskSelectors") or [])
+                mask_kwargs: dict = {}
+                if mask_locators:
+                    mask_kwargs["mask"] = mask_locators
+                    if cfg.get("maskColor"):
+                        mask_kwargs["mask_color"] = cfg["maskColor"]
+
+                if cfg.get("selector"):
+                    locator = page.locator(cfg["selector"]).first
+                    if cfg.get("scrollIntoView", True):
+                        locator.scroll_into_view_if_needed()
+                    if isinstance(cfg.get("clip"), (list, tuple)) and len(cfg["clip"]) == 4:
+                        box = locator.bounding_box()
+                        if not box:
+                            raise SystemExit(
+                                f'selector "{cfg["selector"]}" has no bounding box'
+                            )
+                        dx, dy, w, h = cfg["clip"]
+                        page.screenshot(
+                            path=str(output),
+                            clip={
+                                "x": box["x"] + dx,
+                                "y": box["y"] + dy,
+                                "width": w,
+                                "height": h,
+                            },
+                            **mask_kwargs,
+                        )
+                    else:
+                        locator.screenshot(path=str(output), **mask_kwargs)
+                elif isinstance(cfg.get("clip"), (list, tuple)) and len(cfg["clip"]) == 4:
+                    x, y, w, h = cfg["clip"]
+                    page.screenshot(
+                        path=str(output),
+                        clip={"x": x, "y": y, "width": w, "height": h},
+                        **mask_kwargs,
+                    )
+                else:
+                    page.screenshot(
+                        path=str(output),
+                        full_page=bool(cfg.get("fullPage")),
+                        **mask_kwargs,
+                    )
+            finally:
+                context.close()
+        finally:
+            browser.close()
+    return output

package/skills/web-capture/scripts/_media_screenshot/storyboard.py

@@ -0,0 +1,88 @@
+"""Storyboard runner: orchestrate a sequence of scenes with smooth transitions."""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+from .bootstrap import ensure_runtime
+from .browser import (
+    apply_pre_action_waits,
+    build_context_options,
+    launch_with_browser_install,
+    wait_until_settled,
+)
+from .overlay import clear_overlay, ensure_overlay, fade_out_overlays
+from . import scenes
+
+
+def _run_storyboard(page, cfg: dict) -> None:
+    ensure_overlay(page)
+    scene_list = cfg.get("scenes") or []
+    transition = cfg.get("transition") or {}
+    fade_out_ms = transition.get("fadeOutMs", transition.get("duration", 350))
+    gap_ms = transition.get("gapMs", 150)
+    for i, scene in enumerate(scene_list):
+        handler = scenes.get_handler(scene.get("type", ""))
+        if not handler:
+            print(
+                f"[runner] skip unknown scene type: {scene.get('type')!r} "
+                f"(known: {', '.join(scenes.known_types())})",
+                file=sys.stderr,
+            )
+            continue
+        print(
+            f"[runner] scene {i + 1}/{len(scene_list)}: {scene['type']}",
+            file=sys.stderr,
+        )
+        handler(page, scene)
+        if i < len(scene_list) - 1:
+            fade_out_overlays(page, fade_out_ms)
+            clear_overlay(page)
+            ensure_overlay(page)
+            if gap_ms > 0:
+                page.wait_for_timeout(gap_ms)
+
+
+def do_storyboard(cfg: dict) -> tuple[Path, int, int]:
+    """Run a storyboard recording. Returns (output_path, start_ms, end_ms)."""
+    ensure_runtime()
+    from playwright.sync_api import sync_playwright
+
+    output = Path(cfg["output"]).resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    out_dir = str(output.parent)
+
+    with sync_playwright() as p:
+        browser = launch_with_browser_install(p, cfg.get("browser"))
+        try:
+            t0 = time.time()
+            context = browser.new_context(**build_context_options(p, cfg, out_dir))
+            if cfg.get("timeout"):
+                context.set_default_timeout(cfg["timeout"])
+            page = context.new_page()
+            video_path: str | None = None
+            start_ms = 0
+            end_ms = 0
+            try:
+                page.goto(cfg["url"], wait_until="domcontentloaded")
+                apply_pre_action_waits(page, cfg)
+                wait_until_settled(page, cfg)
+                start_ms = int((time.time() - t0) * 1000)
+                _run_storyboard(page, cfg)
+                end_ms = int((time.time() - t0) * 1000)
+                video = page.video
+                context.close()
+                if video:
+                    video_path = video.path()
+            finally:
+                pass
+        finally:
+            browser.close()
+
+    if not video_path or not Path(video_path).exists():
+        raise SystemExit("storyboard finished but no video file was produced")
+    src = Path(video_path)
+    if src.resolve() != output:
+        src.replace(output)
+    return output, start_ms, end_ms