infinicode 2.8.13 → 2.8.16

package/packages/robopark/pi-client/client.py

@@ -0,0 +1,305 @@
+# RoboPark Pi Client
+# Run on the Raspberry Pi (or any device) to:
+#   1. Enroll with the scheduler (first boot) using --enrollment-token
+#   2. Persist device_id + device_token to --state-file (default ./device.json)
+#   3. Heartbeat every --heartbeat-interval seconds
+#   4. Join a LiveKit room (if `livekit` SDK is installed) to publish mic + camera
+#      and subscribe to the agent's data channel for motor commands
+#   5. Forward motor commands to the local RoboVisionAI_PI motor server
+#
+# Quick start:
+#   python client.py \
+#     --scheduler-url http://100.64.1.5:8080 \
+#     --enrollment-token <TOKEN-FROM-SCHEDULER-LOGS> \
+#     --name pipi \
+#     --tailscale-ip 100.64.1.10 \
+#     --lan-ip 192.168.1.159 \
+#     --motor-server-url http://192.168.1.159:8001 \
+#     --livekit-url ws://100.64.1.5:7880
+#
+# Subsequent runs (token is in device.json):
+#   python client.py --scheduler-url http://100.64.1.5:8080
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import signal
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from motor_bridge import MotorBridge
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+log = logging.getLogger("robopark-pi")
+
+
+class PiClient:
+    def __init__(self, args: argparse.Namespace):
+        self.scheduler_url = args.scheduler_url.rstrip("/")
+        self.state_file = Path(args.state_file)
+        self.enrollment_token = args.enrollment_token
+        self.name = args.name
+        self.tailscale_ip = args.tailscale_ip
+        self.lan_ip = args.lan_ip
+        self.motor_server_url = args.motor_server_url
+        self.livekit_url = args.livekit_url
+        self.character_id = args.character_id
+        self.heartbeat_interval = args.heartbeat_interval
+        self.config_poll_interval = args.config_poll_interval
+        self.join_room = args.join_room
+        self.room_name = args.room_name
+
+        self.device_id: Optional[str] = None
+        self.device_token: Optional[str] = None
+        self.production_mode: bool = False
+        self.motor_bridge = MotorBridge(self.motor_server_url, dry_run=args.dry_run_motors)
+
+        self._stop = asyncio.Event()
+        self._lk_task: Optional[asyncio.Task] = None
+
+    # ---- credential persistence ----------------------------------------
+
+    def _load_state(self) -> bool:
+        if not self.state_file.exists():
+            return False
+        try:
+            data = json.loads(self.state_file.read_text())
+            self.device_id = data.get("device_id")
+            self.device_token = data.get("device_token")
+            # allow CLI overrides to backfill missing fields from a stale state file
+            if not self.tailscale_ip: self.tailscale_ip = data.get("tailscale_ip")
+            if not self.lan_ip: self.lan_ip = data.get("lan_ip")
+            if not self.motor_server_url: self.motor_server_url = data.get("motor_server_url")
+            if not self.livekit_url: self.livekit_url = data.get("livekit_url")
+            if not self.character_id: self.character_id = data.get("character_id")
+            if not self.name: self.name = data.get("name")
+            return bool(self.device_id and self.device_token)
+        except Exception as e:
+            log.warning(f"Could not load state file {self.state_file}: {e}")
+            return False
+
+    def _save_state(self):
+        data = {
+            "device_id": self.device_id,
+            "device_token": self.device_token,
+            "name": self.name,
+            "tailscale_ip": self.tailscale_ip,
+            "lan_ip": self.lan_ip,
+            "motor_server_url": self.motor_server_url,
+            "livekit_url": self.livekit_url,
+            "character_id": self.character_id,
+            "saved_at": time.time(),
+        }
+        self.state_file.parent.mkdir(parents=True, exist_ok=True)
+        self.state_file.write_text(json.dumps(data, indent=2))
+        try:
+            os.chmod(self.state_file, 0o600)
+        except Exception:
+            pass
+        log.info(f"Saved credentials to {self.state_file}")
+
+    # ---- scheduler API --------------------------------------------------
+
+    async def enroll(self):
+        body = {
+            "enrollment_token": self.enrollment_token,
+            "name": self.name,
+            "tailscale_ip": self.tailscale_ip,
+            "lan_ip": self.lan_ip,
+            "motor_server_url": self.motor_server_url,
+            "livekit_url": self.livekit_url,
+            "character_id": self.character_id,
+        }
+        async with httpx.AsyncClient(timeout=15.0) as c:
+            r = await c.post(f"{self.scheduler_url}/api/devices/enroll", json=body)
+            if r.status_code != 200:
+                raise RuntimeError(f"Enroll failed ({r.status_code}): {r.text}")
+            data = r.json()
+        self.device_id = data["device_id"]
+        self.device_token = data["device_token"]
+        log.info(f"Enrolled as device_id={self.device_id}")
+        self._save_state()
+
+    async def heartbeat(self):
+        body = {"status": "online", "ip": self.tailscale_ip or self.lan_ip}
+        async with httpx.AsyncClient(timeout=10.0) as c:
+            r = await c.post(
+                f"{self.scheduler_url}/api/devices/{self.device_id}/heartbeat",
+                headers={"Authorization": f"Bearer {self.device_token}"},
+                json=body,
+            )
+            if r.status_code == 401:
+                log.error("Device token rejected; re-enrollment required")
+                # wipe creds so next loop tries to enroll again
+                self.device_token = None
+                if self.state_file.exists():
+                    self.state_file.unlink()
+                return None
+            r.raise_for_status()
+            return r.json()
+
+    async def fetch_config(self) -> dict:
+        async with httpx.AsyncClient(timeout=10.0) as c:
+            r = await c.get(
+                f"{self.scheduler_url}/api/devices/{self.device_id}/config",
+                headers={"Authorization": f"Bearer {self.device_token}"},
+            )
+            r.raise_for_status()
+            return r.json()
+
+    # ---- LiveKit (optional) ---------------------------------------------
+
+    async def livekit_loop(self):
+        """Join a LiveKit room, publish mic + cam, subscribe to data channel.
+        Skips silently if the `livekit` SDK is not installed."""
+        try:
+            from livekit_bridge import run_livekit  # local module
+        except ImportError:
+            log.warning(
+                "livekit_bridge module not available (livekit SDK missing). "
+                "Heartbeat + motor bridge will still work; install the `livekit` "
+                "and `livekit-api` packages on the Pi to enable rooms."
+            )
+            return
+
+        # Default room: robopark-<device_id>. Allow override via --room-name.
+        room = (self.room_name if self.room_name and not self.room_name.startswith("robopark-pi-standby")
+                else f"robopark-{self.device_id}")
+        # LiveKit URL: prefer the one the scheduler told us about, fall back to CLI.
+        lk_url = self.livekit_url or None
+
+        await run_livekit(
+            livekit_url=lk_url,
+            room_name=room,
+            identity=f"pi:{self.device_id}",
+            on_motor_command=self.motor_bridge.handle_command,
+            stop_event=self._stop,
+            production_mode_provider=lambda: self.production_mode,
+            scheduler_url=self.scheduler_url,
+            device_id=self.device_id,
+            device_token=self.device_token,
+        )
+
+    # ---- main loop ------------------------------------------------------
+
+    async def run(self):
+        # 1. credentials
+        if not self._load_state():
+            if not self.enrollment_token:
+                log.error(
+                    "No saved credentials and no --enrollment-token. "
+                    "First boot requires --enrollment-token from the scheduler."
+                )
+                return
+            await self.enroll()
+
+        log.info(f"Device {self.device_id} starting main loop")
+        # 2. start LiveKit worker in background (no-op if SDK missing)
+        if self.join_room:
+            self._lk_task = asyncio.create_task(self.livekit_loop())
+        hb_failures = 0
+        try:
+            while not self._stop.is_set():
+                try:
+                    hb = await self.heartbeat()
+                    hb_failures = 0
+                    if hb:
+                        self.production_mode = bool(hb.get("production_mode", False))
+                        if self.production_mode and self._lk_task is None and self.join_room:
+                            log.info("Production mode ON -> joining LiveKit room")
+                            self._lk_task = asyncio.create_task(self.livekit_loop())
+                        elif not self.production_mode and self._lk_task is not None:
+                            log.info("Production mode OFF -> leaving LiveKit room")
+                            self._lk_task.cancel()
+                            try:
+                                await self._lk_task
+                            except (asyncio.CancelledError, Exception):
+                                pass
+                            self._lk_task = None
+                except Exception as e:
+                    hb_failures += 1
+                    log.warning(f"Heartbeat error ({hb_failures}): {e}")
+
+                # periodic config poll (covers cases where production_mode flips but hb is slow)
+                try:
+                    if int(time.time()) % int(self.config_poll_interval) < int(self.heartbeat_interval):
+                        cfg = await self.fetch_config()
+                        self.production_mode = bool(cfg.get("production_mode", False))
+                        if cfg.get("character_id"):
+                            self.character_id = cfg["character_id"]
+                except Exception as e:
+                    log.debug(f"Config poll error: {e}")
+
+                try:
+                    await asyncio.wait_for(self._stop.wait(), timeout=self.heartbeat_interval)
+                except asyncio.TimeoutError:
+                    pass
+        finally:
+            self._stop.set()
+            if self._lk_task:
+                self._lk_task.cancel()
+                try:
+                    await self._lk_task
+                except Exception:
+                    pass
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="RoboPark Pi Client")
+    p.add_argument("--scheduler-url", required=True, help="e.g. http://100.64.1.5:8080")
+    p.add_argument("--enrollment-token", default=None,
+                   help="One-time enrollment token (first boot only)")
+    p.add_argument("--state-file", default="./device.json",
+                   help="Where to persist device_id + device_token")
+    p.add_argument("--name", default=None, help="Device display name")
+    p.add_argument("--tailscale-ip", default=None)
+    p.add_argument("--lan-ip", default=None)
+    p.add_argument("--motor-server-url", default=None,
+                   help="Base URL of the local RoboVisionAI_PI motor server")
+    p.add_argument("--livekit-url", default=None, help="e.g. ws://100.64.1.5:7880")
+    p.add_argument("--character-id", default=None, help="Override character assignment")
+    p.add_argument("--room-name", default="robopark-pi-standby",
+                   help="LiveKit room to join")
+    p.add_argument("--heartbeat-interval", type=float, default=10.0)
+    p.add_argument("--config-poll-interval", type=float, default=30.0)
+    p.add_argument("--join-room", action="store_true",
+                   help="Attempt to join the LiveKit room (requires livekit SDK)")
+    p.add_argument("--dry-run-motors", action="store_true",
+                   help="Log motor commands without calling the motor server")
+    return p.parse_args()
+
+
+async def _amain():
+    args = parse_args()
+    client = PiClient(args)
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, client._stop.set)
+        except NotImplementedError:
+            pass  # Windows
+
+    try:
+        await client.run()
+    except KeyboardInterrupt:
+        pass
+
+
+def main():
+    try:
+        asyncio.run(_amain())
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

