405 lines
16 KiB
Python
405 lines
16 KiB
Python
"""Gemini live subprocess supervisor.
|
|
|
|
Spawns `voice/sanad_voice.py` as a managed child with `SANAD_VOICE_BRAIN=gemini`,
|
|
tails the child's stdout, and extracts state transitions + user transcripts
|
|
from the Gemini-specific log lines emitted by `gemini/script.py:GeminiBrain`.
|
|
|
|
When a new model is added, build its own sibling supervisor (see
|
|
`voice/model_subprocess.py` for the template) — do not refactor this file.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import json
|
|
import os
|
|
import signal
|
|
import subprocess
|
|
import sys
|
|
import threading
|
|
from collections import deque
|
|
from datetime import datetime
|
|
from typing import Any, Optional, Union
|
|
|
|
from pathlib import Path
|
|
|
|
from Project.Sanad.config import BASE_DIR, LOGS_DIR, SCRIPTS_DIR, LIVE_TUNE
|
|
from Project.Sanad.core.config_loader import section as _cfg_section
|
|
from Project.Sanad.core.logger import get_logger
|
|
|
|
log = get_logger("gemini_subprocess")
|
|
|
|
_LS_CFG = _cfg_section("gemini", "subprocess")
|
|
|
|
# Camera frame forwarding — push the latest JPEG to the child over stdin
|
|
# at this interval (seconds). 0.5 s ≈ 2 fps, matching the child's
|
|
# SANAD_VISION_SEND_HZ default. The child de-stales + relays to Gemini.
|
|
_FRAME_FORWARD_INTERVAL_S = float(_LS_CFG.get("frame_forward_interval_sec", 0.5))
|
|
|
|
|
|
def _resolve_live_script() -> Path:
|
|
"""Locate the voice script to run as subprocess.
|
|
|
|
Default: voice/sanad_voice.py (the canonical G1 built-in mic +
|
|
AudioClient speaker path). Override with SANAD_LIVE_SCRIPT.
|
|
"""
|
|
override = os.environ.get("SANAD_LIVE_SCRIPT", "").strip()
|
|
if override:
|
|
p = Path(override).expanduser()
|
|
if p.exists():
|
|
return p
|
|
for c in (BASE_DIR / "voice" / "sanad_voice.py",
|
|
SCRIPTS_DIR / "sanad_voice.py"):
|
|
if c.exists():
|
|
return c
|
|
return SCRIPTS_DIR / "sanad_voice.py"
|
|
|
|
|
|
LIVE_SCRIPT = _resolve_live_script()
|
|
LOG_TAIL_SIZE = _LS_CFG.get("log_tail_size", 2000)
|
|
TRANSCRIPT_TAIL_SIZE = _LS_CFG.get("transcript_tail_size", 30)
|
|
|
|
# Persistent on-disk log for the full subprocess session.
|
|
LIVE_LOG_DIR = LOGS_DIR
|
|
LIVE_LOG_NAME = _LS_CFG.get("log_name", "gemini_subprocess")
|
|
|
|
_STOP_TIMEOUT_SEC = _LS_CFG.get("stop_timeout_sec", 3.0)
|
|
_TERMINATE_TIMEOUT_SEC = _LS_CFG.get("terminate_timeout_sec", 2.0)
|
|
|
|
_NOISY_PREFIXES = tuple(_LS_CFG.get("noisy_prefixes", [
|
|
"ALSA lib ", "Expression 'alsa_", "Cannot connect to server socket",
|
|
"jack server is not running",
|
|
]))
|
|
_NOISY_FRAGMENTS = tuple(_LS_CFG.get("noisy_fragments", [
|
|
"Unknown PCM", "Evaluate error", "snd_pcm_open_noupdate",
|
|
"PaAlsaStream", "snd_config_evaluate", "snd_func_refer",
|
|
]))
|
|
|
|
|
|
class GeminiSubprocess:
|
|
def __init__(self):
|
|
self._lock = threading.Lock()
|
|
self.process: subprocess.Popen | None = None
|
|
self.log_tail: deque[str] = deque(maxlen=LOG_TAIL_SIZE)
|
|
self.user_transcript: deque[str] = deque(maxlen=TRANSCRIPT_TAIL_SIZE)
|
|
self._reader_thread: threading.Thread | None = None
|
|
self._log_file = None # opened per-session in _reader_loop
|
|
self.state = "stopped"
|
|
self.state_message = "Idle."
|
|
self.last_user_text = ""
|
|
self.suppressed_noise = 0
|
|
# ── stdin push channel (camera frames + motion state) ──
|
|
# The child (gemini/script.py) reads "frame:<b64>\n" and
|
|
# "state:<json>\n" lines off its stdin. Writes are serialised
|
|
# because the frame forwarder and the motion-state bus handler
|
|
# both call from different threads.
|
|
self._stdin_lock = threading.Lock()
|
|
self._camera = None # set via attach_camera()
|
|
self._frame_thread: threading.Thread | None = None
|
|
self._frame_stop = threading.Event()
|
|
|
|
# ── camera attach (called once from main.py) ──────────────
|
|
|
|
def attach_camera(self, camera) -> None:
|
|
"""Give the supervisor a reference to the CameraDaemon so it can
|
|
forward frames to the child over stdin while a session runs."""
|
|
self._camera = camera
|
|
|
|
def _open_session_log(self, pid: int):
|
|
"""Open (or re-open) the per-day append log file for this session."""
|
|
try:
|
|
LIVE_LOG_DIR.mkdir(parents=True, exist_ok=True)
|
|
fname = f"{LIVE_LOG_NAME}_{datetime.now().strftime('%Y%m%d')}.log"
|
|
fh = open(LIVE_LOG_DIR / fname, "a", encoding="utf-8", buffering=1)
|
|
fh.write(
|
|
f"\n===== live_gemini subprocess start "
|
|
f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')} pid={pid} =====\n"
|
|
)
|
|
return fh
|
|
except Exception as exc:
|
|
log.warning("Could not open live-gemini log file: %s", exc)
|
|
return None
|
|
|
|
def _is_noisy(self, line: str) -> bool:
|
|
return line.startswith(_NOISY_PREFIXES) or any(f in line for f in _NOISY_FRAGMENTS)
|
|
|
|
def _set_state(self, state: str, msg: str):
|
|
self.state = state
|
|
self.state_message = msg
|
|
|
|
def _track_line(self, line: str):
|
|
"""Parse Gemini-specific log markers emitted by `gemini/script.py`.
|
|
|
|
Must stay in lock-step with the `log.info(...)` strings in
|
|
`GeminiBrain`. If you add a new state, add the emit in the brain
|
|
AND the matching detector here — in one PR.
|
|
"""
|
|
if "connecting to Gemini" in line:
|
|
self._set_state("connecting", line)
|
|
elif "connected — speak anytime" in line or "connected - speak anytime" in line:
|
|
self._set_state("listening", "Listening for speech.")
|
|
elif " USER: " in line or line.strip().startswith("USER:"):
|
|
# GeminiBrain emits: log.info("USER: %s", text)
|
|
text = line.split("USER:", 1)[1].strip()
|
|
if text:
|
|
self.last_user_text = text
|
|
self.user_transcript.append(text)
|
|
self._set_state("hearing", f"User: {text}")
|
|
elif "BARGE-IN" in line or "Gemini interrupted" in line or "interrupt (" in line:
|
|
self._set_state("interrupting", line)
|
|
elif "listening" in line.lower() and "no speech" not in line:
|
|
# Fires on "listening" (post-turn) — keep the state fresh.
|
|
self._set_state("listening", "Listening for speech.")
|
|
elif "session error" in line or "client recreation failed" in line:
|
|
self._set_state("error", line)
|
|
elif "server going away" in line or "session ended" in line or "session dead" in line:
|
|
self._set_state("warning", line)
|
|
elif "keyboard interrupt" in line or "cancelled — stopping" in line:
|
|
self._set_state("stopped", line)
|
|
|
|
def _reader_loop(self):
|
|
proc = self.process
|
|
if proc is None or proc.stdout is None:
|
|
return
|
|
# Every line goes to the on-disk log — including the ALSA noise
|
|
# that we filter out of the in-memory tail. That way a field
|
|
# post-mortem has the full raw capture if we need it.
|
|
fh = self._open_session_log(proc.pid)
|
|
self._log_file = fh
|
|
for line in proc.stdout:
|
|
clean = line.rstrip()
|
|
if not clean:
|
|
continue
|
|
if fh is not None:
|
|
try:
|
|
fh.write(clean + "\n")
|
|
except Exception:
|
|
pass
|
|
with self._lock:
|
|
if self._is_noisy(clean):
|
|
self.suppressed_noise += 1
|
|
continue
|
|
self.log_tail.append(clean)
|
|
self._track_line(clean)
|
|
with self._lock:
|
|
self.log_tail.append("Live Gemini process exited.")
|
|
self._set_state("stopped", "Process exited.")
|
|
if fh is not None:
|
|
try:
|
|
fh.write(
|
|
f"===== live_gemini subprocess exit "
|
|
f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====\n"
|
|
)
|
|
fh.close()
|
|
except Exception:
|
|
pass
|
|
self._log_file = None
|
|
|
|
def is_running(self) -> bool:
|
|
with self._lock:
|
|
return self.process is not None and self.process.poll() is None
|
|
|
|
def start(self) -> dict[str, Any]:
|
|
with self._lock:
|
|
if self.process is not None and self.process.poll() is None:
|
|
return {"started": False, "message": "Already running.", "pid": self.process.pid}
|
|
self._set_state("starting", "Starting...")
|
|
|
|
script = LIVE_SCRIPT
|
|
if not script.exists():
|
|
raise RuntimeError(f"Script not found: {script}")
|
|
|
|
env = os.environ.copy()
|
|
env.update({"PYTHONUNBUFFERED": "1", **LIVE_TUNE})
|
|
|
|
# Pass the current G1 speaker volume as an env var so the
|
|
# subprocess can compute the correct barge-in threshold at
|
|
# startup. Without this, sanad_voice.py would read the volume
|
|
# from a stale or non-existent config file path and default to
|
|
# 100, scaling the barge-in threshold wrong for any non-100%
|
|
# volume. load_config() reads data/motions/config.json — the
|
|
# file the dashboard writes to when the user moves the slider.
|
|
try:
|
|
from Project.Sanad.config import load_config
|
|
_cfg = load_config() or {}
|
|
_audio_cfg = _cfg.get("audio") if isinstance(_cfg.get("audio"), dict) else {}
|
|
_g1_vol = int(_audio_cfg.get("g1_volume", 100))
|
|
_g1_vol = max(0, min(100, _g1_vol))
|
|
env["SANAD_G1_VOLUME"] = str(_g1_vol)
|
|
log.info("Passing SANAD_G1_VOLUME=%d to subprocess", _g1_vol)
|
|
except Exception as exc:
|
|
log.warning("Could not read g1_volume for subprocess: %s", exc)
|
|
|
|
# sanad_voice.py takes the DDS interface as the first positional arg
|
|
dds_iface = env.get("SANAD_DDS_INTERFACE", "eth0")
|
|
cmd = [sys.executable, str(script), dds_iface]
|
|
proc = subprocess.Popen(
|
|
cmd,
|
|
cwd=str(script.parent),
|
|
stdin=subprocess.PIPE, # camera frames + motion state push
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
text=True,
|
|
bufsize=1,
|
|
env=env,
|
|
)
|
|
|
|
# Reap any stale frame forwarder from a previous session that ended
|
|
# by a child crash rather than a clean stop() — otherwise it keeps
|
|
# spinning on a dead pipe and we'd leak a thread per restart.
|
|
stale_ft = self._frame_thread
|
|
if stale_ft is not None and stale_ft.is_alive():
|
|
self._frame_stop.set()
|
|
stale_ft.join(timeout=2.0)
|
|
|
|
with self._lock:
|
|
self.process = proc
|
|
self.log_tail.append(f"Started: pid={proc.pid}")
|
|
self._set_state("starting", f"pid={proc.pid}")
|
|
self._reader_thread = threading.Thread(target=self._reader_loop, daemon=True)
|
|
self._reader_thread.start()
|
|
# Frame forwarder — pushes camera JPEGs to the child over stdin.
|
|
self._frame_stop.clear()
|
|
self._frame_thread = threading.Thread(
|
|
target=self._frame_forwarder, daemon=True, name="gemini-frame-fwd",
|
|
)
|
|
self._frame_thread.start()
|
|
|
|
log.info("Live Gemini subprocess started: pid=%d", proc.pid)
|
|
return {"started": True, "pid": proc.pid}
|
|
|
|
# ── stdin push channel ────────────────────────────────────
|
|
|
|
def _send_stdin(self, line: str) -> None:
|
|
"""Serialised stdin write — frame forwarder + motion-state handler
|
|
both call this from different threads. Best-effort: a closed pipe
|
|
or a not-yet-started process is a silent no-op."""
|
|
proc = self.process
|
|
if proc is None or proc.stdin is None:
|
|
return
|
|
try:
|
|
with self._stdin_lock:
|
|
if not proc.stdin.closed:
|
|
proc.stdin.write(line)
|
|
proc.stdin.flush()
|
|
except Exception:
|
|
# Pipe broke (child exited) — drop silently; the reader thread
|
|
# will surface the exit via state="stopped".
|
|
pass
|
|
|
|
def send_frame(self, jpeg: Union[bytes, str]) -> None:
|
|
"""Forward one camera frame to the child as 'frame:<base64>\\n'.
|
|
|
|
Accepts raw JPEG bytes (base64-encoded here) or an already-base64
|
|
ASCII string (e.g. CameraDaemon.get_frame_b64() — no re-encode)."""
|
|
if isinstance(jpeg, bytes):
|
|
b64 = base64.b64encode(jpeg).decode("ascii")
|
|
elif isinstance(jpeg, str):
|
|
b64 = jpeg.strip()
|
|
else:
|
|
return
|
|
if b64:
|
|
self._send_stdin("frame:" + b64 + "\n")
|
|
|
|
def send_state(self, event: str, cmd: str,
|
|
elapsed_sec: Optional[float] = None,
|
|
reason: Optional[str] = None) -> None:
|
|
"""Push a motion-state update to the child as 'state:<json>\\n'.
|
|
|
|
Events: start | complete | interrupted | error. The child injects
|
|
'[STATE-...] <cmd>' into the live Gemini session as silent text
|
|
context so Gemini can answer "what are you doing?" honestly."""
|
|
if not event or not cmd:
|
|
return
|
|
payload: dict[str, Any] = {"event": event, "cmd": cmd}
|
|
if elapsed_sec is not None:
|
|
payload["elapsed_sec"] = round(float(elapsed_sec), 2)
|
|
if reason:
|
|
payload["reason"] = str(reason)[:200]
|
|
try:
|
|
line = "state:" + json.dumps(payload, ensure_ascii=False) + "\n"
|
|
except Exception:
|
|
return
|
|
self._send_stdin(line)
|
|
|
|
def _frame_forwarder(self) -> None:
|
|
"""Background thread — push the camera's latest frame to the child.
|
|
|
|
Runs for the lifetime of one subprocess session. Gated on the
|
|
camera actually running; the child does its own vision-enabled +
|
|
staleness checks, so this stays dumb (camera up → push)."""
|
|
cam = self._camera
|
|
if cam is None:
|
|
return
|
|
while not self._frame_stop.is_set():
|
|
if self._frame_stop.wait(_FRAME_FORWARD_INTERVAL_S):
|
|
break
|
|
try:
|
|
if not cam.is_running():
|
|
continue
|
|
b64 = cam.get_frame_b64()
|
|
if b64:
|
|
self.send_frame(b64)
|
|
except Exception:
|
|
# Best-effort — never let a frame hiccup kill the thread.
|
|
pass
|
|
|
|
def stop(self) -> dict[str, Any]:
|
|
with self._lock:
|
|
proc = self.process
|
|
if proc is None or proc.poll() is not None:
|
|
return {"stopped": False, "message": "Not running."}
|
|
self._set_state("stopping", "Stopping...")
|
|
|
|
# Halt the frame forwarder before we tear the pipe down.
|
|
self._frame_stop.set()
|
|
ft = self._frame_thread
|
|
if ft is not None:
|
|
ft.join(timeout=2.0)
|
|
self._frame_thread = None
|
|
|
|
try:
|
|
proc.send_signal(signal.SIGINT)
|
|
proc.wait(timeout=_STOP_TIMEOUT_SEC)
|
|
except subprocess.TimeoutExpired:
|
|
proc.terminate()
|
|
try:
|
|
proc.wait(timeout=_TERMINATE_TIMEOUT_SEC)
|
|
except subprocess.TimeoutExpired:
|
|
proc.kill()
|
|
proc.wait(timeout=_TERMINATE_TIMEOUT_SEC)
|
|
|
|
rc = proc.returncode
|
|
|
|
# Close stdin/stdout explicitly — without this each start/stop
|
|
# cycle leaks FDs (relied on Popen.__del__ which only runs at GC;
|
|
# a reconnect loop would march the FD count to the OS limit).
|
|
for pipe in (getattr(proc, "stdin", None), getattr(proc, "stdout", None)):
|
|
if pipe is not None:
|
|
try:
|
|
pipe.close()
|
|
except Exception:
|
|
pass
|
|
|
|
with self._lock:
|
|
self.process = None
|
|
self.log_tail.append("Stopped.")
|
|
self._set_state("stopped", "Stopped.")
|
|
|
|
log.info("Live Gemini subprocess stopped (rc=%s)", rc)
|
|
return {"stopped": True, "returncode": rc}
|
|
|
|
def status(self) -> dict[str, Any]:
|
|
with self._lock:
|
|
running = self.process is not None and self.process.poll() is None
|
|
return {
|
|
"running": running,
|
|
"pid": self.process.pid if running and self.process else None,
|
|
"state": self.state,
|
|
"state_message": self.state_message,
|
|
"last_user_text": self.last_user_text,
|
|
"user_transcript": list(self.user_transcript),
|
|
"log_tail": list(self.log_tail),
|
|
"suppressed_noise": self.suppressed_noise,
|
|
}
|