agentreel 0.4.4 → 0.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentreel",
-  "version": "0.4.4",
-  "description": "Turn your web apps and CLIs into viral clips",
+  "version": "0.5.0",
+  "description": "Turn your apps into demo videos",
   "bin": {
     "agentreel": "./bin/agentreel.mjs"
   },
@@ -24,7 +24,6 @@
   "files": [
     "bin/",
     "src/",
-    "scripts/",
     "public/",
     "remotion.config.*",
     "tsconfig.json"

package/scripts/browser_demo.py

@@ -1,286 +0,0 @@
-"""
-Browser demo recorder. Uses claude CLI to generate a Playwright script,
-runs it with video recording, then extracts highlight timestamps.
-
-Usage:
-    python browser_demo.py <url> <output_video> [task]
-    python browser_demo.py --highlights <video_path> <output_json> [task]
-"""
-import asyncio
-import json
-import os
-import subprocess
-import sys
-import tempfile
-import time
-
-
-def find_claude():
-    """Find the claude CLI binary."""
-    import shutil
-    claude = shutil.which("claude")
-    if claude:
-        return claude
-    for path in [
-        os.path.expanduser("~/.local/bin/claude"),
-        "/usr/local/bin/claude",
-    ]:
-        if os.path.isfile(path):
-            return path
-    return "claude"
-
-
-def generate_playwright_script(url, task, guidelines=""):
-    """Use claude CLI to generate a Playwright demo script."""
-    guidelines_part = f"IMPORTANT guidelines: {guidelines}. " if guidelines else ""
-    prompt = (
-        f"Generate a Playwright Python async function that demos a web app at {url}. "
-        f"Task: {task}. "
-        f"{guidelines_part}"
-        f"The function signature is: async def demo(page). "
-        f"Navigate to the URL, wait for load, interact with key features — "
-        f"click buttons, fill forms, scroll. Take about 20 seconds total. "
-        f"Add page.wait_for_timeout(1500) between actions so the viewer can see each step. "
-        f"IMPORTANT rules for robust scripts: "
-        f"- Use timeout=5000 on every click/fill/action so failures are fast. "
-        f"- Use force=True on all click() calls to bypass overlapping labels/overlays. "
-        f"- Click visible labels and buttons, never hidden inputs (like sr-only radio buttons). "
-        f"- Wrap each action in try/except and continue on failure — the demo must finish. "
-        f"Return ONLY the Python function code, no imports, no markdown fences."
-    )
-
-    claude = find_claude()
-    print(f"Using claude at: {claude}", file=sys.stderr)
-
-    result = subprocess.run(
-        [claude, "-p", prompt, "--output-format", "text"],
-        capture_output=True,
-        text=True,
-        timeout=300,
-    )
-
-    text = result.stdout.strip()
-    if "```" in text:
-        parts = text.split("```")
-        for part in parts:
-            part = part.strip()
-            if part.startswith("python"):
-                part = part[6:].strip()
-            if "async def demo" in part:
-                text = part
-                break
-    return text
-
-
-def extract_highlights(video_path, task):
-    """Ask Claude to suggest highlight timestamps for a browser recording."""
-    claude = find_claude()
-
-    prompt = (
-        f"I recorded a browser demo video of a web app. The task was: {task}. "
-        f"The video is about 20 seconds long. "
-        f"Suggest 3-4 highlight moments as a JSON array. Each highlight has: "
-        f'"label" (1-2 words), "overlay" (short caption with **bold** for accent), '
-        f'"videoStartSec" (start time in seconds), "videoEndSec" (end time). '
-        f"Each clip should be 5-8 seconds to show the full interaction. Cover: page load, key interaction, result. "
-        f"Return ONLY the JSON array."
-    )
-
-    result = subprocess.run(
-        [claude, "-p", prompt, "--output-format", "text"],
-        capture_output=True,
-        text=True,
-        timeout=300,
-    )
-
-    text = result.stdout.strip()
-    if result.returncode != 0 or not text:
-        print(f"Claude returned no output (exit {result.returncode}), using default highlights", file=sys.stderr)
-        if result.stderr:
-            print(f"  stderr: {result.stderr[:200]}", file=sys.stderr)
-        text = ""
-
-    if "```" in text:
-        parts = text.split("```")
-        for part in parts:
-            part = part.strip()
-            if part.startswith("json"):
-                part = part[4:].strip()
-            if part.startswith("["):
-                text = part
-                break
-
-    try:
-        highlights = json.loads(text)
-    except (json.JSONDecodeError, ValueError):
-        print(f"Could not parse highlights, using defaults", file=sys.stderr)
-        highlights = [
-            {"label": "Overview", "overlay": "**Quick look**", "videoStartSec": 1, "videoEndSec": 7},
-            {"label": "Features", "overlay": "**Key features**", "videoStartSec": 7, "videoEndSec": 14},
-            {"label": "Result", "overlay": "**See it work**", "videoStartSec": 14, "videoEndSec": 20},
-        ]
-
-    for h in highlights:
-        h["videoSrc"] = "browser-demo.mp4"
-
-    return highlights
-
-
-async def record_browser_demo(url, task, output_path, auth_state=None, guidelines=""):
-    """Generate and run a Playwright demo with video recording."""
-    from playwright.async_api import async_playwright
-
-    print(f"Generating demo script for {url}...", file=sys.stderr)
-    script_code = generate_playwright_script(url, task, guidelines)
-    print(f"Script ready ({len(script_code)} chars)", file=sys.stderr)
-
-    video_dir = tempfile.mkdtemp()
-    recording_start_ms = int(time.time() * 1000)
-
-    async with async_playwright() as p:
-        browser = await p.chromium.launch(headless=True)
-        ctx_opts = dict(
-            viewport={"width": 1280, "height": 800},
-            record_video_dir=video_dir,
-            record_video_size={"width": 1280, "height": 800},
-        )
-        if auth_state and os.path.isfile(auth_state):
-            ctx_opts["storage_state"] = auth_state
-            print(f"Using auth state: {auth_state}", file=sys.stderr)
-        context = await browser.new_context(**ctx_opts)
-
-        # Inject click tracker — persists across navigations
-        click_tracker_js = (
-            "if (!window.__agentreel_clicks) {"
-            "  window.__agentreel_clicks = [];"
-            "  document.addEventListener('click', function(e) {"
-            "    window.__agentreel_clicks.push({"
-            "      x: e.clientX,"
-            "      y: e.clientY,"
-            f"     timestamp: Date.now() - {recording_start_ms}"
-            "    });"
-            "  }, true);"
-            "}"
-        )
-        await context.add_init_script(click_tracker_js)
-
-        page = await context.new_page()
-
-        # Navigate first
-        print(f"Loading {url}...", file=sys.stderr)
-        try:
-            await page.goto(url, wait_until="networkidle", timeout=15000)
-        except Exception as e:
-            print(f"Navigation warning: {e}", file=sys.stderr)
-            await page.goto(url, timeout=15000)
-
-        await page.wait_for_timeout(1000)
-
-        # Run the generated demo
-        try:
-            local_ns = {}
-            full_code = "import asyncio\n" + script_code
-            compiled = compile(full_code, "<demo>", "exec")  # noqa: S102
-            exec(compiled, local_ns)  # noqa: S102
-
-            if "demo" in local_ns:
-                print("Running demo script...", file=sys.stderr)
-                await local_ns["demo"](page)
-            else:
-                print("No demo() function found, waiting on page...", file=sys.stderr)
-                await page.wait_for_timeout(10000)
-        except Exception as e:
-            print(f"Demo script error: {e}", file=sys.stderr)
-            # Scroll around as fallback
-            await page.wait_for_timeout(2000)
-            await page.evaluate("window.scrollTo({ top: 500, behavior: 'smooth' })")
-            await page.wait_for_timeout(2000)
-            await page.evaluate("window.scrollTo({ top: 0, behavior: 'smooth' })")
-            await page.wait_for_timeout(2000)
-
-        # Extract click data before closing
-        try:
-            clicks_raw = await page.evaluate("window.__agentreel_clicks || []")
-        except Exception:
-            clicks_raw = []
-
-        clicks = [
-            {"x": c["x"], "y": c["y"], "timeSec": round(c["timestamp"] / 1000.0, 3)}
-            for c in clicks_raw
-        ]
-        clicks_path = output_path.replace(".mp4", "-clicks.json")
-        with open(clicks_path, "w") as f:
-            json.dump(clicks, f, indent=2)
-        print(f"Captured {len(clicks)} clicks -> {clicks_path}", file=sys.stderr)
-
-        # Get the video path before closing
-        video = page.video
-        await page.close()
-        await context.close()
-        await browser.close()
-
-    # Find the recorded video and convert to mp4
-    for f in os.listdir(video_dir):
-        if f.endswith(".webm"):
-            webm_path = os.path.join(video_dir, f)
-
-            # Convert webm to mp4 with ffmpeg
-            print(f"Converting to mp4...", file=sys.stderr)
-            try:
-                subprocess.run(
-                    ["ffmpeg", "-y", "-i", webm_path, "-c:v", "libx264",
-                     "-preset", "fast", "-crf", "23", output_path],
-                    capture_output=True,
-                    timeout=60,
-                )
-                print(f"Saved: {output_path}", file=sys.stderr)
-            except (subprocess.TimeoutExpired, FileNotFoundError):
-                # ffmpeg not available, use webm directly
-                import shutil
-                mp4_path = output_path.replace(".mp4", ".webm")
-                shutil.copy2(webm_path, mp4_path)
-                print(f"Saved (webm): {mp4_path}", file=sys.stderr)
-            return
-
-    print("Error: no video file recorded", file=sys.stderr)
-    sys.exit(1)
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 3:
-        print(
-            "Usage:\n"
-            "  python browser_demo.py <url> <output_video> [task]\n"
-            "  python browser_demo.py --highlights <video_path> <output_json> [task]",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-    if sys.argv[1] == "--highlights":
-        video_path = sys.argv[2]
-        output = sys.argv[3]
-        task = sys.argv[4] if len(sys.argv) > 4 else "Demo the web app"
-        print(f"Extracting highlights...", file=sys.stderr)
-        highlights = extract_highlights(video_path, task)
-        with open(output, "w") as f:
-            json.dump(highlights, f, indent=2)
-        print(f"Saved {len(highlights)} highlights to: {output}", file=sys.stderr)
-    else:
-        url = sys.argv[1]
-        output = sys.argv[2]
-        # Parse remaining args: [task] [--auth <state_file>]
-        task = "Explore the main features"
-        auth_state = None
-        guidelines = ""
-        i = 3
-        while i < len(sys.argv):
-            if sys.argv[i] == "--auth" and i + 1 < len(sys.argv):
-                auth_state = sys.argv[i + 1]
-                i += 2
-            elif sys.argv[i] == "--guidelines" and i + 1 < len(sys.argv):
-                guidelines = sys.argv[i + 1]
-                i += 2
-            else:
-                task = sys.argv[i]
-                i += 1
-        asyncio.run(record_browser_demo(url, task, output, auth_state=auth_state, guidelines=guidelines))

package/scripts/cli_demo.py

@@ -1,370 +0,0 @@
-"""
-CLI demo recorder. Uses `claude` CLI to plan the demo, then records it.
-
-Usage:
-    python cli_demo.py <command> <workdir> <output_cast> [context]
-"""
-import getpass
-import json
-import os
-import pty
-import re
-import select
-import socket
-import subprocess
-import sys
-import time
-
-
-def find_claude():
-    """Find the claude CLI binary."""
-    import shutil
-    claude = shutil.which("claude")
-    if claude:
-        return claude
-    # Common locations
-    for path in [
-        os.path.expanduser("~/.local/bin/claude"),
-        "/usr/local/bin/claude",
-        os.path.expanduser("~/.claude/bin/claude"),
-    ]:
-        if os.path.isfile(path):
-            return path
-    return "claude"
-
-
-def generate_demo_plan(command: str, context: str, guidelines: str = "") -> list[dict]:
-    """Use claude CLI to plan a demo sequence."""
-    guidelines_block = f"\n\nIMPORTANT guidelines you MUST follow:\n{guidelines}" if guidelines else ""
-
-    prompt = f"""You are planning a terminal demo for a CLI tool. The tool is invoked with: {command}
-
-Context about what this tool does:
-{context}{guidelines_block}
-
-Generate a JSON array of demo steps. Each step is an object with:
-- "type": "command" (run a shell command)
-- "value": the command string
-- "delay": seconds to wait after (for dramatic effect)
-- "description": one-line description
-
-Make the demo:
-- Show the most impressive features
-- 5-8 steps max
-- Start simple, build to the wow moment
-- Use realistic commands
-
-Return ONLY the JSON array, no markdown, no explanation."""
-
-    claude = find_claude()
-    print(f"Using claude at: {claude}", file=sys.stderr)
-
-    result = subprocess.run(
-        [claude, "-p", prompt, "--output-format", "text"],
-        capture_output=True,
-        text=True,
-        timeout=300,
-    )
-
-    if result.returncode != 0:
-        print(f"claude stderr: {result.stderr}", file=sys.stderr)
-        raise RuntimeError(f"claude failed: {result.stderr}")
-
-    text = result.stdout.strip()
-    print(f"Claude output: {text[:200]}...", file=sys.stderr)
-
-    # Strip markdown fences if present
-    if "```" in text:
-        # Find JSON between fences
-        parts = text.split("```")
-        for part in parts:
-            part = part.strip()
-            if part.startswith("json"):
-                part = part[4:].strip()
-            if part.startswith("["):
-                text = part
-                break
-
-    return json.loads(text)
-
-
-def record_demo(steps: list[dict], workdir: str, output_path: str):
-    """Execute demo steps in a PTY and record as asciicast v2."""
-    cols, rows = 80, 24
-    start_time = time.time()
-
-    with open(output_path, "w") as f:
-        header = {
-            "version": 2,
-            "width": cols,
-            "height": rows,
-            "timestamp": int(start_time),
-        }
-        f.write(json.dumps(header) + "\n")
-
-        # Build patterns to strip user identity from output
-        _user = getpass.getuser()
-        _host = socket.gethostname().split(".")[0]
-        _home = os.path.expanduser("~")
-        _title_seq = re.compile(r'\x1b\][\d;]*[^\x07\x1b]*(?:\x07|\x1b\\)')
-        _identity = re.compile(
-            r'|'.join(re.escape(s) for s in {_user, _host, _home} if s),
-            re.IGNORECASE,
-        )
-
-        def _sanitize(text: str) -> str:
-            text = _title_seq.sub('', text)
-            text = _identity.sub('user', text)
-            return text
-
-        def write_event(event_type: str, data: str, sanitize: bool = False):
-            if sanitize:
-                data = _sanitize(data)
-            elapsed = time.time() - start_time
-            f.write(json.dumps([round(elapsed, 6), event_type, data]) + "\n")
-            f.flush()
-
-        for step in steps:
-            if step["type"] != "command":
-                continue
-
-            cmd = step["value"]
-            desc = step.get("description", "")
-
-            # Show description as dim comment
-            if desc:
-                write_event("o", f"\x1b[38;5;245m# {desc}\x1b[0m\r\n")
-                time.sleep(0.3)
-
-            # Type the command character by character (no $ prompt — the renderer adds one)
-            write_event("o", "")
-            for char in cmd:
-                write_event("o", char)
-                time.sleep(0.04)
-            write_event("o", "\r\n")
-            time.sleep(0.2)
-
-            # Execute in PTY with sanitized env (hide username/hostname)
-            pid, fd = pty.fork()
-            if pid == 0:
-                os.chdir(workdir)
-                os.environ["PS1"] = "$ "
-                os.environ["PROMPT_COMMAND"] = ""
-                os.environ.pop("BASH_COMMAND", None)
-                # Suppress terminal title sequences (user@host)
-                os.environ["TERM"] = "dumb"
-                os.execvp("/bin/sh", ["/bin/sh", "-c", cmd])
-            else:
-                deadline = time.time() + 15
-                while time.time() < deadline:
-                    r, _, _ = select.select([fd], [], [], 0.1)
-                    if r:
-                        try:
-                            data = os.read(fd, 4096)
-                            if data:
-                                write_event("o", data.decode("utf-8", errors="replace"), sanitize=True)
-                            else:
-                                break
-                        except OSError:
-                            break
-                    pid_result = os.waitpid(pid, os.WNOHANG)
-                    if pid_result[0] != 0:
-                        # Drain remaining output
-                        try:
-                            while True:
-                                r, _, _ = select.select([fd], [], [], 0.1)
-                                if r:
-                                    data = os.read(fd, 4096)
-                                    if data:
-                                        write_event("o", data.decode("utf-8", errors="replace"), sanitize=True)
-                                    else:
-                                        break
-                                else:
-                                    break
-                        except OSError:
-                            pass
-                        break
-
-                try:
-                    os.close(fd)
-                except OSError:
-                    pass
-
-            delay = step.get("delay", 1.0)
-            time.sleep(delay)
-            write_event("o", "\r\n")
-
-    print(f"Saved: {output_path}", file=sys.stderr)
-
-
-def extract_highlights(cast_path: str, context: str, guidelines: str = "") -> list[dict]:
-    """Ask Claude to pick highlight moments from the recorded session."""
-    # Read the asciicast and strip to just the text content
-    lines_output = []
-    with open(cast_path) as f:
-        for i, line in enumerate(f):
-            if i == 0:
-                continue  # skip header
-            try:
-                event = json.loads(line)
-                if event[1] == "o":
-                    lines_output.append(event[2])
-            except (json.JSONDecodeError, IndexError):
-                continue
-
-    raw_output = "".join(lines_output)
-    # Clean ANSI escape codes
-    clean = re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', raw_output)
-    # Strip other common escape sequences (title sets, OSC, etc.)
-    clean = re.sub(r'\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)', '', clean)
-    # Collapse carriage-return overwrites (spinners, progress bars).
-    # \r means "go back to line start" — keep only the final version of each line.
-    collapsed_lines = []
-    for line in clean.split('\n'):
-        parts = line.split('\r')
-        final = parts[-1].strip() if parts else ""
-        if final:
-            # Deduplicate consecutive identical lines (spinner frames)
-            if not collapsed_lines or final != collapsed_lines[-1]:
-                collapsed_lines.append(final)
-    clean = '\n'.join(collapsed_lines)
-
-    guidelines_block = f"\n\nAdditional guidelines: {guidelines}" if guidelines else ""
-
-    # Demo mode: more chapters, more lines, show full flows
-    is_demo = "demo" in guidelines.lower() if guidelines else False
-
-    # If terminal output is empty (e.g. tmux sessions, interactive tools),
-    # tell Claude to generate representative highlights from context alone
-    output_block = f"\nTerminal output:\n---\n{clean[:6000 if is_demo else 3000]}\n---" if clean.strip() else "\n(No terminal output captured — generate representative highlights from the context below.)"
-
-    if is_demo:
-        prompt = f"""You are creating chapter-based highlights for a demo walkthrough video.
-{output_block}
-
-Context: {context}{guidelines_block}
-
-Create 4-6 chapters that walk through the demo. For each chapter, return:
-- "label": chapter name (1-3 words)
-- "lines": array of objects with "text" (string), optionally "color" (hex), "bold" (bool), "dim" (bool), "isPrompt" (bool)
-
-Each chapter: 12-20 lines. Include the prompt (isPrompt: true) and realistic output.
-Colors: green="#50fa7b", yellow="#f1fa8c", purple="#bd93f9", red="#ff5555", dim="#6272a4", white="#f8f8f2"
-
-Return ONLY a JSON array. No markdown fences."""
-    else:
-        prompt = f"""You are creating a highlights reel for a CLI demo video.
-{output_block}
-
-Context: {context}{guidelines_block}
-
-Pick 3-4 highlight moments. For each, return:
-- "label": 1-2 word label
-- "lines": array of objects with "text", optionally "color" (hex), "bold", "dim", "isPrompt"
-- "zoomLine": (optional) index of the most impressive line
-
-Each highlight: 4-8 lines max.
-Colors: green="#50fa7b", yellow="#f1fa8c", purple="#bd93f9", red="#ff5555", dim="#6272a4", white="#f8f8f2"
-
-Return ONLY a JSON array. No markdown fences."""
-
-    claude = find_claude()
-    result = subprocess.run(
-        [claude, "-p", prompt, "--output-format", "text"],
-        capture_output=True,
-        text=True,
-        timeout=300,
-    )
-
-    text = result.stdout.strip()
-    if "```" in text:
-        parts = text.split("```")
-        for part in parts:
-            part = part.strip()
-            if part.startswith("json"):
-                part = part[4:].strip()
-            if part.startswith("["):
-                text = part
-                break
-
-    try:
-        return json.loads(text)
-    except (json.JSONDecodeError, ValueError):
-        print(f"Could not parse highlights from Claude, retrying with simpler prompt...", file=sys.stderr)
-
-    # Retry with a minimal prompt
-    retry_prompt = f"""Generate a JSON array of {4 if is_demo else 3} terminal highlights for a demo video.
-Context: {context}
-
-Each highlight: {{"label": "Name", "lines": [{{"text": "command", "isPrompt": true}}, {{"text": "output line", "color": "#50fa7b"}}]}}
-Use 8-15 lines per highlight. Make the output realistic for this tool.
-Return ONLY a JSON array."""
-
-    try:
-        retry = subprocess.run(
-            [claude, "-p", retry_prompt, "--output-format", "text"],
-            capture_output=True, text=True, timeout=120,
-        )
-        retry_text = retry.stdout.strip()
-        if "```" in retry_text:
-            for part in retry_text.split("```"):
-                part = part.strip()
-                if part.startswith("json"):
-                    part = part[4:].strip()
-                if part.startswith("["):
-                    retry_text = part
-                    break
-        return json.loads(retry_text)
-    except Exception:
-        print(f"Retry also failed, using defaults", file=sys.stderr)
-        return [
-            {"label": "Run", "lines": [
-                {"text": context or "demo", "isPrompt": True},
-                {"text": "", },
-                {"text": "  Done.", "color": "#50fa7b"},
-            ]},
-        ]
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 4:
-        print("Usage: python cli_demo.py <command> <workdir> <output> [context]", file=sys.stderr)
-        print("       python cli_demo.py --highlights <cast_file> <output_json> [context]", file=sys.stderr)
-        sys.exit(1)
-
-    # Highlights mode: extract highlights from existing recording
-    if sys.argv[1] == "--highlights":
-        cast_file = sys.argv[2]
-        output = sys.argv[3]
-        context = sys.argv[4] if len(sys.argv) > 4 else ""
-        guidelines = sys.argv[5] if len(sys.argv) > 5 else ""
-        print(f"Extracting highlights from: {cast_file}", file=sys.stderr)
-        highlights = extract_highlights(cast_file, context, guidelines)
-        with open(output, "w") as f:
-            json.dump(highlights, f, indent=2)
-        print(f"Saved {len(highlights)} highlights to: {output}", file=sys.stderr)
-        sys.exit(0)
-
-    # Record mode: plan + record + extract highlights
-    command = sys.argv[1]
-    workdir = sys.argv[2]
-    output = sys.argv[3]
-    context = sys.argv[4] if len(sys.argv) > 4 else ""
-    guidelines = sys.argv[5] if len(sys.argv) > 5 else ""
-
-    print(f"Planning demo for: {command}", file=sys.stderr)
-    steps = generate_demo_plan(command, context, guidelines)
-    print(f"Generated {len(steps)} steps:", file=sys.stderr)
-    for s in steps:
-        print(f"  $ {s['value']}  — {s.get('description', '')}", file=sys.stderr)
-
-    print("Recording...", file=sys.stderr)
-    record_demo(steps, workdir, output)
-
-    # Extract highlights from the recording
-    highlights_path = output.replace(".cast", "-highlights.json")
-    print("Extracting highlights...", file=sys.stderr)
-    highlights = extract_highlights(output, context, guidelines)
-    with open(highlights_path, "w") as f:
-        json.dump(highlights, f, indent=2)
-    print(f"Saved {len(highlights)} highlights to: {highlights_path}", file=sys.stderr)