infinicode 2.8.75 → 2.8.77

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

@@ -1083,7 +1083,16 @@ button.act:disabled{opacity:0.5;cursor:default;}
 
   <!-- ═══ Setup ═══ -->
   <div class="rp-sub" id="rp-sub-setup">
-    <!-- Add LiveKit server -->
+    <div class="rp-form" id="rp-provider-secrets">
+      <h3>Voice provider secret</h3>
+      <div class="rp-quickrow">
+        <div class="rp-field" style="flex:1"><label>ElevenLabs API key</label><input type="password" id="rp-elevenlabs-key" autocomplete="new-password" placeholder="stored only on the scheduler"></div>
+        <button class="rp-btn primary" id="rp-elevenlabs-save" style="height:fit-content">Save secret</button>
+      </div>
+      <div class="rp-autonote" id="rp-elevenlabs-status">not configured · cached voice speaker tests require this key</div>
+    </div>
+
+    <!-- Add LiveKit server -->
     <div class="rp-form" id="rp-addserver">
       <h3>Add LiveKit server</h3>
       <div class="rp-quickrow">
@@ -1893,11 +1902,25 @@ button.act:disabled{opacity:0.5;cursor:default;}
         .then(function(){ pmBusy=false; applyReadOnly(); });
     });
   })();
