@oneciel-ai/ciel-runtime 0.2.7 → 0.2.8

package/ciel_runtime.py

@@ -4388,8 +4388,8 @@ _CHANNEL_TRANSCRIPT_SCOPE: dict[str, Any] = {'runtime': '', 'started_at': 0.0, '
 _CHANNEL_STDIN_RECOVERY_CACHE: dict[str, Any] = {'checked_at': 0.0, 'last_id': None, 'marker': None, 'recovered_last_id': None}
 def channel_transcript_repository() -> ChannelTranscriptRepository: return channel_wake_context().transcript_repository()
 
-def _set_channel_transcript_scope(runtime: str, *, started_at: float | None = None, codex_home: Path | None = None) -> None:
-    channel_wake_context().set_transcript_scope(runtime, started_at=started_at, codex_home=codex_home)
+def _set_channel_transcript_scope(runtime: str, *, started_at: float | None = None, codex_home: Path | None = None, cwd: Path | None = None) -> None:
+    channel_wake_context().set_transcript_scope(runtime, started_at=started_at, codex_home=codex_home, cwd=cwd)
 
 def _channel_transcript_roots() -> tuple[tuple[Path, str], ...]: return channel_wake_context().transcript_roots()
 def _latest_claude_transcript_path(ttl_seconds: float = 2.0) -> Path | None: return channel_wake_context().latest_transcript_path(ttl_seconds)

package/ciel_runtime_support/channel_transcript_repository.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from datetime import datetime
+import json
 from pathlib import Path
 from typing import Any
 
@@ -21,6 +23,7 @@ class ChannelTranscriptRepository:
         *,
         started_at: float | None = None,
         codex_home: Path | None = None,
+        cwd: Path | None = None,
     ) -> None:
         self.scope["runtime"] = str(runtime or "").strip().casefold()
         self.scope["started_at"] = (
@@ -31,6 +34,7 @@ class ChannelTranscriptRepository:
             if codex_home is not None
             else None
         )
+        self.scope["cwd"] = Path(cwd).expanduser() if cwd is not None else None
         self.cache.clear()
         self.cache.update({"checked_at": 0.0, "path": None})
 
@@ -59,6 +63,8 @@ class ChannelTranscriptRepository:
         latest: Path | None = None
         latest_mtime = -1.0
         scope_started_at = float(self.scope.get("started_at") or 0.0)
+        runtime = str(self.scope.get("runtime") or "").strip().casefold()
+        scope_cwd = self._normalized_cwd(self.scope.get("cwd"))
         for root, pattern in self.roots():
             try:
                 paths = root.glob(pattern)
@@ -71,6 +77,17 @@ class ChannelTranscriptRepository:
                     continue
                 if scope_started_at > 0 and mtime < scope_started_at - 1.0:
                     continue
+                if runtime == "codex" and (scope_started_at > 0 or scope_cwd):
+                    session_started_at, session_cwd = self._codex_session_identity(path)
+                    if (
+                        session_started_at is not None
+                        and scope_started_at > 0
+                        and session_started_at < scope_started_at - 1.0
+                    ):
+                        continue
+                    normalized_session_cwd = self._normalized_cwd(session_cwd)
+                    if scope_cwd and normalized_session_cwd and normalized_session_cwd != scope_cwd:
+                        continue
                 if mtime > latest_mtime:
                     latest = path
                     latest_mtime = mtime
@@ -78,6 +95,36 @@ class ChannelTranscriptRepository:
         self.cache["path"] = latest
         return latest
 