package/packages/robopark/pi-client/install.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Install RoboPark Pi Client on a Raspberry Pi
+# Usage:
+#   sudo ./install.sh --scheduler-url http://100.64.1.5:8080 \
+#                     --enrollment-token <TOKEN>
+set -euo pipefail
+
+SCHEDULER_URL=""
+ENROLLMENT_TOKEN=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --scheduler-url) SCHEDULER_URL="$2"; shift 2 ;;
+    --enrollment-token) ENROLLMENT_TOKEN="$2"; shift 2 ;;
+    *) echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+if [[ -z "$SCHEDULER_URL" || -z "$ENROLLMENT_TOKEN" ]]; then
+  echo "Usage: $0 --scheduler-url URL --enrollment-token TOKEN"
+  exit 1
+fi
+
+id "robopark" 2>/dev/null || useradd -r -s /bin/false robopark
+install -d -m 755 -o robopark -g robopark /opt/robopark-pi-client
+install -d -m 700 -o robopark -g robopark /etc/robopark
+cp -r ./* /opt/robopark-pi-client/
+chown -R robopark:robopark /opt/robopark-pi-client
+
+sudo -u robopark python3 -m venv /opt/robopark-pi-client/.venv
+/opt/robopark-pi-client/.venv/bin/pip install --upgrade pip
+/opt/robopark-pi-client/.venv/bin/pip install -r /opt/robopark-pi-client/requirements.txt
+# On Pi you typically want the full media stack:
+/opt/robopark-pi-client/.venv/bin/pip install livekit livekit-api sounddevice numpy opencv-python av
+
+cp /opt/robopark-pi-client/robopark-pi-client.service /etc/systemd/system/
+systemctl daemon-reload
+systemctl enable --now robopark-pi-client.service
+
+echo "First-boot enrollment will run as part of the service start."
+echo "Tail logs with: journalctl -u robopark-pi-client -f"

package/packages/robopark/pi-client/join_convo.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Join a LiveKit conversation from the Pi.
+#
+# Calls the local Pi UI's /api/join endpoint, which itself asks the scheduler
+# for a short-lived LiveKit access token. The script prints the meet URL
+# AND (if --open) opens it in the default browser on the Pi.
+#
+# Usage:
+#   ./join_convo.sh
+#   ./join_convo.sh --room robopark-pi-test --identity alice --open
+#   PI_UI=http://192.168.1.159:8081 ./join_convo.sh --open
+
+set -euo pipefail
+
+PI_UI="${PI_UI:-http://127.0.0.1:8081}"
+ROOM="${ROOM:-robopark-pi-test}"
+IDENTITY="${IDENTITY:-}"
+OPEN=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --room) ROOM="$2"; shift 2 ;;
+    --identity) IDENTITY="$2"; shift 2 ;;
+    --open) OPEN=1; shift ;;
+    --pi-ui) PI_UI="$2"; shift 2 ;;
+    -h|--help)
+      sed -n '2,12p' "$0"; exit 0 ;;
+    *) echo "unknown arg: $1" >&2; exit 1 ;;
+  esac
+done
+
+BODY=$(jq -nc --arg room "$ROOM" --arg identity "$IDENTITY" \
+  '{room:$room, identity:$identity}')
+
+echo "Requesting token from $PI_UI (room=$ROOM identity=$IDENTITY)..."
+RESP=$(curl -fsS -X POST "$PI_UI/api/join" \
+  -H 'Content-Type: application/json' -d "$BODY")
+
+URL=$(echo "$RESP" | jq -r '
+  "https://meet.livekit.io/custom?livekitUrl=" + (.url | @uri) +
+  "&token=" + (.token | @uri)
+')
+
+EXPIRES=$(echo "$RESP" | jq -r '.expires_at')
+echo "Token expires: $EXPIRES"
+echo "Meet URL:"
+echo "  $URL"
+
+if [[ $OPEN -eq 1 ]]; then
+  if command -v xdg-open >/dev/null 2>&1; then xdg-open "$URL" >/dev/null 2>&1 || true
+  elif command -v sensible-browser >/dev/null 2>&1; then sensible-browser "$URL" >/dev/null 2>&1 || true
+  elif command -v open >/dev/null 2>&1; then open "$URL" >/dev/null 2>&1 || true
+  else echo "no browser opener found; copy the URL above" >&2; exit 2; fi
+  echo "(opened in browser)"
+fi

package/packages/robopark/pi-client/livekit_bridge.py

@@ -0,0 +1,289 @@
+"""LiveKit bridge for the RoboPark Pi client.
+
+Joins a LiveKit room as the Pi's device, publishes mic + camera, and forwards
+inbound data-channel messages to MotorBridge.handle_command().
+
+Token strategy: the Pi doesn't hold LiveKit API credentials. It asks the
+scheduler (POST /api/livekit/token) for a short-lived JWT signed by the
+scheduler. The Pi re-fetches the token whenever it's about to (re)connect.
+
+Install on Pi:
+    pip install livekit livekit-api sounddevice numpy av opencv-python-headless
+"""
+
+import asyncio
+import json
+import logging
+from typing import Callable, Awaitable, Optional
+
+import httpx
+
+log = logging.getLogger("robopark-pi.livekit")
+
+
+async def _fetch_livekit_token(
+    scheduler_url: str, device_id: str, device_token: str,
+    room: str, identity: str, ttl_seconds: int = 3600,
+) -> tuple[str, str]:
+    """Ask the scheduler for a LiveKit access token. Returns (url, token)."""
+    async with httpx.AsyncClient(timeout=10.0) as c:
+        r = await c.post(
+            f"{scheduler_url.rstrip('/')}/api/livekit/token",
+            json={"room": room, "identity": identity, "name": device_id,
+                  "can_publish": True, "can_subscribe": True,
+                  "ttl_seconds": ttl_seconds},
+        )
+        r.raise_for_status()
+        data = r.json()
+    return data["url"], data["token"]
+
+
+async def _connect_with_retry(
+    scheduler_url: str, device_id: str, device_token: str,
+    livekit_url: Optional[str], room_name: str, identity: str,
+    stop_event: asyncio.Event,
+) -> Optional["rtc.Room"]:
+    """Fetch a token and connect. Reconnect on failure until stopped."""
+    from livekit import rtc
+    backoff = 1.0
+    while not stop_event.is_set():
+        try:
+            url, token = await _fetch_livekit_token(
+                scheduler_url, device_id, device_token, room_name, identity,
+            )
+            url = livekit_url or url  # CLI override wins
+            room = rtc.Room()
+            log.info(f"Connecting to LiveKit {url} room={room_name} as {identity}")
+            await room.connect(url, token)
+            log.info(f"Connected to room {room_name}")
+            return room
+        except Exception as e:
+            log.warning(f"LiveKit connect failed: {e}; retrying in {backoff:.1f}s")
+            try:
+                await asyncio.wait_for(stop_event.wait(), timeout=backoff)
+                return None  # stopped while waiting
+            except asyncio.TimeoutError:
+                pass
+            backoff = min(backoff * 2, 30.0)
+    return None
+
+
+async def run_livekit(
+    livekit_url: Optional[str],
+    room_name: str,
+    identity: str,
+    on_motor_command: Callable[[str | bytes], Awaitable[str]],
+    stop_event: asyncio.Event,
+    production_mode_provider: Callable[[], bool],
+    scheduler_url: str = "",
+    device_id: str = "",
+    device_token: str = "",
+):
+    """Join a LiveKit room, publish mic + cam, subscribe to data channel.
+
+    Reconnects on disconnect, refetching the token each time.
+    Stops cleanly when production_mode flips False or stop_event is set.
+    """
+    try:
+        from livekit import rtc
+    except ImportError as e:
+        log.warning(f"LiveKit SDK not available, cannot join room: {e}")
+        return
+
+    while not stop_event.is_set():
+        if not production_mode_provider():
+            log.info("production_mode is OFF; not joining LiveKit")
+            try:
+                await asyncio.wait_for(stop_event.wait(), timeout=5.0)
+            except asyncio.TimeoutError:
+                continue
+            continue
+
+        room = await _connect_with_retry(
+            scheduler_url, device_id, device_token,
+            livekit_url, room_name, identity, stop_event,
+        )
+        if room is None:
+            return  # stop requested
+
+        @room.on("data_received")
+        def _on_data(packet):
+            asyncio.create_task(on_motor_command(packet.data))
+
+        @room.on("disconnected")
+        def _on_disc():
+            log.warning("LiveKit disconnected")
+
+        # --- Audio output: play remote participants' TTS through speakers ---
+        async def _play_remote_audio():
+            """Subscribe to audio tracks from other participants (agent TTS)
+            and play them through the Pi's default audio output device."""
+            try:
+                import sounddevice as sd
+                import numpy as np
+            except Exception as e:
+                log.warning(f"sounddevice/numpy unavailable for playback: {e}")
+                return
+
+            OUT_RATE = 48000  # sounddevice default output rate
+            _active_streams: dict = {}  # sid -> sd.OutputStream
+
+            def _on_track(track, publication, participant):
+                if track.kind != rtc.TrackKind.KIND_AUDIO:
+                    return
+                if participant.identity == room.local_participant.identity:
+                    return  # don't play our own mic
+                sid = publication.sid
+                log.info(f"audio out: subscribing to {participant.identity} / {sid}")
+
+                async def _stream_audio():
+                    try:
+                        stream = rtc.AudioStream(track=track)
+                        # Open output stream at 48kHz mono (Pi speaker)
+                        out = sd.OutputStream(samplerate=OUT_RATE, channels=1, dtype="int16", blocksize=0)
+                        out.start()
+                        _active_streams[sid] = out
+
+                        async for frame in stream:
+                            # SDK v1.1.12 yields AudioFrameEvent; v1.1.13 yields AudioFrame
+                            af = frame.frame if hasattr(frame, 'frame') else frame
+                            in_rate = af.sample_rate
+                            in_data = np.frombuffer(af.data, dtype=np.int16)
+                            if in_rate == OUT_RATE:
+                                out_data = in_data
+                            else:
+                                # Simple linear resample
+                                ratio = OUT_RATE / in_rate
+                                n_out = int(len(in_data) * ratio)
+                                indices = np.linspace(0, len(in_data) - 1, n_out)
+                                out_data = np.interp(indices, np.arange(len(in_data)), in_data.astype(np.float64)).astype(np.int16)
+
+                            try:
+                                out.write(out_data)
+                            except Exception as e:
+                                log.debug(f"audio out write error: {e}")
+                                break
+                    except Exception as e:
+                        log.warning(f"audio out stream error: {e}")
+                    finally:
+                        try:
+                            if sid in _active_streams:
+                                _active_streams[sid].stop()
+                                del _active_streams[sid]
+                        except Exception:
+                            pass
+                    log.info(f"audio out: stopped {sid}")
+
+                asyncio.create_task(_stream_audio())
+
+            @room.on("track_subscribed")
+            def _on_track_subscribed(track, publication, participant):
+                _on_track(track, publication, participant)
+
+            # Also handle tracks already present (agent joined before us)
+            for p in room.remote_participants.values():
+                for pub in p.track_publications.values():
+                    if pub.track and pub.track.kind == rtc.TrackKind.KIND_AUDIO:
+                        _on_track(pub.track, pub, p)
+
+            # Keep alive until disconnect
+            while not stop_event.is_set() and room.connection_state == rtc.ConnectionState.CONN_CONNECTED:
+                await asyncio.sleep(0.5)
+
+            # Cleanup
+            for s in _active_streams.values():
+                try: s.stop()
+                except Exception: pass
+            _active_streams.clear()
+
+        # Publish tracks
+        async def _publish_mic():
+            try:
+                import sounddevice as sd
+            except Exception as e:
+                log.warning(f"sounddevice unavailable, skipping mic: {e}")
+                return
+            # The USB mic is ALSA device index 1 (1 in, 0 out). Default is output-only.
+            MIC_DEVICE = 1
+            try:
+                log.info(f"mic: opening device {MIC_DEVICE} ({sd.query_devices()[MIC_DEVICE]['name']})")
+            except Exception:
+                log.warning(f"mic: device {MIC_DEVICE} not found, trying default")
+                MIC_DEVICE = None
+            try:
+                source = rtc.AudioSource(sample_rate=16000, num_channels=1)
+                track = rtc.LocalAudioTrack.create_audio_track("mic", source)
+                opts = rtc.TrackPublishOptions(source=rtc.TrackSource.SOURCE_MICROPHONE)
+                await room.local_participant.publish_track(track, opts)
+                log.info("mic published (source=MICROPHONE, 16kHz)")
+                loop = asyncio.get_event_loop()
+                def _cb(indata, frames, time_info, status):
+                    if status: log.debug(f"mic status: {status}")
+                    try:
+                        frame = rtc.AudioFrame(
+                            data=indata.tobytes(),
+                            sample_rate=16000,
+                            num_channels=1,
+                            samples_per_channel=frames,
+                        )
+                        asyncio.run_coroutine_threadsafe(
+                            source.capture_frame(frame), loop)
+                    except Exception: pass
+                with sd.InputStream(device=MIC_DEVICE, samplerate=16000, channels=1, dtype="int16", callback=_cb):
+                    while not stop_event.is_set() and room.connection_state == rtc.ConnectionState.CONN_CONNECTED:
+                        await asyncio.sleep(0.1)
+            except Exception as e:
+                log.warning(f"mic publish error: {e}")
+
+        async def _publish_cam():
+            try:
+                import cv2
+            except Exception as e:
+                log.warning(f"opencv unavailable, skipping camera: {e}")
+                return
+            cap = cv2.VideoCapture(0, cv2.CAP_V4L2)
+            if not cap.isOpened():
+                log.warning("camera /dev/video0 not available")
+                return
+            cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
+            cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+            cap.set(cv2.CAP_PROP_FPS, 15)
+            try:
+                source = rtc.VideoSource(width=640, height=480)
+                track = rtc.LocalVideoTrack.create_video_track("cam", source)
+                opts = rtc.TrackPublishOptions(source=rtc.TrackSource.SOURCE_CAMERA)
+                await room.local_participant.publish_track(track, opts)
+                log.info("camera published (source=CAMERA)")
+                while not stop_event.is_set() and room.connection_state == rtc.ConnectionState.CONN_CONNECTED:
+                    ok, frame = cap.read()
+                    if not ok: await asyncio.sleep(0.1); continue
+                    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    vf = rtc.VideoFrame(width=640, height=480, type=rtc.VideoBufferType.RGB24, data=rgb.tobytes())
+                    source.capture_frame(vf)
+                    await asyncio.sleep(1/15)
+            except Exception as e:
+                log.warning(f"camera publish error: {e}")
+            finally:
+                cap.release()
+
+        mic_task = asyncio.create_task(_publish_mic())
+        cam_task = asyncio.create_task(_publish_cam())
+        audio_out_task = asyncio.create_task(_play_remote_audio())
+
+        try:
+            while not stop_event.is_set():
+                if not production_mode_provider():
+                    log.info("production_mode flipped OFF; leaving room")
+                    break
+                if room.connection_state != rtc.ConnectionState.CONN_CONNECTED:
+                    log.info("room not connected; will reconnect")
+                    break
+                await asyncio.sleep(1)
+        finally:
+            mic_task.cancel(); cam_task.cancel(); audio_out_task.cancel()
+            for t in (mic_task, cam_task, audio_out_task):
+                try: await t
+                except Exception: pass
+            try: await room.disconnect()
+            except Exception: pass
+            log.info("left room, will loop to reconnect")