infinicode 2.8.77 → 2.8.79

package/dist/kernel/federation/dashboard-html.js

@@ -6270,13 +6270,17 @@ button.act:disabled{opacity:0.5;cursor:default;}
       var video=deviceList(inv,'video',['auto','none']);
       var input=deviceList(inv,'audio_input',['default','none']);
       var output=deviceList(inv,'audio_output',['default','none']);
-      function fill(id, list, selected){
-        var el=$(id); if(!el) return;
-        el.innerHTML='';
-        list.filter(function(x){ return !query || String(x.name||x.id).toLowerCase().indexOf(query)>-1 || String(x.id).toLowerCase().indexOf(query)>-1; }).forEach(function(x){
-          var o=document.createElement('option'); o.value=String(x.id); o.textContent=String(x.name||x.id); if(String(x.id)===String(selected||'')) o.selected=true; el.appendChild(o);
-        });
-        if(!el.value && selected){ var o=document.createElement('option'); o.value=String(selected); o.textContent=String(selected)+' (saved)'; o.selected=true; el.appendChild(o); }
+      function fill(id, list, selected){
+        var el=$(id); if(!el) return;
+        // Heartbeat polling rebuilds this panel frequently. Preserve an
+        // operator's unsaved choice instead of snapping back to the last
+        // scheduler value while they move between camera/mic/speaker fields.
+        var effectiveSelected=el.dataset.dirty==='true'?el.value:selected;
+        el.innerHTML='';
+        list.filter(function(x){ return !query || String(x.name||x.id).toLowerCase().indexOf(query)>-1 || String(x.id).toLowerCase().indexOf(query)>-1; }).forEach(function(x){
+          var o=document.createElement('option'); o.value=String(x.id); o.textContent=String(x.name||x.id); if(String(x.id)===String(effectiveSelected||'')) o.selected=true; el.appendChild(o);
+        });
+        if(!el.value && effectiveSelected){ var o=document.createElement('option'); o.value=String(effectiveSelected); o.textContent=String(effectiveSelected)+(el.dataset.dirty==='true'?' (selected)':' (saved)'); o.selected=true; el.appendChild(o); }
       }
       fill('pk-video-device', video, device.video_device||'auto');
       fill('pk-audio-input', input, device.audio_device||'default');
@@ -6296,13 +6300,27 @@ button.act:disabled{opacity:0.5;cursor:default;}
         note.textContent=hasRealInventory(inv) ? ('inventory from '+source+' · camera/mic/speaker '+counts) : (device.id ? 'no real hardware inventory reported yet · restart vision-agent + preview-agent on this robot' : 'waiting for robot heartbeat inventory');
       }
     }