+    @staticmethod
+    def _normalized_cwd(value: Any) -> str:
+        if value is None:
+            return ""
+        return str(value).strip().replace("\\", "/").rstrip("/").casefold()
+
+    @staticmethod
+    def _codex_session_identity(path: Path) -> tuple[float | None, str]:
+        try:
+            with path.open("r", encoding="utf-8", errors="replace") as stream:
+                record = json.loads(stream.readline(64 * 1024))
+        except (OSError, UnicodeError, ValueError, TypeError):
+            return None, ""
+        if not isinstance(record, dict):
+            return None, ""
+        payload = record.get("payload")
+        metadata = payload if isinstance(payload, dict) else {}
+        raw_timestamp = metadata.get("timestamp") or record.get("timestamp")
+        started_at: float | None = None
+        if isinstance(raw_timestamp, (int, float)):
+            started_at = float(raw_timestamp)
+        elif isinstance(raw_timestamp, str) and raw_timestamp.strip():
+            try:
+                started_at = datetime.fromisoformat(
+                    raw_timestamp.strip().replace("Z", "+00:00")
+                ).timestamp()
+            except ValueError:
+                started_at = None
+        return started_at, str(metadata.get("cwd") or "")
+
     @staticmethod
     def read_tail_text(
         path: Path,

package/ciel_runtime_support/channel_wake_context.py

@@ -358,9 +358,10 @@ class ChannelWakeContext:
         *,
         started_at: float | None = None,
         codex_home: Path | None = None,
+        cwd: Path | None = None,
     ) -> None:
         self.transcript_repository().set_scope(
-            runtime, started_at=started_at, codex_home=codex_home
+            runtime, started_at=started_at, codex_home=codex_home, cwd=cwd
         )
 
     def transcript_roots(self) -> tuple[tuple[Path, str], ...]:

package/ciel_runtime_support/runtime_constants.py

@@ -93,7 +93,7 @@ OFFICIAL_CHANNEL_PLUGINS = {
 }
 
 APP_NAME = "Ciel Runtime"
-VERSION = "0.2.7"
+VERSION = "0.2.8"
 CREDITS = "Credits: One Ciel LLC"
 PRELAUNCH_CANCEL = 10
 PRELAUNCH_LAUNCH_CODEX = 11

package/ciel_runtime_support/runtime_launch.py

