MVP: CLI wired to LiveKit driver + procedural avatar

13e846a verified about 1 month ago

12 kB

#!/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())

	#!/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())