MVP: CLI wired to LiveKit driver + procedural avatar

scripts/freestream.py

@@ -26,19 +26,20 @@ 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"
-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
 
@@ -106,7 +107,8 @@ def cmd_join(args) -> int:
     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_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,
@@ -122,6 +124,8 @@ def cmd_join(args) -> int:
             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}")
@@ -140,8 +144,7 @@ def cmd_join(args) -> int:
         return EX_CONFIG
 
     # Rename the session directory to the real id so replay paths are stable.
-    session_root = session_root.rename(SESSIONS_DIR / sid)
-
+    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)
@@ -157,7 +160,7 @@ def cmd_join(args) -> int:
                   "bot": drv.bot_connected(sid)})
             last_status = status
             log.append("session.status", status=status)
-        if status == "ready":
+        if status == "ready" or status in ("speaking", "thinking", "listening"):
             log.append("session.ready", session_id=sid)
             return EX_OK
         if status in ("error", "closed"):
@@ -173,12 +176,8 @@ def cmd_join(args) -> int:
 
 
 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
+        detail = shutdown_session(args.session_id)
     except DriverError as e:
         eprint(f"Error: transport: {e}")
         return EX_TRANSPORT
@@ -196,24 +195,17 @@ def cmd_generate_avatar(args) -> int:
                              "avatar. Clean background, warm expression, centered face, suitable "
                              "for video calls.")
 
-    # Local-first: bundled placeholder avatar, unless a generation backend exists.
-    local_gen = None
+    # 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_gen as avatar_gen  # optional module, heavy deps
-        local_gen = avatar_gen.available()
+        import freestream.avatar as avatar_mod
     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
+        avatar_mod = None
 
-    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})
+    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",