-  function pollSettings(){
-    fetch('/robopark/api/settings'+QS,{cache:'no-store'}).then(function(r){return r.json();}).then(function(s){
-      if(s && typeof s.production_mode!=='undefined') setPm(!!s.production_mode);
-    }).catch(function(){});
-  }
+  function pollSettings(){
+    fetch('/robopark/api/settings'+QS,{cache:'no-store'}).then(function(r){return r.json();}).then(function(s){
+      if(s && typeof s.production_mode!=='undefined') setPm(!!s.production_mode);
+      var providerStatus=$('rp-elevenlabs-status');
+      if(providerStatus) providerStatus.textContent=s&&s.elevenlabs_configured
+        ? 'configured · source: '+(s.elevenlabs_source==='environment'?'scheduler environment':'persistent scheduler store')
+        : 'not configured · cached voice speaker tests require this key';
+    }).catch(function(){});
+  }
+
+  var elevenlabsSave=$('rp-elevenlabs-save');
+  if(elevenlabsSave) elevenlabsSave.addEventListener('click',function(){
+    var input=$('rp-elevenlabs-key'), key=input?input.value.trim():'';
+    if(key.length<8){ showOut('Enter a valid ElevenLabs API key'); return; }
+    elevenlabsSave.disabled=true;
+    rpAction('POST','/robopark/api/settings/provider-secret',{provider:'elevenlabs',api_key:key}).then(function(){
+      input.value=''; showOut('ElevenLabs secret saved on scheduler'); pollSettings();
+    }).catch(function(e){ showOut('ElevenLabs secret: '+e.message); }).then(function(){elevenlabsSave.disabled=false;});
+  });
 
   function robotName(x){ return x.robot_id||x.id||x.name||'robot'; }
   function endSession(id){
@@ -6190,6 +6213,9 @@ button.act:disabled{opacity:0.5;cursor:default;}
       if(!directRef){ visionOn=false; directImg.src=''; directImg.style.display='none'; return; }
       var directCamNote=$('pk-camnote'), directLiveNote=$('pk-golivenote'), directRes=$('pk-camres');
       visionOn=true;
+      directImg.style.display='block';
+      if(directCamNote)directCamNote.textContent='opening RoboVision camera relay...';
+      if(directRes)directRes.textContent='CONNECTING';
       directImg.onerror=function(){ visionOn=false; directImg.style.display='none'; directImg.src=''; if(directCamNote) directCamNote.textContent='RoboVision feed unavailable on robot'; if(directLiveNote) directLiveNote.textContent='camera unavailable'; if(directRes) directRes.textContent='OFFLINE'; };
       directImg.onload=function(){ directImg.style.display='block'; if(directCamNote) directCamNote.textContent='live camera via RoboVision mesh relay'; if(directLiveNote) directLiveNote.textContent='live'; if(directRes) directRes.textContent='LIVE'; };
       directImg.src='/fed/media/robots/'+encodeURIComponent(directRef)+'/video_feed'+QS+(QS?'&':'?')+'_='+Date.now();
@@ -6879,7 +6905,7 @@ button.act:disabled{opacity:0.5;cursor:default;}
         .catch(function(){ idleCam('unreachable'); });
     }
     function idleCam(reason){
-      var cc=$('pk-camcv'), msg={connecting:'connecting to live session…', idle:'robot idle · no live session', production_mode_off:'production mode off', 'no-sdk':'live session up · loading video…', unreachable:'scheduler unreachable'}[reason]||'no live feed';
+      var cc=$('pk-camcv'), msg={connecting:'connecting to RoboVision camera relay…', idle:'camera relay standing by', production_mode_off:'production mode off', 'no-sdk':'voice session active · loading microphone…', unreachable:'camera relay unreachable'}[reason]||'no live feed';
       if(cc&&cc.getContext){ var cx=cc.getContext('2d'); cx.fillStyle='#0b0d12'; cx.fillRect(0,0,cc.width,cc.height); cx.strokeStyle='rgba(255,255,255,0.05)'; for(var y=0;y<cc.height;y+=4){cx.beginPath();cx.moveTo(0,y);cx.lineTo(cc.width,y);cx.stroke();} cx.fillStyle='#5a6a80'; cx.font='11px monospace'; cx.textAlign='center'; cx.fillText(msg, cc.width/2, cc.height/2); }
       var res=$('pk-camres'); if(res) res.textContent = reason==='idle'?'idle':'—';
       var note=$('pk-camnote'); if(note) note.textContent = reason==='idle'?'the feed goes live automatically when the robot opens a session':msg;
@@ -6985,7 +7011,17 @@ button.act:disabled{opacity:0.5;cursor:default;}
       (function loop(){ if(!$('pk-micbars')||drawerId==null) return;
         // MIC — real RMS from the subscribed LiveKit mic track (else no signal).
         var lvl=0;
-        if(micAnalyser){ micAnalyser.getByteTimeDomainData(buf); var sum=0; for(var q=0;q<buf.length;q++){ var v=(buf[q]-128)/128; sum+=v*v; } lvl=Math.min(1, Math.sqrt(sum/buf.length)*3.4); }
+        if(micAnalyser){
+          micAnalyser.getByteTimeDomainData(buf);
+          var sum=0;
+          for(var q=0;q<buf.length;q++){ var v=(buf[q]-128)/128; sum+=v*v; }
+          var rms=Math.sqrt(sum/buf.length);
+          // USB microphones commonly sit around -55 dBFS at room level and
+          // -20 dBFS when spoken into. Map that useful range to 0..100 rather
+          // than displaying normalized RMS directly (which looked stuck at 1%).
+          var db=rms>0 ? 20*Math.log10(rms) : -90;
+          lvl=Math.max(0,Math.min(1,(db+60)/45));
+        }
         for(var i=0;i<mi.length;i++){ var on=i<lvl*mi.length; mi[i].style.height=(3+(on?lvl*13:0))+'px'; mi[i].style.background=on?(i<mi.length*0.7?'var(--ok)':i<mi.length*0.9?'var(--warn)':'var(--bad)'):'var(--glass-border)'; }
         set('pk-micval', micAnalyser?Math.round(lvl*100)+'%':'—');
         set('pk-micstate', micAnalyser?('selected '+selectedRobotMic()+' · '+(lvl>0.12?'live, hearing audio':'live, quiet')):('selected '+selectedRobotMic()+' · '+micMonitorState));
@@ -7099,8 +7135,9 @@ button.act:disabled{opacity:0.5;cursor:default;}
         + '<div><span class="l">duration</span><span class="v">'+esc(result.duration+' s')+'</span></div>'
         + '<div><span class="l">latency</span><span class="v">'+esc(result.duration_ms+' ms')+'</span></div>'
         + '<div><span class="l">output</span><span class="v">'+esc(result.output_device)+'</span></div>'
-        + '<div><span class="l">input</span><span class="v">'+esc(result.input_device)+'</span></div>'
-        + '</div>';
+        + '<div><span class="l">input</span><span class="v">'+esc(result.input_device)+'</span></div>'
+        + '<div><span class="l">format</span><span class="v">'+esc((result.output_sample_rate||result.sample_rate)+' Hz / '+(result.output_channels||1)+'ch out · '+(result.input_sample_rate||result.sample_rate)+' Hz / '+(result.input_channels||1)+'ch in')+'</span></div>'
+        + '</div>';
       var diag = result.diagnostic ? '<div class="pk-spk-diag">'+esc(result.diagnostic)+'</div>' : '';
       host.innerHTML = '<div class="pk-spk-result '+(result.pass?'ok':'bad')+'">'
         + banner + meta + diag + '</div>';

package/package.json

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

@@ -69,7 +69,14 @@ ELEVENLABS_API_KEY = (
     or os.getenv("ELEVENLABS_KEY", "").strip()
     or os.getenv("ELEVEN_API_KEY", "").strip()
 )
-ELEVENLABS_BASE_URL = os.getenv("ELEVENLABS_BASE_URL", "https://api.elevenlabs.io").rstrip("/")
+ELEVENLABS_BASE_URL = os.getenv("ELEVENLABS_BASE_URL", "https://api.elevenlabs.io").rstrip("/")
+
+
+async def _get_elevenlabs_api_key() -> str:
+    """Resolve the provider key without ever returning it through public APIs."""
+    if ELEVENLABS_API_KEY:
+        return ELEVENLABS_API_KEY
+    return (await get_setting("elevenlabs_api_key") or "").strip()
 
 # Optional base URL of a local Kokoro TTS server. When set, /api/voices/kokoro
 # will proxy its /v1/audio/voices endpoint to return the dynamic list of voices
@@ -1991,12 +1998,29 @@ async def get_settings():
     """Public settings with secret values reduced to status only."""
     pm = await get_production_mode()
     has_default_token = bool(await get_setting("default_enrollment_token"))
+    elevenlabs_key = await _get_elevenlabs_api_key()
     return {
         "production_mode": pm,
         "default_enrollment_token_set": has_default_token,
         "agent_token_configured": bool(ROBOPARK_AGENT_TOKEN),
         "agent_token_source": "environment" if os.getenv("ROBOPARK_AGENT_TOKEN", "").strip() else "scheduler_secret_file",
+        "elevenlabs_configured": bool(elevenlabs_key),
+        "elevenlabs_source": "environment" if ELEVENLABS_API_KEY else ("scheduler_store" if elevenlabs_key else None),
     }
+
+
+@app.post("/api/settings/provider-secret")
+async def set_provider_secret(payload: dict):
+    """Persist a provider credential while only exposing configured status."""
+    provider = str(payload.get("provider") or "").strip().lower()
+    api_key = str(payload.get("api_key") or "").strip()
+    if provider != "elevenlabs":
+        raise HTTPException(400, "unsupported provider")
+    if len(api_key) < 8:
+        raise HTTPException(400, "ElevenLabs API key must be at least 8 characters")
+    await set_setting("elevenlabs_api_key", api_key)
+    await _log_history("settings", "provider_secret", provider, "updated", "operator")
+    return {"ok": True, "provider": provider, "configured": True, "source": "scheduler_store"}
 
 @app.put("/api/settings")
 async def update_settings(payload: SettingsPayload):
@@ -3462,8 +3486,9 @@ async def _cached_speaker_tts(robot_id: str, text: str) -> dict:
     voice_id = stack.tts_voice if stack else "21m00Tcm4TlvDq8ikWAM"
     if provider != "elevenlabs":
         raise HTTPException(400, f"Cached voice test currently requires ElevenLabs; selected stack uses {provider}")
-    if not ELEVENLABS_API_KEY:
-        raise HTTPException(503, "ELEVENLABS_API_KEY is not configured on the scheduler")
+    elevenlabs_key = await _get_elevenlabs_api_key()
+    if not elevenlabs_key:
+        raise HTTPException(503, "ElevenLabs is not configured; open Control Center > Setup > Voice provider secret")
     if not voice_id:
         raise HTTPException(400, "Selected voice stack has no ElevenLabs voice id")
     cache_dir = os.path.join(os.path.dirname(DB_PATH), "tts-test-cache")
@@ -3479,7 +3504,7 @@ async def _cached_speaker_tts(robot_id: str, text: str) -> dict:
             response = await client.post(
                 f"{ELEVENLABS_BASE_URL}/v1/text-to-speech/{voice_id}",
                 params={"output_format": "pcm_24000"},
-                headers={"xi-api-key": ELEVENLABS_API_KEY, "Accept": "audio/pcm"},
+                headers={"xi-api-key": elevenlabs_key, "Accept": "audio/pcm"},
                 json={"text": phrase, "model_id": "eleven_flash_v2_5"},
             )
         if response.status_code != 200:

package/packages/robopark/scheduler/robot_supervisor.py

@@ -458,7 +458,7 @@ SPEAKER_TEST_INPUT_DEVICE = None
 SPEAKER_TEST_PEAK_DB_THRESHOLD = -30.0
 
 
-def _resolve_audio_device(pa, selected: str, kind: str) -> Optional[int]:
+def _resolve_audio_device(pa, selected: str, kind: str) -> Optional[int]:
     """Resolve a free-form device name/index to a PyAudio device index.
 
     kind is "input" or "output". None / "default" picks the WASAPI
@@ -491,9 +491,93 @@ def _resolve_audio_device(pa, selected: str, kind: str) -> Optional[int]:
             continue
         if needle in str(info.get("name", "")).lower():
             return i
-    return None
-
-
+    return None
+
+
+def _audio_rate_candidates(info: dict, requested_rate: int) -> list[int]:
+    """Return practical PCM rates with the device native rate first."""
+    rates = []
+    for value in (
+        info.get("defaultSampleRate"),
+        requested_rate,
+        48000,
+        44100,
+        32000,
+        24000,
+        16000,
+    ):
+        try:
+            rate = int(round(float(value)))
+        except (TypeError, ValueError):
+            continue
+        if rate > 0 and rate not in rates:
+            rates.append(rate)
+    return rates
+
+
+def _resample_pcm16_mono(raw: bytes, source_rate: int, target_rate: int) -> bytes:
+    """Linearly resample little-endian mono PCM16 without optional DSP deps."""
+    if source_rate == target_rate or not raw:
+        return raw
+    source_count = len(raw) // 2
+    target_count = max(1, int(round(source_count * target_rate / source_rate)))
+    source = struct.unpack(f"<{source_count}h", raw[:source_count * 2])
+    if source_count == 1:
+        return struct.pack("<h", source[0]) * target_count
+    scale = (source_count - 1) / max(1, target_count - 1)
+    result = bytearray(target_count * 2)
+    for index in range(target_count):
+        position = index * scale
+        left = int(position)
+        right = min(left + 1, source_count - 1)
+        fraction = position - left
+        value = int(round(source[left] + (source[right] - source[left]) * fraction))
+        struct.pack_into("<h", result, index * 2, value)
+    return bytes(result)
+
+
+def _open_pcm_stream(pa, pyaudio_module, kind: str, device_index: Optional[int],
+                     requested_rate: int):
+    """Open a PCM16 stream using the first format the device accepts."""
+    try:
+        if device_index is None:
+            info = (pa.get_default_output_device_info() if kind == "output"
+                    else pa.get_default_input_device_info())
+            device_index = int(info.get("index"))
+        else:
+            info = pa.get_device_info_by_index(device_index)
+    except Exception as exc:
+        raise OSError(f"selected {kind} device is unavailable: {exc}") from exc
+
+    channel_key = "maxOutputChannels" if kind == "output" else "maxInputChannels"
+    max_channels = int(info.get(channel_key, 0) or 0)
+    if max_channels < 1:
+        raise OSError(f"{info.get('name', device_index)} has no {kind} channels")
+    channels = [2, 1] if kind == "output" and max_channels >= 2 else [1]
+    errors = []
+    for rate in _audio_rate_candidates(info, requested_rate):
+        for channel_count in channels:
+            kwargs = {
+                "format": pyaudio_module.paInt16,
+                "channels": channel_count,
+                "rate": rate,
+                kind: True,
+                f"{kind}_device_index": device_index,
+            }
+            if kind == "input":
+                kwargs["frames_per_buffer"] = 1024
+            try:
+                stream = pa.open(**kwargs)
+                return stream, rate, channel_count, info
+            except Exception as exc:
+                errors.append(f"{rate}Hz/{channel_count}ch: {exc}")
+    attempts = "; ".join(errors[-4:])
+    raise OSError(
+        f"{info.get('name', device_index)} supports no usable PCM16 {kind} format"
+        + (f" ({attempts})" if attempts else "")
+    )
+
+
 def _speaker_roundtrip_test(params: dict) -> dict:
     """Play a test tone + record the mic simultaneously; return metrics.
 
@@ -510,7 +594,7 @@ def _speaker_roundtrip_test(params: dict) -> dict:
     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)
-    sample_rate = int(params.get("sample_rate", SPEAKER_TEST_SAMPLE_RATE))
+    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}"}
     if mode == "tone" and not (50.0 <= freq <= 8000.0):
@@ -527,8 +611,10 @@ def _speaker_roundtrip_test(params: dict) -> dict:
             return {"ok": False, "error": f"invalid cached TTS audio: {e}"}
         if len(mono_pcm) < 480 or len(mono_pcm) % 2:
             return {"ok": False, "error": "cached TTS audio is empty or malformed"}
-        dur = len(mono_pcm) / 2 / sample_rate
-    n_samples = int(sample_rate * dur)
+        dur = len(mono_pcm) / 2 / source_rate
+        if dur > 10.0:
+            return {"ok": False, "error": "cached TTS audio exceeds the 10 second test limit"}
+    n_samples = int(source_rate * dur)
     if n_samples < 480:
         return {"ok": False, "error": "duration too short"}
 
@@ -542,44 +628,49 @@ def _speaker_roundtrip_test(params: dict) -> dict:
     out_label = _dev_name(out_idx)
     in_label = _dev_name(in_idx)
 
-    if mono_pcm is not None:
-        frames = bytearray()
-        for pos in range(0, len(mono_pcm), 2):
-            sample = mono_pcm[pos:pos + 2]
-            frames.extend(sample + sample)
-        raw = bytes(frames)
-    else:
-        frames = bytearray()
-        peak_value = int(32767 * amp)
-        for n in range(n_samples):
-            env = min(1.0, n / (sample_rate * 0.004), (n_samples - n) / (sample_rate * 0.008))
-            value = int(peak_value * env * math.sin(2 * math.pi * freq * n / sample_rate))
-            frames.extend(struct.pack("<hh", value, value))
-        raw = bytes(frames)
-
-    recorded_peak = 0
-    recorded_rms = 0.0
-    err = None
-    t0 = time.monotonic()
-    try:
-        out_stream = pa.open(
-            format=pyaudio.paInt16,
-            channels=2,
-            rate=sample_rate,
-            output=True,
-            output_device_index=out_idx,
-        )
-        chunk = 1024
-        in_stream = pa.open(
-            format=pyaudio.paInt16,
-            channels=1,
-            rate=sample_rate,
-            input=True,
-            input_device_index=in_idx,
-            frames_per_buffer=chunk,
-        )
-        in_stream.start_stream()
-        chunk_bytes = chunk * 2 * 2
+    recorded_peak = 0
+    recorded_rms = 0.0
+    err = None
+    output_rate = None
+    input_rate = None
+    output_channels = None
+    input_channels = None
+    t0 = time.monotonic()
+    out_stream = None
+    in_stream = None
+    try:
+        out_stream, output_rate, output_channels, out_info = _open_pcm_stream(
+            pa, pyaudio, "output", out_idx, source_rate
+        )
+        in_stream, input_rate, input_channels, in_info = _open_pcm_stream(
+            pa, pyaudio, "input", in_idx, source_rate
+        )
+        out_label = str(out_info.get("name", out_label))
+        in_label = str(in_info.get("name", in_label))
+
+        if mono_pcm is not None:
+            output_mono = _resample_pcm16_mono(mono_pcm, source_rate, output_rate)
+        else:
+            output_samples = int(output_rate * dur)
+            frames = bytearray(output_samples * 2)
+            peak_value = int(32767 * amp)
+            for n in range(output_samples):
+                env = min(1.0, n / (output_rate * 0.004),
+                          (output_samples - n) / (output_rate * 0.008))
+                value = int(peak_value * env * math.sin(2 * math.pi * freq * n / output_rate))
+                struct.pack_into("<h", frames, n * 2, value)
+            output_mono = bytes(frames)
+        if output_channels == 2:
+            frames = bytearray(len(output_mono) * 2)
+            for pos in range(0, len(output_mono), 2):
+                frames[pos * 2:pos * 2 + 4] = output_mono[pos:pos + 2] * 2
+            raw = bytes(frames)
+        else:
+            raw = output_mono
+
+        chunk = 1024
+        in_stream.start_stream()
+        chunk_bytes = chunk * 2 * output_channels
         pos = 0
         peak_acc = 0
         rms_acc = 0.0
@@ -601,9 +692,10 @@ def _speaker_roundtrip_test(params: dict) -> dict:
                         n_samp += 1
             except Exception:
                 pass
-        out_stream.stop_stream(); out_stream.close()
-        try:
-            tail = in_stream.read(n_samples, exception_on_overflow=False)
+        out_stream.stop_stream(); out_stream.close(); out_stream = None
+        try:
+            tail_frames = min(int(input_rate * 0.35), max(0, in_stream.get_read_available()))
+            tail = in_stream.read(tail_frames, exception_on_overflow=False) if tail_frames else b""
             for s in range(0, len(tail) - 1, 2):
                 v = int.from_bytes(tail[s:s+2], "little", signed=True)
                 a = abs(v)
@@ -612,13 +704,19 @@ def _speaker_roundtrip_test(params: dict) -> dict:
                 n_samp += 1
         except Exception:
             pass
-        in_stream.stop_stream(); in_stream.close()
+        in_stream.stop_stream(); in_stream.close(); in_stream = None
         recorded_peak = peak_acc
         recorded_rms = (rms_acc / max(1, n_samp)) ** 0.5
-    except Exception as e:
-        err = f"{type(e).__name__}: {e}"
-    finally:
-        try: pa.terminate()
+    except Exception as e:
+        err = f"{type(e).__name__}: {e}"
+    finally:
+        for stream in (out_stream, in_stream):
+            if stream is not None:
+                try: stream.stop_stream()
+                except Exception: pass
+                try: stream.close()
+                except Exception: pass
+        try: pa.terminate()
         except Exception: pass
     duration_ms = int((time.monotonic() - t0) * 1000)
     if err:
@@ -645,7 +743,11 @@ def _speaker_roundtrip_test(params: dict) -> dict:
         "frequency": freq,
         "duration": dur,
         "duration_ms": duration_ms,
-        "sample_rate": sample_rate,
+        "sample_rate": source_rate,
+        "output_sample_rate": output_rate,
+        "input_sample_rate": input_rate,
+        "output_channels": output_channels,
+        "input_channels": input_channels,
         "amplitude": amp,
         "output_device": out_label,
         "input_device": in_label,