Main CLI

scripts/freestream.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python
+# FREESTREAM — universal free-tier avatar-meeting skill.
+#
+# Clean-room reimplementation, CLI-compatible with:
+#   Pika-Labs/Pika-Skills — pikastream-video-meeting (Apache-2.0)
+#
+# Exit codes (Pika-compatible, one addition):
+#   0 = ok
+#   1 = configuration error (FREESTREAM-specific: invalid config file / no driver)
+#   2 = validation error
+#   3 = transport error
+#   4 = session error
+#   5 = timeout
+#   6 = capability shortfall (repurposed from Pika's "funding":
+#       stdout JSON carries "capability" and "remediation" instead of "checkout_url")
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+# Make the freestream package importable when run from the repo checkout.
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from freestream.events import EventLog
+from freestream.presence import (
+    CapabilityShortfall,
+    DriverError,
+    ValidationError,
+    get_driver,
+    infer_platform,
+    list_drivers,
+)
+from freestream.persona import FidelityRung, VoiceBackend, select_rung
+
+SKILL_DIR = Path(__file__).resolve().parent.parent
+DEFAULT_IMAGE = SKILL_DIR / "assets" / "placeholder-avatar.jpg"
+DEFAULT_VOICE = "piper-en_US-amy-medium"
+SESSIONS_DIR = SKILL_DIR / ".freestream" / "sessions"
+
+EX_OK, EX_CONFIG, EX_VALIDATION, EX_TRANSPORT, EX_SESSION, EX_TIMEOUT, EX_CAPABILITY = 0, 1, 2, 3, 4, 5, 6
+
+
+def eprint(*a):
+    print(*a, file=sys.stderr)
+
+
+def emit(obj: dict) -> None:
+    print(json.dumps(obj))
+    sys.stdout.flush()
+
+
+def resolve_voice(voice_id: str | None) -> str:
+    """Pika-compatible voice resolution: flag > life/voice_id.txt > default."""
+    if voice_id:
+        return voice_id
+    life_file = Path("life") / "voice_id.txt"
+    if life_file.exists():
+        cached = life_file.read_text().strip()
+        if cached:
+            return cached
+    return DEFAULT_VOICE
+
+
+# --------------------------------------------------------------------------- join
+
+
+def cmd_join(args) -> int:
+    if not args.meet_url.startswith(("http://", "https://")):
+        eprint(f"Error: not a meeting URL: {args.meet_url}")
+        return EX_VALIDATION
+
+    platform = args.platform or infer_platform(args.meet_url)
+    if not platform:
+        eprint("Error: can't infer platform from URL; pass --platform")
+        return EX_VALIDATION
+
+    image = Path(args.image or str(DEFAULT_IMAGE))
+    if not image.exists() or image.stat().st_size < 1024:
+        eprint(f"Error: avatar image missing or too small (<1KB): {image}")
+        return EX_VALIDATION
+
+    system_prompt = args.system_prompt
+    if args.system_prompt_file:
+        sp = Path(args.system_prompt_file)
+        if not sp.exists():
+            eprint(f"Error: system prompt file not found: {sp}")
+            return EX_VALIDATION
+        system_prompt = sp.read_text().strip()
+
+    voice = resolve_voice(args.voice_id)
+
+    # ---- driver selection -------------------------------------------------
+    driver_name = args.driver
+    if driver_name and driver_name not in list_drivers():
+        eprint(f"Error: unknown presence driver '{driver_name}'. Available: {', '.join(sorted(list_drivers()))}")
+        return EX_CONFIG
+    if not driver_name:
+        driver_name = "livekit" if platform == "livekit" else "browser"
+        eprint(f"No --driver given; selected '{driver_name}' for platform '{platform}'")
+
+    # ---- capability negotiation ------------------------------------------
+    backend = VoiceBackend(voice)
+    rung = select_rung(prefer_gpu=not args.cpu_only)
+    eprint(f"Fidelity rung: {rung.name} | voice: {backend.name}")
+
+    session_root = SESSIONS_DIR / f"pending-{int(__import__('time').time())}"
+    session_root.mkdir(parents=True, exist_ok=True)
+    log = EventLog(session_root / "events.jsonl")
+    log.append("session.requested", platform=platform, driver=driver_name, bot_name=args.bot_name,
+               voice=voice, rung=rung.name, meet_url=args.meet_url)
+
+    try:
+        drv = get_driver(driver_name, log=log)
+        sid = drv.join(
+            meet_url=args.meet_url,
+            platform=platform,
+            bot_name=args.bot_name,
+            image=image,
+            voice=voice,
+            system_prompt=system_prompt,
+            meeting_password=args.meeting_password,
+        )
+    except ValidationError as e:
+        eprint(f"Error: {e}")
+        return EX_VALIDATION
+    except CapabilityShortfall as e:
+        emit({"status": "capability_shortfall", "capability": e.capability,
+              "remediation": e.remediation, "driver": driver_name})
+        return EX_CAPABILITY
+    except DriverError as e:
+        eprint(f"Error: transport: {e}")
+        return EX_TRANSPORT
+    except NotImplementedError as e:
+        eprint(f"Error: driver '{driver_name}' not implemented in this scaffold: {e}")
+        emit({"status": "not_implemented", "driver": driver_name,
+              "note": "MVP slice targets the livekit driver (Jitsi/LiveKit)"})
+        return EX_CONFIG
+
+    # Rename the session directory to the real id so replay paths are stable.
+    session_root = session_root.rename(SESSIONS_DIR / sid)
+
+    # Pika-compatible first output: emitted immediately so the agent can capture it.
+    emit({"session_id": sid, "platform": platform, "status": "created"})
+    log.append("session.created", session_id=sid, driver=driver_name)
+
+    # ---- poll until ready (Pika-compatible status stream) -----------------
+    deadline = __import__("time").time() + args.timeout_sec
+    last_status = None
+    while __import__("time").time() < deadline:
+        __import__("time").sleep(2)
+        status = drv.status(sid)
+        if status != last_status:
+            emit({"session_id": sid, "status": status, "video": drv.video_connected(sid),
+                  "bot": drv.bot_connected(sid)})
+            last_status = status
+            log.append("session.status", status=status)
+        if status == "ready":
+            log.append("session.ready", session_id=sid)
+            return EX_OK
+        if status in ("error", "closed"):
+            log.append("session.failed", status=status)
+            return EX_SESSION
+
+    eprint("Error: timeout")
+    log.append("session.timeout")
+    return EX_TIMEOUT
+
+
+# --------------------------------------------------------------------------- leave
+
+
+def cmd_leave(args) -> int:
+    drv = get_driver(args.driver or "browser")
+    try:
+        drv.leave(args.session_id)
+    except CapabilityShortfall as e:
+        emit({"status": "capability_shortfall", "capability": e.capability, "remediation": e.remediation})
+        return EX_CAPABILITY
+    except DriverError as e:
+        eprint(f"Error: transport: {e}")
+        return EX_TRANSPORT
+    emit({"session_id": args.session_id, "closed": True})
+    return EX_OK
+
+
+# --------------------------------------------------------------------------- generate-avatar
+
+
+def cmd_generate_avatar(args) -> int:
+    out = Path(args.output)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    prompt = args.prompt or ("A friendly, approachable portrait headshot of a virtual assistant "
+                             "avatar. Clean background, warm expression, centered face, suitable "
+                             "for video calls.")
+
+    # Local-first: bundled placeholder avatar, unless a generation backend exists.
+    local_gen = None
+    try:
+        import freestream.avatar_gen as avatar_gen  # optional module, heavy deps
+        local_gen = avatar_gen.available()
+    except ImportError:
+        pass
+
+    if local_gen:
+        path = local_gen.generate(prompt, out)
+        emit({"path": str(path), "size_bytes": Path(path).stat().st_size})
+        return EX_OK
+
+    if DEFAULT_IMAGE.exists():
+        import shutil
+        shutil.copyfile(DEFAULT_IMAGE, out)
+        eprint("No local image-generation backend available; copied bundled placeholder avatar.")
+        emit({"path": str(out), "size_bytes": out.stat().st_size, "generated": False})
+        return EX_OK
+
+    emit({"status": "capability_shortfall", "capability": "image_generation",
+          "remediation": "install a local backend (e.g. `pip install freestream[avatar-gen]`) "
+                         "or place a portrait at assets/placeholder-avatar.jpg"})
+    return EX_CAPABILITY
+
+
+# --------------------------------------------------------------------------- clone-voice
+
+
+def cmd_clone_voice(args) -> int:
+    audio = Path(args.audio)
+    if not audio.exists():
+        eprint(f"Error: audio file not found: {audio}")
+        return EX_VALIDATION
+
+    backend = VoiceBackend(args.name)
+    try:
+        result = backend.clone(audio, name=args.name, noise_reduction=args.noise_reduction)
+    except CapabilityShortfall as e:
+        emit({"status": "capability_shortfall", "capability": e.capability, "remediation": e.remediation})
+        return EX_CAPABILITY
+
+    # Pika-compatible identity files (local-only; clones never leave the device).
+    life = Path("life")
+    life.mkdir(parents=True, exist_ok=True)
+    (life / "voice_id.txt").write_text(result["voice_id"])
+    import json as _json
+    (life / "voice_config.json").write_text(_json.dumps(result, indent=2))
+
+    emit(result)
+    return EX_OK
+
+
+# --------------------------------------------------------------------------- probe
+
+
+def cmd_probe(args) -> int:
+    """Capability negotiation: report the best pipeline for this hardware."""
+    import platform as _platform
+    probe = {
+        "platform": _platform.system(),
+        "machine": _platform.machine(),
+        "drivers": sorted(list_drivers()),
+        "voice": VoiceBackend.probe(),
+        "fidelity_rung": select_rung(prefer_gpu=not args.cpu_only).name,
+        "gpu": probe_gpu(),
+        "exit_code_meanings": {
+            "0": "ok", "1": "configuration", "2": "validation", "3": "transport",
+            "4": "session", "5": "timeout", "6": "capability_shortfall",
+        },
+    }
+    emit(probe)
+    return EX_OK
+
+
+def probe_gpu() -> dict:
+    info = {"cuda": False, "mps": False, "ane": False}
+    try:
+        import torch  # optional
+        info["cuda"] = bool(torch.cuda.is_available())
+        info["mps"] = bool(getattr(torch.backends, "mps", None) and torch.backends.mps.is_available())
+        info["torch"] = torch.__version__
+    except ImportError:
+        pass
+    return info
+
+
+# --------------------------------------------------------------------------- main
+
+
+def main():
+    p = argparse.ArgumentParser(prog="freestream",
+                                description="Free-tier avatar-meeting skill (Pika-CLI-compatible)")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    j = sub.add_parser("join")
+    j.add_argument("--meet-url", required=True)
+    j.add_argument("--platform", choices=["google_meet", "zoom", "jitsi", "livekit"])
+    j.add_argument("--driver", help="presence driver: browser | livekit | sip")
+    j.add_argument("--bot-name", required=True)
+    j.add_argument("--voice-id")
+    j.add_argument("--meeting-password")
+    j.add_argument("--system-prompt", help="System prompt text for the meeting agent")
+    j.add_argument("--system-prompt-file", help="Path to file containing system prompt")
+    j.add_argument("--image")
+    j.add_argument("--timeout-sec", type=int, default=90)
+    j.add_argument("--cpu-only", action="store_true", help="Force the fidelity ladder to CPU rungs")
+    j.set_defaults(func=cmd_join)
+
+    lv = sub.add_parser("leave")
+    lv.add_argument("--session-id", required=True)
+    lv.add_argument("--driver")
+    lv.set_defaults(func=cmd_leave)
+
+    ga = sub.add_parser("generate-avatar")
+    ga.add_argument("--output", required=True)
+    ga.add_argument("--prompt", help="Custom prompt for avatar generation")
+    ga.add_argument("--model", default="local", help="[compat] ignored; kept for Pika CLI parity")
+    ga.set_defaults(func=cmd_generate_avatar)
+
+    cv = sub.add_parser("clone-voice")
+    cv.add_argument("--audio", required=True, help="Audio file (10s-5min, clear speech)")
+    cv.add_argument("--name", required=True)
+    cv.add_argument("--noise-reduction", action="store_true")
+    cv.set_defaults(func=cmd_clone_voice)
+
+    pr = sub.add_parser("probe")
+    pr.add_argument("--cpu-only", action="store_true")
+    pr.set_defaults(func=cmd_probe)
+
+    args = p.parse_args()
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())