Blame for scripts/freestream.py

#!/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 (
    SESSIONS_DIR,
    CapabilityShortfall,
    DriverError,
    ValidationError,
    get_driver,
    infer_platform,
    list_drivers,
    shutdown_session,
)
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"

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_id = __import__("uuid").uuid4().hex[:12]
    session_root = SESSIONS_DIR / session_id
    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,
            session_id=session_id,
            session_dir=session_root,
        )
    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.
    sid = session_id
    # 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" or status in ("speaking", "thinking", "listening"):
            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:
    try:
        detail = shutdown_session(args.session_id)
    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 procedural avatar (freestream.avatar) — no model,
    # no network, always available. A heavy local generator can plug in later.
    try:
        import freestream.avatar as avatar_mod
    except ImportError:
        avatar_mod = None

    if avatar_mod is not None:
        path = avatar_mod.generate_placeholder(out)
        emit({"path": str(path), "size_bytes": Path(path).stat().st_size,
              "generated": True, "generator": "procedural-face"})
        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())