-    function saveDeviceSelectors(n){
-      var device=schedulerDevice(n), id=device&&device.id; if(!id){ showOut('device inventory is not available yet'); return; }
-      var body={video_device:$('pk-video-device').value, audio_device:$('pk-audio-input').value, audio_output_device:$('pk-audio-output').value,
-        greeting_phrases:($('pk-greeting-phrases').value||'').split(String.fromCharCode(10)).map(function(x){return x.trim();}).filter(Boolean)};
-      rpAction('PATCH','/robopark/api/devices/'+encodeURIComponent(id),body).then(function(){
-        showOut('camera and microphone selection saved for '+(device.name||id));
-      }).catch(function(e){ showOut('device selection: '+e.message); });
+    function saveDeviceSelectors(n){
+      var device=schedulerDevice(n), id=device&&device.id; if(!id){ showOut('device inventory is not available yet'); return; }
+      var body={video_device:$('pk-video-device').value, audio_device:$('pk-audio-input').value, audio_output_device:$('pk-audio-output').value,
+        greeting_phrases:($('pk-greeting-phrases').value||'').split(String.fromCharCode(10)).map(function(x){return x.trim();}).filter(Boolean)};
+      var button=$('pk-device-save'),note=$('pk-device-note');
+      if(button){button.disabled=true;button.textContent='Saving...';}
+      if(note)note.textContent='saving device selection to scheduler...';
+      rpAction('PATCH','/robopark/api/devices/'+encodeURIComponent(id),body).then(function(saved){
+        // Keep the drawer's local scheduler record current immediately. The
+        // next /devices poll will confirm the same values from persistent DB.
+        Object.assign(device,saved||body);
+        ['pk-video-device','pk-audio-input','pk-audio-output'].forEach(function(field){var el=$(field);if(el)delete el.dataset.dirty;});
+        refreshDeviceSelectors(n);
+        if(note)note.textContent='saved · robot will apply selection on its next config heartbeat';
+        if(button){button.textContent='Saved';setTimeout(function(){if($('pk-device-save')===button)button.textContent='Save device selection + greetings';},1400);}
+        showOut('camera, microphone, and speaker selection saved for '+(device.name||id));
+      }).catch(function(e){
+        if(note)note.textContent='save failed · '+e.message;
+        if(button)button.textContent='Retry save';
+        showOut('device selection: '+e.message);
+      }).then(function(){if(button)button.disabled=false;});
     }
     function fmtUptime(secs){
       if(secs==null) return '';
@@ -6705,7 +6723,17 @@ button.act:disabled{opacity:0.5;cursor:default;}
          b.innerHTML += '<div class="pk-ctl" style="margin-top:0.5rem"><button class="rp-btn danger" id="pk-recover" data-robot="'+esc(n.name)+'">Recover robot</button><span class="pk-note" style="margin:0">clears stale sessions and queued triggers for this robot</span></div>';
          var deviceSearch=$('pk-device-search'); if(deviceSearch) deviceSearch.addEventListener('input', function(){ refreshDeviceSelectors(n); });
          var deviceSave=$('pk-device-save'); if(deviceSave) deviceSave.addEventListener('click', function(){ saveDeviceSelectors(n); });
-         var outputSelect=$('pk-audio-output'); if(outputSelect) outputSelect.addEventListener('change', function(){ refreshDeviceSelectors(n); });
+         ['pk-video-device','pk-audio-input','pk-audio-output'].forEach(function(field){
+           var select=$(field);if(!select)return;
+           select.addEventListener('change',function(){
+             select.dataset.dirty='true';
+             var note=$('pk-device-note');if(note)note.textContent='unsaved selection · click Save device selection + greetings';
+             if(field==='pk-audio-output'){
+               var selectedLabel=$('pk-spk-selected'),option=select.options&&select.selectedIndex>=0?select.options[select.selectedIndex]:null;
+               if(selectedLabel)selectedLabel.textContent=option?String(option.textContent||option.value):String(select.value||'default');
+             }
+           });
+         });
          var micListen=$('pk-mic-listen');if(micListen)micListen.addEventListener('click',function(){setMicMonitorAudible(!micMonitorAudible);});
          var micVolume=$('pk-mic-volume');if(micVolume)micVolume.addEventListener('input',function(){micMonitorVolume=Math.max(0,Math.min(1,Number(micVolume.value||80)/100));lkAudioEls.forEach(function(el){el.volume=micMonitorVolume;});});
          startCam(n); startMeters(n); loadEffectiveConfig(schedId(n)); refreshSupervisorPanel(n);
@@ -7153,12 +7181,13 @@ button.act:disabled{opacity:0.5;cursor:default;}
       var phrase=String((($('pk-spk-phrase')||{}).value)||'Hello, I am ready to talk.').trim();
       var output=(($('pk-audio-output')||{}).value)||'default';
       var input=(($('pk-audio-input')||{}).value)||'default';
+      var outputName=selectedRobotOutput(),inputName=selectedRobotMic();
       // Animate the meter with a synthetic "during-test" peak so the
       // operator sees something happen immediately while waiting for
       // the real recording.
       _spkTestSetLive(robotId, {live:true, rms: 0.45, pass: undefined, waveform: null});
       rpAction('POST','/robopark/api/robots/'+encodeURIComponent(robotId)+'/shell/speaker-test',
-        {mode:mode, text:phrase, frequency:freq, duration:dur, amplitude:0.6, threshold_db:-30, output:output, input:input})
+        {mode:mode, text:phrase, frequency:freq, duration:dur, amplitude:0.6, threshold_db:-30, output:output, input:input, output_name:outputName, input_name:inputName})
         .then(function(q){
           // long-poll up to 8s, then fall back to 12s of result polling
           if(status) status.textContent = mode==='tts'?'playing cached voice on '+selectedRobotOutput()+'…':'playing tone + recording…';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.77",
+  "version": "2.8.79",
   "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

@@ -3472,8 +3472,10 @@ class SpeakerTestRequest(BaseModel):
     duration: Optional[float] = None
     amplitude: Optional[float] = None
     threshold_db: Optional[float] = None
-    output: Optional[str] = None
-    input: Optional[str] = None
+    output: Optional[str] = None
+    input: Optional[str] = None
+    output_name: Optional[str] = None
+    input_name: Optional[str] = None
     sample_rate: Optional[int] = None
 
 

package/packages/robopark/scheduler/preview_agent.py

@@ -846,7 +846,18 @@ class PreviewAgent:
                 return
             self._speaker_test_in_flight = True
             from robot_supervisor import _speaker_roundtrip_test
-            result = await asyncio.to_thread(_speaker_roundtrip_test, request.get("params") or {})
+            # LiveKit owns the USB microphone continuously. Release that owner
+            # for an explicit hardware test, then restore the same session.
+            restore_state = self._current_state if self._publisher else None
+            if restore_state:
+                await self._stop_publisher()
+                await asyncio.sleep(0.35)
+            try:
+                result = await asyncio.to_thread(_speaker_roundtrip_test, request.get("params") or {})
+                result["media_owner_paused"] = bool(restore_state)
+            finally:
+                if restore_state and restore_state.active:
+                    await self._start_publisher(restore_state)
             result_response = await self._session.post(
                 f"{self.scheduler_url.rstrip('/')}/api/devices/{self.device_id}/supervisor-output",
                 json={"kind": "speaker_test", "service": None, "payload": result,
@@ -1092,8 +1103,9 @@ class LiveKitPublisher:
         self.audio_source: Optional[rtc.AudioSource] = None
         self.audio_track: Optional[rtc.LocalAudioTrack] = None
         self._stop_event = asyncio.Event()
-        self._tasks: list[asyncio.Task] = []
-        self._capture: Optional["VideoCapture"] = None
+        self._tasks: list[asyncio.Task] = []
+        self._capture: Optional["VideoCapture"] = None
+        self._mic_capture: Optional["AudioCapture"] = None
         # Motion sampling state belongs to the publisher instance.  Keeping it
         # initialized here prevents shutdown/reopen paths from raising while
         # the camera is being handed between preview and voice sessions.
@@ -1373,7 +1385,7 @@ class LiveKitPublisher:
             out.close()
             pa.terminate()
 
-    async def stop(self) -> None:
+    async def stop(self) -> None:
         self._stop_event.set()
         for t in self._tasks:
             t.cancel()
@@ -1381,7 +1393,10 @@ class LiveKitPublisher:
                 await t
             except asyncio.CancelledError:
                 pass
-        self._tasks.clear()
+        self._tasks.clear()
+        if self._mic_capture:
+            await asyncio.to_thread(self._mic_capture.stop)
+            self._mic_capture = None
         if self._capture:
             self._capture.stop()
             self._capture = None
@@ -1442,10 +1457,11 @@ class LiveKitPublisher:
 
     async def _audio_loop(self) -> None:
         assert self.audio_source is not None
-        mic = create_audio_capture(self.agent.audio_device)
-        if mic is None:
+        mic = create_audio_capture(self.agent.audio_device)
+        if mic is None:
             logger.warning("audio_loop: create_audio_capture returned None, mic will not publish")
-            return
+            return
+        self._mic_capture = mic
         logger.info(f"audio_loop: mic capture started ({type(mic).__name__})")
         # Read in bigger batches (100ms) instead of one 20ms frame per
         # asyncio.to_thread() dispatch. Each dispatch/poll cycle has a fixed

package/packages/robopark/scheduler/robot_supervisor.py

@@ -468,14 +468,14 @@ def _resolve_audio_device(pa, selected: str, kind: str) -> Optional[int]:
     result is recorded so the operator can see it."""
     if selected is None:
         selected = "default"
-    s = str(selected).strip()
-    if s == "" or s.lower() == "default":
-        try:
-            wasapi = pa.get_host_api_info_by_type(pyaudio.paWASAPI)
-            key = "defaultInputDevice" if kind == "input" else "defaultOutputDevice"
-            idx = wasapi.get(key)
-            if idx is not None and idx >= 0:
-                return idx
+    s = str(selected).strip()
+    if s == "" or s.lower() == "default":
+        try:
+            info = (pa.get_default_input_device_info() if kind == "input"
+                    else pa.get_default_output_device_info())
+            idx = info.get("index")
+            if idx is not None and idx >= 0:
+                return int(idx)
         except Exception:
             pass
         return None
@@ -592,8 +592,10 @@ def _speaker_roundtrip_test(params: dict) -> dict:
     dur = float(params.get("duration", SPEAKER_TEST_DURATION_S))
     amp = float(params.get("amplitude", SPEAKER_TEST_AMPLITUDE))
     threshold_db = float(params.get("threshold_db", SPEAKER_TEST_PEAK_DB_THRESHOLD))
-    out_name = params.get("output", os.environ.get("ROBOPARK_AUDIO_OUTPUT") or SPEAKER_TEST_OUTPUT_DEVICE)
-    in_name = params.get("input", os.environ.get("ROBOPARK_AUDIO_INPUT") or SPEAKER_TEST_INPUT_DEVICE)
+    # RoboVision inventory indices belong to sounddevice and may not match
+    # PyAudio's index space. Prefer the reported hardware name for lookup.
+    out_name = params.get("output_name") or params.get("output", os.environ.get("ROBOPARK_AUDIO_OUTPUT") or SPEAKER_TEST_OUTPUT_DEVICE)
+    in_name = params.get("input_name") or params.get("input", os.environ.get("ROBOPARK_AUDIO_INPUT") or SPEAKER_TEST_INPUT_DEVICE)
     source_rate = int(params.get("sample_rate", SPEAKER_TEST_SAMPLE_RATE))
     if mode not in ("tone", "tts"):
         return {"ok": False, "error": f"unsupported speaker test mode: {mode}"}