@optima-chat/optima-agent 0.8.91 → 0.8.93

package/.claude/skills/video-clone/scripts/init_project_test.py

@@ -0,0 +1,106 @@
+"""Tests for init_project.py.
+
+Uses GEN_OUTPUT_ROOT env override to isolate the tests from the real
+gen-output/ directory.
+
+Run: python scripts/init_project_test.py
+"""
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+SCRIPTS = Path(__file__).parent
+INIT = SCRIPTS / "init_project.py"
+
+
+def _run(root: Path, *args: str) -> subprocess.CompletedProcess:
+    env = os.environ.copy()
+    env["GEN_OUTPUT_ROOT"] = str(root)
+    return subprocess.run(
+        [sys.executable, str(INIT), *args],
+        capture_output=True, text=True, env=env,
+    )
+
+
+def test_creates_full_structure():
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        r = _run(root, "--name", "myproj", "--task-type", "video_clone")
+        assert r.returncode == 0, f"init failed: {r.stderr}"
+        base = root / "video-clone" / "myproj"
+        assert (base / "source").is_dir()
+        assert (base / "frames").is_dir()
+        assert (base / "videos").is_dir()
+        state_file = base / ".state" / "phase.json"
+        assert state_file.is_file()
+        state = json.loads(state_file.read_text(encoding="utf-8"))
+        assert state["project"] == "myproj"
+        assert state["task_type"] == "video_clone"
+        assert state["created_at"] is not None
+        # Single-gate model: only preview_confirmed, no plan/prompt/frame gates
+        assert "preview_confirmed" in state["gates"], (
+            f"Expected single-gate schema with 'preview_confirmed', got: {list(state['gates'])}"
+        )
+        assert state["gates"]["preview_confirmed"]["status"] is False
+        # Old 3-gate keys must NOT exist
+        for old_gate in ("plan_confirmed", "prompt_confirmed", "frame_confirmed"):
+            assert old_gate not in state["gates"], (
+                f"Old gate '{old_gate}' still present in template"
+            )
+
+
+def test_creates_video_gen_project():
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        r = _run(root, "--name", "genproj", "--task-type", "video_gen")
+        assert r.returncode == 0, f"init failed: {r.stderr}"
+        state_file = root / "video-clone" / "genproj" / ".state" / "phase.json"
+        state = json.loads(state_file.read_text(encoding="utf-8"))
+        assert state["task_type"] == "video_gen"
+        assert "preview_confirmed" in state["gates"]
+
+
+def test_rejects_duplicate():
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        _run(root, "--name", "dup", "--task-type", "video_clone")
+        r = _run(root, "--name", "dup", "--task-type", "video_clone")
+        assert r.returncode == 1, (
+            f"expected exit 1 on duplicate, got {r.returncode}\n"
+            f"stdout: {r.stdout}\nstderr: {r.stderr}"
+        )
+
+
+def test_rejects_unknown_task_type():
+    with tempfile.TemporaryDirectory() as tmp:
+        r = _run(Path(tmp), "--name", "x", "--task-type", "nonsense")
+        assert r.returncode != 0
+
+
+TESTS = [
+    ("creates full structure", test_creates_full_structure),
+    ("creates video_gen project", test_creates_video_gen_project),
+    ("rejects duplicate", test_rejects_duplicate),
+    ("rejects unknown task type", test_rejects_unknown_task_type),
+]
+
+
+def main() -> int:
+    failed = 0
+    for name, fn in TESTS:
+        try:
+            fn()
+            print(f"PASS  {name}")
+        except Exception as e:
+            failed += 1
+            print(f"FAIL  {name}: {type(e).__name__}: {e}")
+    print(f"\n{len(TESTS) - failed}/{len(TESTS)} passed")
+    return 0 if failed == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.claude/skills/video-clone/scripts/kling_generate.py