@@ -1000,6 +1000,7 @@ def run_codex(
         _set_channel_transcript_scope(
             "codex",
             codex_home=Path(env.get("CODEX_HOME") or (Path.home() / ".codex")),
+            cwd=launch_cwd,
         )
         if not use_native_codex:
             start_codex_mcp_channel_sse_for_launch(cfg, codex_mcp_config, allowed_server_names=codex_channel_owned_names)

package/ciel_runtime_support/web_ui.py

@@ -303,6 +303,11 @@ def render_web_chat_page(
     let mediaRecorder = null;
     let mediaStream = null;
     let recordingChunks = [];
+    let audioContext = null;
+    let audioInput = null;
+    let audioProcessor = null;
+    let pcmChunks = [];
+    let voiceRecording = false;
     let pendingTtsReferenceAudio = '';
     function setState(text, cls = '') {{
       statePill.textContent = text;
@@ -709,27 +714,91 @@ def render_web_chat_page(
       prompt.focus();
       setState('transcribed', 'ok');
     }}
+    function encodePcmWav(chunks, sampleRate) {{
+      const sampleCount = chunks.reduce((total, chunk) => total + chunk.length, 0);
+      const buffer = new ArrayBuffer(44 + sampleCount * 2);
+      const view = new DataView(buffer);
+      const writeAscii = (offset, value) => {{
+        for (let index = 0; index < value.length; index += 1) view.setUint8(offset + index, value.charCodeAt(index));
+      }};
+      writeAscii(0, 'RIFF');
+      view.setUint32(4, 36 + sampleCount * 2, true);
+      writeAscii(8, 'WAVE');
+      writeAscii(12, 'fmt ');
+      view.setUint32(16, 16, true);
+      view.setUint16(20, 1, true);
+      view.setUint16(22, 1, true);
+      view.setUint32(24, sampleRate, true);
+      view.setUint32(28, sampleRate * 2, true);
+      view.setUint16(32, 2, true);
+      view.setUint16(34, 16, true);
+      writeAscii(36, 'data');
+      view.setUint32(40, sampleCount * 2, true);
+      let offset = 44;
+      chunks.forEach(chunk => chunk.forEach(rawSample => {{
+        const sample = Math.max(-1, Math.min(1, rawSample));
+        view.setInt16(offset, sample < 0 ? sample * 0x8000 : sample * 0x7fff, true);
+        offset += 2;
+      }}));
+      return new Blob([buffer], {{type: 'audio/wav'}});
+    }}
+    async function finishVoiceInput(blob) {{
+      if (mediaStream) mediaStream.getTracks().forEach(track => track.stop());
+      mediaStream = null;
+      micButton.textContent = 'Start voice input';
+      micButton.classList.remove('recording');
+      try {{ await transcribeRecording(blob); }} catch (err) {{ setState('STT error', 'error'); addBubble('system', 'STT failed: ' + String(err && err.message ? err.message : err)); }}
+    }}
     async function startVoiceInput() {{
-      if (!navigator.mediaDevices || !window.MediaRecorder) throw new Error('This browser does not support microphone recording');
+      if (!navigator.mediaDevices) throw new Error('This browser does not support microphone recording');
       mediaStream = await navigator.mediaDevices.getUserMedia({{audio: true}});
-      recordingChunks = [];
-      mediaRecorder = new MediaRecorder(mediaStream);
-      mediaRecorder.addEventListener('dataavailable', event => {{ if (event.data && event.data.size) recordingChunks.push(event.data); }});
-      mediaRecorder.addEventListener('stop', async () => {{
-        const blob = new Blob(recordingChunks, {{type: mediaRecorder.mimeType || 'audio/webm'}});
-        if (mediaStream) mediaStream.getTracks().forEach(track => track.stop());
+      const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+      if (AudioContextClass) {{
+        audioContext = new AudioContextClass();
+        if (audioContext.state === 'suspended') await audioContext.resume();
+        audioInput = audioContext.createMediaStreamSource(mediaStream);
+        audioProcessor = audioContext.createScriptProcessor(4096, 1, 1);
+        pcmChunks = [];
+        audioProcessor.onaudioprocess = event => pcmChunks.push(new Float32Array(event.inputBuffer.getChannelData(0)));
+        audioInput.connect(audioProcessor);
+        audioProcessor.connect(audioContext.destination);
+      }} else if (window.MediaRecorder) {{
+        recordingChunks = [];
+        mediaRecorder = new MediaRecorder(mediaStream);
+        mediaRecorder.addEventListener('dataavailable', event => {{ if (event.data && event.data.size) recordingChunks.push(event.data); }});
+        mediaRecorder.addEventListener('stop', async () => {{
+          const blob = new Blob(recordingChunks, {{type: mediaRecorder.mimeType || 'audio/webm'}});
+          await finishVoiceInput(blob);
+        }}, {{once: true}});
+        mediaRecorder.start();
+      }} else {{
+        mediaStream.getTracks().forEach(track => track.stop());
         mediaStream = null;
-        micButton.textContent = 'Start voice input';
-        micButton.classList.remove('recording');
-        try {{ await transcribeRecording(blob); }} catch (err) {{ setState('STT error', 'error'); addBubble('system', 'STT failed: ' + String(err && err.message ? err.message : err)); }}
-      }}, {{once: true}});
-      mediaRecorder.start();
+        throw new Error('This browser does not support microphone recording');
+      }}
+      voiceRecording = true;
       micButton.textContent = 'Stop and transcribe';
       micButton.classList.add('recording');
       setState('recording', 'error');
     }}
-    function stopVoiceInput() {{
-      if (mediaRecorder && mediaRecorder.state !== 'inactive') mediaRecorder.stop();
+    async function stopVoiceInput() {{
+      if (!voiceRecording) return;
+      voiceRecording = false;
+      if (audioProcessor && audioContext) {{
+        const sampleRate = audioContext.sampleRate;
+        audioProcessor.onaudioprocess = null;
+        audioInput.disconnect();
+        audioProcessor.disconnect();
+        await audioContext.close();
+        const blob = encodePcmWav(pcmChunks, sampleRate);
+        audioContext = null;
+        audioInput = null;
+        audioProcessor = null;
+        pcmChunks = [];
+        await finishVoiceInput(blob);
+      }} else if (mediaRecorder && mediaRecorder.state !== 'inactive') {{
+        mediaRecorder.stop();
+      }}
     }}
     async function uploadAttachment(file) {{
       const content = await fileToBase64(file);
@@ -924,8 +993,8 @@ def render_web_chat_page(
     }});
     attachButton.addEventListener('click', () => fileInput.click());
     micButton.addEventListener('click', async () => {{
-      if (mediaRecorder && mediaRecorder.state !== 'inactive') {{
-        stopVoiceInput();
+      if (voiceRecording) {{
+        await stopVoiceInput();
         return;
       }}
       try {{ await startVoiceInput(); }} catch (err) {{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oneciel-ai/ciel-runtime",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Universal AI coding-agent runtime and model-routing layer for Claude, Codex, AGY, and compatible runtimes.",
   "license": "MIT",
   "author": "One Ciel LLC",