infinicode 2.8.85 → 2.8.86

package/dist/robopark/serve.js

@@ -9,7 +9,8 @@
  */
 import chalk from 'chalk';
 import { spawn, execSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 function pkgDir() {
@@ -68,6 +69,33 @@ function findPython() {
     // ENOENT/"not found" error from the OS rather than a silent fallback.
     return process.platform === 'win32' ? 'python' : 'python3';
 }
+function resolveSchedulerDataDir(explicit) {
+    if (explicit)
+        return explicit;
+    if (process.env.SCHEDULER_DATA_DIR)
+        return process.env.SCHEDULER_DATA_DIR;
+    const stable = join(homedir(), '.robopark', 'scheduler');
+    const stableDb = join(stable, 'scheduler.db');
+    if (existsSync(stableDb))
+        return stable;
+    // Older releases stored data beside whichever npm installation launched
+    // the scheduler. Local, global and npx installs therefore created separate
+    // databases. Migrate the largest existing DB once into stable user storage.
+    const legacyCandidates = [join(pkgDir(), '..', 'data')];
+    if (process.platform === 'win32' && process.env.APPDATA) {
+        legacyCandidates.push(join(process.env.APPDATA, 'npm', 'node_modules', 'data'));
+    }
+    const legacy = legacyCandidates
+        .filter((candidate, index, all) => all.indexOf(candidate) === index)
+        .filter(candidate => existsSync(join(candidate, 'scheduler.db')))
+        .sort((a, b) => statSync(join(b, 'scheduler.db')).size - statSync(join(a, 'scheduler.db')).size)[0];
+    mkdirSync(stable, { recursive: true });
+    if (legacy) {
+        cpSync(legacy, stable, { recursive: true, force: false, errorOnExist: false });
+        console.log(chalk.yellow(`  migrated scheduler data: ${legacy} -> ${stable}`));
+    }
+    return stable;
+}
 /** Resolve the actual infinicode CLI entry point so `robopark setup --start`
  *  works even when global bins are not on PATH.
  *
@@ -110,6 +138,7 @@ export async function roboparkServe(opts) {
     const python = findPython();
     const schedulerDir = dirname(schedulerPath);
     const requirements = join(schedulerDir, 'requirements.txt');
+    const dataDir = resolveSchedulerDataDir(opts.dataDir);
     // Ensure scheduler Python dependencies are installed before starting.
     if (existsSync(requirements)) {
         console.log(chalk.dim('  ensuring scheduler Python deps…'));
@@ -125,7 +154,7 @@ export async function roboparkServe(opts) {
         ...process.env,
         SCHEDULER_HOST: host,
         SCHEDULER_PORT: String(port),
-        SCHEDULER_DATA_DIR: opts.dataDir ?? join(pkgDir(), '..', 'data'),
+        SCHEDULER_DATA_DIR: dataDir,
     };
     if (opts.gateway)
         env.INFINIBOT_GATEWAY_URL = opts.gateway;
@@ -138,6 +167,7 @@ export async function roboparkServe(opts) {
     console.log(`  scheduler: ${chalk.cyan(schedulerPath)}`);
     console.log(`  python:    ${chalk.cyan(python)}`);
     console.log(`  listen:    ${chalk.cyan(`${host}:${port}`)}`);
+    console.log(`  data:      ${chalk.cyan(dataDir)}`);
     if (opts.gateway)
         console.log(`  gateway:   ${chalk.cyan(opts.gateway)}`);
     console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.85",
+  "version": "2.8.86",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/scheduler/main.py

@@ -604,6 +604,9 @@ async def init_db():
             ("sessions", "voice_stack_id", "TEXT"),
             ("sessions", "initiated_by", "TEXT"),
             ("sessions", "event_token_hash", "TEXT"),
+            # Speaker tests are executed only by preview_agent, which can
+            # release and restore the active media publisher around ALSA I/O.
+            ("shell_requests", "claimed_at", "TEXT"),
         ):
             try:
                 await db.execute(f"ALTER TABLE {_table} ADD COLUMN {_column} {_coldef}")
@@ -3317,8 +3320,9 @@ async def device_supervisor_status(device_id: str, payload: SupervisorStatusRepo
         pending = []
         try:
             async with db.execute(
-                "SELECT service_name, action, kind, params, id FROM shell_requests "
-                "WHERE device_id = ? AND completed_at IS NULL ORDER BY requested_at",
+                "SELECT service_name, action, kind, params, id FROM shell_requests "
+                "WHERE device_id = ? AND completed_at IS NULL AND kind != 'speaker_test' "
+                "ORDER BY requested_at",
                 (device_id,),
             ) as c:
                 shell_rows = [dict(r) for r in await c.fetchall()]
@@ -3696,13 +3700,26 @@ async def next_device_speaker_test(device_id: str, authorization: Optional[str]
     """Allow the always-running preview agent to execute audio tests."""
     if not await _authorize_device(device_id, authorization):
         raise HTTPException(401, "Invalid device token")
+    now = datetime.utcnow()
+    stale_before = (now - timedelta(seconds=45)).isoformat()
     async with aiosqlite.connect(DB_PATH) as db:
         db.row_factory = aiosqlite.Row
+        await db.execute("BEGIN IMMEDIATE")
         async with db.execute(
             "SELECT id, params FROM shell_requests WHERE device_id = ? AND kind = 'speaker_test' "
-            "AND completed_at IS NULL ORDER BY requested_at LIMIT 1", (device_id,),
+            "AND completed_at IS NULL AND (claimed_at IS NULL OR claimed_at < ?) "
+            "ORDER BY requested_at LIMIT 1", (device_id, stale_before),
         ) as cursor:
             row = await cursor.fetchone()
+        if row:
+            claimed = await db.execute(
+                "UPDATE shell_requests SET claimed_at = ? WHERE id = ? AND completed_at IS NULL "
+                "AND (claimed_at IS NULL OR claimed_at < ?)",
+                (now.isoformat(), row["id"], stale_before),
+            )
+            if claimed.rowcount != 1:
+                row = None
+        await db.commit()
     return {"request": {"id": row["id"], "params": json.loads(row["params"] or "{}")} if row else None}
 
 
@@ -4171,25 +4188,35 @@ async def _auto_elevenlabs_voice(robot_name: Optional[str], current: Optional[st
 
 
 async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
-    """Public helper to resolve the effective voice config for a robot id."""
-    async with aiosqlite.connect(DB_PATH) as db:
-        db.row_factory = aiosqlite.Row
-        stack_dict = await _resolve_voice_stack_for_robot(db, robot_id)
+    """Public helper to resolve the effective voice config for a robot id."""
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        # Dashboard routes commonly use the human robot name ("bmw"), while
+        # assignments are persisted against the enrolled device id. Resolve
+        # that alias once so character, stack and greetings use one identity.
+        async with db.execute(
+            "SELECT id FROM devices WHERE id = ? OR lower(name) = lower(?) "
+            "ORDER BY CASE WHEN id = ? THEN 0 ELSE 1 END LIMIT 1",
+            (robot_id, robot_id, robot_id),
+        ) as c:
+            canonical_device = await c.fetchone()
+        canonical_id = canonical_device["id"] if canonical_device else robot_id
+        stack_dict = await _resolve_voice_stack_for_robot(db, canonical_id)
 
         # Determine character preset + name
         character_id = None
         character_name = None
         system_prompt = None
         async with db.execute(
-            "SELECT character_preset_id FROM robot_voice_configs WHERE robot_id = ?", (robot_id,)
+            "SELECT character_preset_id FROM robot_voice_configs WHERE robot_id = ?", (canonical_id,)
         ) as c:
             rvc = await c.fetchone()
         if rvc and rvc["character_preset_id"]:
             character_id = rvc["character_preset_id"]
         else:
             async with db.execute(
-                "SELECT character_id FROM robots WHERE id = ? UNION ALL SELECT character_id FROM devices WHERE id = ?",
-                (robot_id, robot_id),
+                "SELECT character_id FROM robots WHERE id = ? UNION ALL SELECT character_id FROM devices WHERE id = ?",
+                (canonical_id, canonical_id),
             ) as c:
                 row = await c.fetchone()
                 if row:
@@ -4204,21 +4231,23 @@ async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
                     system_prompt = row["system_prompt"]
             if not character_name:
                 async with db.execute(
-                    "SELECT name FROM robots WHERE id = ? UNION ALL SELECT name FROM devices WHERE id = ?",
-                    (robot_id, robot_id),
+                    "SELECT name FROM robots WHERE id = ? UNION ALL SELECT name FROM devices WHERE id = ?",
+                    (canonical_id, canonical_id),
                 ) as c:
                     row = await c.fetchone()
                     if row:
                         character_name = row["name"]
 
-        async with db.execute("SELECT greeting_phrases FROM devices WHERE id = ?", (robot_id,)) as c:
+        async with db.execute("SELECT greeting_phrases FROM devices WHERE id = ?", (canonical_id,)) as c:
             device_row = await c.fetchone()
         greeting_phrases = []
         if device_row and device_row["greeting_phrases"]:
             try:
                 greeting_phrases = [str(p) for p in _json.loads(device_row["greeting_phrases"]) if str(p).strip()]
-            except Exception:
-                greeting_phrases = []
+            except Exception:
+                greeting_phrases = []
+        if not greeting_phrases and (character_name or character_id):
+            greeting_phrases = [f"Hello, I am {character_name or character_id}. How can I help you?"]
         if stack_dict:
             stack_dict["tts_voice"] = await _auto_elevenlabs_voice(character_name or character_id, stack_dict.get("tts_voice"))
         voice_stack = VoiceStack(**stack_dict) if stack_dict else None

package/packages/robopark/scheduler/preview_agent.py

@@ -1233,44 +1233,95 @@ class LiveKitPublisher:
         if self._capture and self.video_source:
             self._tasks.append(asyncio.create_task(self._video_loop()))
 
-    async def _play_remote_audio(self, track, sid: str) -> None:
-        try:
-            import pyaudio
-        except Exception as e:
-            logger.warning(f"pyaudio unavailable for playback: {e}")
-            return
-        OUT_RATE = 48000
-        OUT_CHANNELS = 2
-        pa = pyaudio.PyAudio()
-        # Same MME-vs-WASAPI gotcha as mic capture (see PyAudioCapture._resolve_device):
-        # PyAudio's global default output device resolves through MME, which on this
-        # machine will accept writes and report success with zero exceptions while
-        # never actually reaching the real speakers. Prefer WASAPI's default output,
-        # which is what Windows' own volume mixer/meter is backed by.
-        output_device_index = None
+    async def _play_remote_audio(self, track, sid: str) -> None:
+        OUT_RATE = 48000
+        OUT_CHANNELS = 2
         selected_output = str(self.agent.audio_playback_device or "default")
-        if selected_output.strip().isdigit():
-            output_device_index = int(selected_output.strip())
-        try:
-            if selected_output.lower() == "default":
-                wasapi = pa.get_host_api_info_by_type(pyaudio.paWASAPI)
-                idx = wasapi.get("defaultOutputDevice")
-                if idx is not None and idx >= 0:
-                    output_device_index = idx
-            elif output_device_index is None:
-                needle = selected_output.lower()
-                for i in range(pa.get_device_count()):
-                    info = pa.get_device_info_by_index(i)
-                    if info.get("maxOutputChannels", 0) > 0 and needle in str(info.get("name", "")).lower():
-                        output_device_index = i
-                        break
-        except Exception as e:
-            logger.debug(f"audio out: WASAPI default output lookup failed, using PyAudio default: {e}")
-        out = pa.open(
-            format=pyaudio.paInt16, channels=OUT_CHANNELS, rate=OUT_RATE, output=True,
-            output_device_index=output_device_index,
-            frames_per_buffer=960,
-        )
+        pa = None
+        output_device_index = None
+
+        # RoboVision inventories Linux devices through sounddevice/PortAudio,
+        # but the numeric indices are not stable across PyAudio builds. More
+        # importantly, BMW's production USB adapter is already proven through
+        # ALSA's plughw conversion path. Use that exact endpoint for live TTS
+        # instead of reopening the unrelated PyAudio index.
+        if sys.platform.startswith("linux") and "hw:" in selected_output:
+            import re
+            import subprocess
+
+            match = re.search(r"\b(hw:\d+,\d+)\b", selected_output)
+            if not match:
+                logger.warning(f"audio out: no ALSA hardware address in {selected_output!r}")
+                return
+            alsa_device = f"plug{match.group(1)}"
+            process = subprocess.Popen(
+                [
+                    "aplay", "-q", "-D", alsa_device, "-t", "raw",
+                    "-f", "S16_LE", "-r", str(OUT_RATE), "-c", str(OUT_CHANNELS),
+                ],
+                stdin=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            if process.stdin is None:
+                logger.warning(f"audio out: aplay did not expose stdin for {alsa_device}")
+                process.kill()
+                return
+
+            class _AplayOutput:
+                def write(self, chunk: bytes) -> None:
+                    if process.poll() is not None:
+                        detail = ""
+                        if process.stderr is not None:
+                            detail = process.stderr.read().decode("utf-8", errors="replace").strip()
+                        raise OSError(detail or f"aplay exited {process.returncode}")
+                    process.stdin.write(chunk)
+                    process.stdin.flush()
+
+                def stop_stream(self) -> None:
+                    if process.stdin and not process.stdin.closed:
+                        process.stdin.close()
+                    try:
+                        process.wait(timeout=2)
+                    except subprocess.TimeoutExpired:
+                        process.terminate()
+
+                def close(self) -> None:
+                    return
+
+            out = _AplayOutput()
+            output_device_index = alsa_device
+        else:
+            try:
+                import pyaudio
+            except Exception as e:
+                logger.warning(f"pyaudio unavailable for playback: {e}")
+                return
+            pa = pyaudio.PyAudio()
+            # Same MME-vs-WASAPI gotcha as mic capture (see
+            # PyAudioCapture._resolve_device): prefer the endpoint backing the
+            # Windows volume mixer instead of the silent MME default.
+            if selected_output.strip().isdigit():
+                output_device_index = int(selected_output.strip())
+            try:
+                if selected_output.lower() == "default":
+                    wasapi = pa.get_host_api_info_by_type(pyaudio.paWASAPI)
+                    idx = wasapi.get("defaultOutputDevice")
+                    if idx is not None and idx >= 0:
+                        output_device_index = idx
+                elif output_device_index is None:
+                    needle = selected_output.lower()
+                    for i in range(pa.get_device_count()):
+                        info = pa.get_device_info_by_index(i)
+                        if info.get("maxOutputChannels", 0) > 0 and needle in str(info.get("name", "")).lower():
+                            output_device_index = i
+                            break
+            except Exception as e:
+                logger.debug(f"audio out: WASAPI default output lookup failed, using PyAudio default: {e}")
+            out = pa.open(
+                format=pyaudio.paInt16, channels=OUT_CHANNELS, rate=OUT_RATE, output=True,
+                output_device_index=output_device_index,
+                frames_per_buffer=960,
+            )
         logger.info(f"audio out: opened playback stream for {sid} (device_index={output_device_index})")
         frame_count = 0
         mismatch_logged = False
@@ -1409,9 +1460,10 @@ class LiveKitPublisher:
                 f"audio out: {sid} received {frame_count} frames, "
                 f"writer wrote {written_frames[0]} chunks, queue backlog at close={write_queue.qsize()}"
             )
-            out.stop_stream()
-            out.close()
-            pa.terminate()
+            out.stop_stream()
+            out.close()
+            if pa is not None:
+                pa.terminate()
 
     async def stop(self) -> None:
         self._stop_event.set()