@@ -0,0 +1,262 @@
+"""Phase 3: generate video with audio via the Optima generation backend.
+
+The generation backend routes to Kling 3.0 (PiAPI) when provider="piapi".
+Billing is automatic — the server's billing middleware deducts credits from
+the user's Optima wallet at submit time and refunds on task failure.
+
+Usage:
+    python scripts/kling_generate.py --project <name> --frame <path> \
+        [--duration 10] [--aspect-ratio 9:16] [--mode std] \
+        [--cfg-scale 0.5] [--no-audio]
+
+Auth & API URL discovery (matches @optima-chat/gen-cli convention):
+    Token:
+        1. OPTIMA_TOKEN env var
+        2. ~/.optima/token.json ("access_token" field)
+    Generation API URL:
+        1. GENERATION_API_URL env var
+        2. ~/.optima/token.json ("env" field) → ci/stage/prod mapping
+        3. default: prod (https://gen-api.optima.onl)
+
+A logged-in user (`optima login`) has both automatically; no server-side
+env injection is required.
+
+Pipeline:
+    1. Gate: requires preview_confirmed.
+    2. POST <GEN_URL>/api/video/generate with provider="piapi" + base64 frame.
+       Server-side billing middleware pre-deducts credits here.
+    3. Poll GET <GEN_URL>/api/task/{id} every 10s until completed/failed.
+    4. Download result_url to <project>/videos/ (3-attempt retry).
+
+Reads prompt from <project>/prompt.md. Writes output with a versioned filename.
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+from _gate import require_gate
+from _project import resolve_project, next_version, append_log
+
+try:
+    import requests  # type: ignore
+except ImportError:  # pragma: no cover
+    requests = None
+
+POLL_INTERVAL_S = 10
+POLL_TIMEOUT_S = 15 * 60  # 15 min (server side uses 10 min, leave 5 min headroom)
+DOWNLOAD_RETRIES = 3
+DOWNLOAD_BACKOFF_S = 5
+
+TOKEN_FILE = Path.home() / ".optima" / "token.json"
+API_URLS = {
+    "prod": "https://gen-api.optima.onl",
+    "stage": "https://gen-api.stage.optima.onl",
+}
+
+
+def _load_token_file() -> dict | None:
+    """Read ~/.optima/token.json if present. Returns parsed dict or None."""
+    if not TOKEN_FILE.is_file():
+        return None
+    try:
+        data = json.loads(TOKEN_FILE.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not data.get("access_token"):
+        return None
+    return data
+
+
+def _get_token() -> str:
+    """Resolve the Optima auth token.
+
+    Order matches @optima-chat/gen-cli: env var > token.json. Fail fast with
+    a login hint if neither is available.
+    """
+    env_token = os.environ.get("OPTIMA_TOKEN", "").strip()
+    if env_token:
+        return env_token
+    data = _load_token_file()
+    if data:
+        return data["access_token"]
+    print(
+        "ERROR: Optima token not found. Set OPTIMA_TOKEN or run `optima login`.",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+
+def _get_gen_api_url() -> str:
+    """Resolve the generation service base URL.
+
+    Order matches @optima-chat/gen-cli: GENERATION_API_URL > token.json env
+    field > prod default.
+    """
+    override = os.environ.get("GENERATION_API_URL", "").strip()
+    if override:
+        return override.rstrip("/")
+    data = _load_token_file()
+    env = (data or {}).get("env") or "prod"
+    return API_URLS.get(env, API_URLS["prod"])
+
+
+def _auth_header(token: str) -> str:
+    """Accept either 'Bearer xxx' or a raw token; normalize to Bearer form."""
+    return token if token.lower().startswith("bearer ") else f"Bearer {token}"
+
+
+def _submit(gen_url: str, auth: str, prompt: str, frame_b64: str,
+            duration: int, aspect: str, mode: str,
+            cfg: float, audio: bool) -> str:
+    """POST /api/video/generate with provider='piapi'. Returns backend task_id.
+
+    On billing failure the server returns 402 (INSUFFICIENT_CREDITS) or
+    403 (PLAN_RESTRICTED); both are surfaced as actionable errors.
+    """
+    payload = {
+        "provider": "piapi",
+        "image": frame_b64,
+        "prompt": prompt,
+        "duration": duration,
+        "aspect_ratio": aspect,
+        "mode": mode,
+        "cfg_scale": float(cfg),
+        "enable_audio": audio,
+    }
+    r = requests.post(
+        f"{gen_url}/api/video/generate",
+        headers={"Authorization": auth, "Content-Type": "application/json"},
+        json=payload, timeout=60,
+    )
+    if r.status_code == 402:
+        raise RuntimeError(f"INSUFFICIENT_CREDITS: {r.json().get('error', {}).get('message', 'not enough credits')}")
+    if r.status_code == 403:
+        raise RuntimeError(f"PLAN_RESTRICTED: {r.json().get('error', {}).get('message', 'plan does not include video generation')}")
+    r.raise_for_status()
+    return r.json()["task_id"]
+
+
+def _poll(gen_url: str, auth: str, task_id: str) -> tuple[str, dict]:
+    """Poll /api/task/{id} until completed or failed. Returns (result_url, result_meta).
+
+    On client-side timeout the task may still complete server-side (credits
+    already deducted). The task_id is included in the timeout message so the
+    caller can re-check later via GET /api/task/<id>.
+    """
+    start = time.monotonic()
+    while True:
+        if time.monotonic() - start > POLL_TIMEOUT_S:
+            raise RuntimeError(
+                f"polling timed out after {POLL_TIMEOUT_S}s (task_id={task_id}). "
+                f"Task may still complete server-side — query "
+                f"GET /api/task/{task_id} to check status and retrieve the result."
+            )
+        r = requests.get(
+            f"{gen_url}/api/task/{task_id}",
+            headers={"Authorization": auth}, timeout=60,
+        )
+        r.raise_for_status()
+        d = r.json()
+        status = d.get("status", "")
+        if status == "completed":
+            url = d.get("result_url")
+            if not url:
+                raise RuntimeError(
+                    f"task {task_id} completed but result_url missing from response"
+                )
+            return url, d.get("result_meta") or {}
+        if status == "failed":
+            raise RuntimeError(d.get("error_message") or f"task {task_id} failed without error message")
+        print(f"  status: {status} — polling again in {POLL_INTERVAL_S}s")
+        time.sleep(POLL_INTERVAL_S)
+
+
+def _download(url: str, out: Path) -> None:
+    last_err = None
+    for attempt in range(DOWNLOAD_RETRIES):
+        try:
+            r = requests.get(url, timeout=300)
+            r.raise_for_status()
+            out.write_bytes(r.content)
+            return
+        except Exception as e:
+            last_err = e
+            print(f"  download attempt {attempt + 1}/{DOWNLOAD_RETRIES} failed: {e}")
+            time.sleep(DOWNLOAD_BACKOFF_S)
+    raise RuntimeError(f"download failed after {DOWNLOAD_RETRIES} attempts: {last_err}")
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--project", required=True)
+    ap.add_argument("--frame", required=True, help="confirmed first frame")
+    ap.add_argument("--duration", type=int, default=10, choices=[5, 10])
+    ap.add_argument("--aspect-ratio", default="9:16")
+    ap.add_argument("--mode", default="std", choices=["std", "pro"])
+    ap.add_argument("--cfg-scale", type=float, default=0.5)
+    ap.add_argument("--no-audio", action="store_true")
+    args = ap.parse_args()
+
+    project_dir = resolve_project(args.project)
+    require_gate(project_dir, "preview_confirmed")
+
+    if requests is None:
+        print("ERROR: the 'requests' package is required. Install: pip install requests",
+              file=sys.stderr)
+        return 1
+
+    gen_url = _get_gen_api_url()
+    auth = _auth_header(_get_token())
+
+    frame = Path(args.frame)
+    if not frame.is_file():
+        print(f"ERROR: frame not found at {frame}", file=sys.stderr)
+        return 1
+
+    prompt_path = project_dir / "prompt.md"
+    if not prompt_path.is_file():
+        print(f"ERROR: {prompt_path} missing. Write prompt.md first.", file=sys.stderr)
+        return 1
+    prompt = prompt_path.read_text(encoding="utf-8").strip()
+
+    frame_b64 = base64.b64encode(frame.read_bytes()).decode()
+
+    print("Submitting video generation task …")
+    try:
+        task_id = _submit(
+            gen_url, auth, prompt, frame_b64,
+            duration=args.duration, aspect=args.aspect_ratio, mode=args.mode,
+            cfg=args.cfg_scale, audio=not args.no_audio,
+        )
+    except RuntimeError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 1
+    print(f"  task_id: {task_id}")
+
+    print("Polling for completion …")
+    try:
+        result_url, result_meta = _poll(gen_url, auth, task_id)
+    except RuntimeError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return 1
+    print(f"  result_url: {result_url}")
+    if result_meta:
+        print(f"  result_meta: {result_meta}")
+
+    out = next_version(project_dir / "videos", f"video_{args.duration}s_", ".mp4")
+    print(f"Downloading → {out}")
+    _download(result_url, out)
+
+    print(f"\nDone: {out}")
+    append_log(project_dir, f"video_generated_with_audio → {out.name} (task {task_id})")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.claude/skills/video-clone/scripts/kling_generate_test.py

@@ -0,0 +1,191 @@
+"""Tests for the pure helper functions in kling_generate.py.
+
+No network. We do not exercise _submit / _poll / _download — those are
+I/O-bound and covered by end-to-end staging runs. Unit tests here keep the
+helper contracts honest so refactors don't silently break the auth-header
+normalization or the token / API-URL discovery order.
+
+Run: python scripts/kling_generate_test.py
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from unittest import mock
+
+SCRIPTS_DIR = Path(__file__).parent
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+import kling_generate  # noqa: E402
+
+
+# ---------- _auth_header ----------
+
+def test_auth_header_adds_bearer_prefix():
+    assert kling_generate._auth_header("xyz123") == "Bearer xyz123"
+
+
+def test_auth_header_preserves_existing_bearer():
+    assert kling_generate._auth_header("Bearer xyz123") == "Bearer xyz123"
+
+
+def test_auth_header_is_case_insensitive_on_existing_prefix():
+    assert kling_generate._auth_header("bearer xyz123") == "bearer xyz123"
+    assert kling_generate._auth_header("BEARER xyz123") == "BEARER xyz123"
+
+
+# ---------- _get_token ----------
+
+def test_get_token_prefers_env_var(tmp_token_file):
+    tmp_token_file.write_text(
+        json.dumps({"access_token": "from-file", "env": "prod"}), encoding="utf-8"
+    )
+    os.environ["OPTIMA_TOKEN"] = "from-env"
+    try:
+        assert kling_generate._get_token() == "from-env"
+    finally:
+        os.environ.pop("OPTIMA_TOKEN", None)
+
+
+def test_get_token_falls_back_to_file(tmp_token_file):
+    os.environ.pop("OPTIMA_TOKEN", None)
+    tmp_token_file.write_text(
+        json.dumps({"access_token": "file-xyz", "env": "stage"}), encoding="utf-8"
+    )
+    assert kling_generate._get_token() == "file-xyz"
+
+
+def test_get_token_exits_when_neither_source_has_token(tmp_token_file):
+    os.environ.pop("OPTIMA_TOKEN", None)
+    # tmp_token_file does not exist (fixture creates parent, caller decides)
+    # Here: don't create the file — _load_token_file should return None
+    code = (
+        "import sys; sys.path.insert(0, r'{d}'); import kling_generate; "
+        "kling_generate._get_token()"
+    ).format(d=str(SCRIPTS_DIR))
+    env = {**os.environ}
+    env.pop("OPTIMA_TOKEN", None)
+    env["HOME"] = str(tmp_token_file.parent.parent)   # .../.optima/token.json → HOME = .../
+    env["USERPROFILE"] = env["HOME"]
+    result = subprocess.run(
+        [sys.executable, "-c", code], capture_output=True, text=True, env=env,
+    )
+    assert result.returncode == 1
+    assert "optima login" in result.stderr or "OPTIMA_TOKEN" in result.stderr
+
+
+# ---------- _get_gen_api_url ----------
+
+def test_get_gen_api_url_env_override_wins(tmp_token_file):
+    tmp_token_file.write_text(
+        json.dumps({"access_token": "t", "env": "stage"}), encoding="utf-8"
+    )
+    os.environ["GENERATION_API_URL"] = "https://custom.example/api"
+    try:
+        assert kling_generate._get_gen_api_url() == "https://custom.example/api"
+    finally:
+        os.environ.pop("GENERATION_API_URL", None)
+
+
+def test_get_gen_api_url_trims_trailing_slash():
+    os.environ["GENERATION_API_URL"] = "https://custom.example/"
+    try:
+        assert kling_generate._get_gen_api_url() == "https://custom.example"
+    finally:
+        os.environ.pop("GENERATION_API_URL", None)
+
+
+def test_get_gen_api_url_reads_env_from_token_file(tmp_token_file):
+    os.environ.pop("GENERATION_API_URL", None)
+    tmp_token_file.write_text(
+        json.dumps({"access_token": "t", "env": "stage"}), encoding="utf-8"
+    )
+    assert kling_generate._get_gen_api_url() == "https://gen-api.stage.optima.onl"
+
+
+def test_get_gen_api_url_defaults_to_prod_when_no_file(tmp_token_file):
+    os.environ.pop("GENERATION_API_URL", None)
+    # tmp_token_file not created → should default to prod
+    assert kling_generate._get_gen_api_url() == "https://gen-api.optima.onl"
+
+
+# ---------- fixture ----------
+
+class _TmpToken:
+    """Manage a throwaway ~/.optima/token.json by monkey-patching the module constant."""
+    def __init__(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.path = Path(self.tmp.name) / ".optima" / "token.json"
+        self.path.parent.mkdir(parents=True)
+        self._orig = kling_generate.TOKEN_FILE
+        kling_generate.TOKEN_FILE = self.path
+
+    def write_text(self, *a, **kw):
+        self.path.write_text(*a, **kw)
+
+    @property
+    def parent(self):
+        return self.path.parent
+
+    def cleanup(self):
+        kling_generate.TOKEN_FILE = self._orig
+        self.tmp.cleanup()
+
+
+def _with_tmp_token_file(fn):
+    """Decorator-ish: pass a fresh _TmpToken to the test, then clean up."""
+    def wrapped():
+        h = _TmpToken()
+        try:
+            return fn(h)
+        finally:
+            h.cleanup()
+    return wrapped
+
+
+# Rebind each test to wrap with the fixture
+test_get_token_prefers_env_var = _with_tmp_token_file(test_get_token_prefers_env_var)
+test_get_token_falls_back_to_file = _with_tmp_token_file(test_get_token_falls_back_to_file)
+test_get_token_exits_when_neither_source_has_token = _with_tmp_token_file(test_get_token_exits_when_neither_source_has_token)
+test_get_gen_api_url_env_override_wins = _with_tmp_token_file(test_get_gen_api_url_env_override_wins)
+test_get_gen_api_url_reads_env_from_token_file = _with_tmp_token_file(test_get_gen_api_url_reads_env_from_token_file)
+test_get_gen_api_url_defaults_to_prod_when_no_file = _with_tmp_token_file(test_get_gen_api_url_defaults_to_prod_when_no_file)
+
+
+TESTS = [
+    ("auth_header adds Bearer prefix", test_auth_header_adds_bearer_prefix),
+    ("auth_header preserves Bearer", test_auth_header_preserves_existing_bearer),
+    ("auth_header case-insensitive on prefix", test_auth_header_is_case_insensitive_on_existing_prefix),
+    ("get_token: env wins over file", test_get_token_prefers_env_var),
+    ("get_token: falls back to token.json", test_get_token_falls_back_to_file),
+    ("get_token: exits 1 when neither source", test_get_token_exits_when_neither_source_has_token),
+    ("get_gen_api_url: env override wins", test_get_gen_api_url_env_override_wins),
+    ("get_gen_api_url: trims trailing slash", test_get_gen_api_url_trims_trailing_slash),
+    ("get_gen_api_url: reads env from token.json", test_get_gen_api_url_reads_env_from_token_file),
+    ("get_gen_api_url: defaults to prod", test_get_gen_api_url_defaults_to_prod_when_no_file),
+]
+
+
+def main() -> int:
+    failed = 0
+    for name, fn in TESTS:
+        try:
+            fn()
+            print(f"PASS  {name}")
+        except AssertionError as e:
+            failed += 1
+            print(f"FAIL  {name}: {e}")
+        except Exception as e:
+            failed += 1
+            print(f"ERROR {name}: {type(e).__name__}: {e}")
+    print()
+    print(f"{len(TESTS) - failed}/{len(TESTS)} passed")
+    return 0 if failed == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.claude/skills/video-clone/scripts/preflight.py

@@ -0,0 +1,102 @@
+"""Pre-flight environment check for the video-clone skill.
+
+Verifies the external dependencies the executor scripts will need:
+    - `gen` CLI       — gen image / gen video (routed through generation backend)
+    - `ffmpeg` / `ffprobe`
+    - Optima auth     — either OPTIMA_TOKEN env var or ~/.optima/token.json
+                        (matches @optima-chat/gen-cli convention)
+    - Python >= 3.10
+
+Exits 0 if all checks pass, 1 otherwise. On failure, prints a human-readable
+list of missing items and how to fix each one.
+
+This script is safe to run any time — it only reads env and probes binaries.
+No state, no side effects.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+TOKEN_FILE = Path.home() / ".optima" / "token.json"
+
+
+def _check_binary(name: str, fix_hint: str) -> tuple[bool, str]:
+    path = shutil.which(name)
+    if path is None:
+        return False, f"{name}: NOT FOUND. {fix_hint}"
+    # probe --version for extra confidence (non-blocking if version flag missing)
+    try:
+        r = subprocess.run(
+            [name, "--version"], capture_output=True, text=True, timeout=5
+        )
+        head = (r.stdout or r.stderr).splitlines()[0] if (r.stdout or r.stderr) else ""
+    except Exception:
+        head = ""
+    return True, f"{name}: OK ({path}) {head}".strip()
+
+
+def _check_optima_auth() -> tuple[bool, str]:
+    """Token comes from OPTIMA_TOKEN env var OR ~/.optima/token.json (gen-cli convention)."""
+    if os.environ.get("OPTIMA_TOKEN"):
+        return True, "Optima token: OK (source=env OPTIMA_TOKEN)"
+    if TOKEN_FILE.is_file():
+        try:
+            data = json.loads(TOKEN_FILE.read_text(encoding="utf-8"))
+            if data.get("access_token"):
+                env = data.get("env", "prod")
+                return True, f"Optima token: OK (source={TOKEN_FILE}, env={env})"
+        except (OSError, json.JSONDecodeError):
+            pass
+    return (
+        False,
+        f"Optima token: NOT FOUND. Run `optima login` or set OPTIMA_TOKEN env var.",
+    )
+
+
+def _check_python() -> tuple[bool, str]:
+    v = sys.version_info
+    ok = (v.major, v.minor) >= (3, 10)
+    msg = f"python: {v.major}.{v.minor}.{v.micro}"
+    if not ok:
+        msg += " — NEED >= 3.10"
+    return ok, msg + (" OK" if ok else "")
+
+
+CHECKS = [
+    lambda: _check_python(),
+    lambda: _check_binary(
+        "gen",
+        "Install the gen CLI and ensure it is on PATH. (gen image / gen video)",
+    ),
+    lambda: _check_binary("ffmpeg", "Install ffmpeg and ensure it is on PATH."),
+    lambda: _check_binary("ffprobe", "Install ffmpeg (bundles ffprobe)."),
+    lambda: _check_optima_auth(),
+]
+
+
+def main() -> int:
+    results = [check() for check in CHECKS]
+    missing = [msg for ok, msg in results if not ok]
+    passing = [msg for ok, msg in results if ok]
+
+    print("== video-clone preflight ==")
+    for msg in passing:
+        print(f"  [OK]    {msg}")
+    for msg in missing:
+        print(f"  [FAIL]  {msg}")
+    print()
+
+    if missing:
+        print(f"{len(missing)} check(s) failed. Fix the above and re-run.")
+        return 1
+    print("All checks passed.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())