@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/codex_process_lifecycle.py

@@ -0,0 +1,271 @@
+"""Codex child-process records, discovery, and shutdown lifecycle."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class CodexProcessPorts:
+    pid_running: Callable[[int], bool]
+    command_line: Callable[[int], str]
+    managed_process: Callable[[int, str | None], bool]
+    terminate_tree: Callable[[int, str, bool], bool]
+    process_rows: Callable[[], list[tuple[int, str, str]]]
+    process_cwd: Callable[[int], Path | None]
+    parent_info: Callable[[int], tuple[int, str] | None]
+    log: Callable[[str, str], None]
+    current_pid: Callable[[], int]
+    parent_pid: Callable[[], int]
+
+
+class CodexProcessRepository:
+    def __init__(self, process_dir: Path, log: Callable[[str, str], None]) -> None:
+        self.process_dir = process_dir
+        self.log = log
+
+    def write(
+        self,
+        path: Path | None,
+        pid: int,
+        command: list[str],
+        cwd: Path | None = None,
+    ) -> None:
+        if path is None or pid <= 0:
+            return
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            payload = {
+                "pid": int(pid),
+                "owner_pid": os.getpid(),
+                "started_at": time.strftime("%Y-%m-%dT%H:%M:%S"),
+                "cwd": str(cwd or Path.cwd()),
+                "cmd": [str(item) for item in command],
+            }
+            path.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+            try:
+                os.chmod(path, 0o600)
+            except Exception as exc:
+                self.log(
+                    "WARN",
+                    "codex_child_process_record_chmod_failed "
+                    f"path={path} error={type(exc).__name__}: {exc}",
+                )
+            self.log("INFO", f"codex_child_process_registered pid={pid} path={path}")
+        except Exception as exc:
+            self.log(
+                "WARN",
+                f"codex_child_process_register_failed pid={pid} "
+                f"error={type(exc).__name__}: {exc}",
+            )
+
+    def release(self, path: Path | None, pid: int | None = None) -> None:
+        if path is None:
+            return
+        try:
+            if pid is not None and path.exists():
+                data = json.loads(path.read_text(encoding="utf-8"))
+                if int(data.get("pid") or 0) != int(pid):
+                    return
+            path.unlink()
+            self.log("INFO", f"codex_child_process_released path={path}")
+        except FileNotFoundError:
+            return
+        except Exception as exc:
+            self.log(
+                "WARN",
+                f"codex_child_process_release_failed path={path} "
+                f"error={type(exc).__name__}: {exc}",
+            )
+
+    def records(self) -> list[tuple[Path, int]]:
+        if not self.process_dir.exists():
+            return []
+        records: list[tuple[Path, int]] = []
+        for path in sorted(self.process_dir.glob("*.json")):
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+                records.append((path, int(data.get("pid") or 0)))
+            except (
+                OSError,
+                UnicodeError,
+                json.JSONDecodeError,
+                AttributeError,
+                TypeError,
+                ValueError,
+            ) as exc:
+                self.log(
+                    "WARN",
+                    f"codex_tracked_process_record_invalid path={path} "
+                    f"error={type(exc).__name__}: {exc}",
+                )
+                try:
+                    path.unlink()
+                except FileNotFoundError:
+                    pass
+                except OSError as unlink_exc:
+                    self.log(
+                        "WARN",
+                        f"codex_tracked_process_record_cleanup_failed path={path} "
+                        f"error={type(unlink_exc).__name__}: {unlink_exc}",
+                    )
+        return records
+
+
+def managed_process(
+    pid: int,
+    command: str | None,
+    *,
+    managed_environment: Callable[[int, str, str | None], bool],
+    command_line: Callable[[int], str],
+) -> bool:
+    if managed_environment(pid, "CIEL_RUNTIME_CODEX_MANAGED", "1"):
+        return True
+    text = (command if command is not None else command_line(pid)).lower()
+    return "codex" in text and ("--yolo" in text or "app-server" in text)
+
+
+def terminate_recorded_child(
+    process: Any,
+    label: str,
+    *,
+    terminate_tree: Callable[[int, str, bool], bool],
+    log: Callable[[str, str], None],
+) -> None:
+    try:
+        pid = int(getattr(process, "pid", 0) or 0)
+    except (TypeError, ValueError) as exc:
+        log("WARN", f"codex_child_process_pid_invalid error={type(exc).__name__}: {exc}")
+        return
+    if pid <= 0:
+        return
+    try:
+        if process.poll() is not None:
+            return
+    except Exception as exc:
+        log(
+            "WARN",
+            f"codex_child_process_poll_failed pid={pid} error={type(exc).__name__}: {exc}",
+        )
+    terminate_tree(pid, label, True)
+    try:
+        process.wait(timeout=2)
+    except Exception as wait_exc:
+        log(
+            "WARN",
+            f"codex_child_process_wait_failed pid={pid} "
+            f"error={type(wait_exc).__name__}: {wait_exc}",
+        )
+        try:
+            process.kill()
+        except Exception as kill_exc:
+            log(
+                "WARN",
+                f"codex_child_process_kill_failed pid={pid} "
+                f"error={type(kill_exc).__name__}: {kill_exc}",
+            )
+        try:
+            process.wait(timeout=2)
+        except Exception as final_wait_exc:
+            log(
+                "WARN",
+                f"codex_child_process_final_wait_failed pid={pid} "
+                f"error={type(final_wait_exc).__name__}: {final_wait_exc}",
+            )
+
+
+class CodexProcessLifecycle:
+    def __init__(self, repository: CodexProcessRepository, ports: CodexProcessPorts) -> None:
+        self.repository = repository
+        self.ports = ports
+
+    def terminate_tracked(self, reason: str, quiet: bool = True) -> bool:
+        stopped = False
+        for path, pid in self.repository.records():
+            if pid <= 0 or not self.ports.pid_running(pid):
+                self.repository.release(path, pid)
+                continue
+            command = self.ports.command_line(pid)
+            if not self.ports.managed_process(pid, command):
+                self.ports.log(
+                    "WARN",
+                    f"codex_tracked_process_skipped_unexpected_command pid={pid} path={path}",
+                )
+                self.repository.release(path, pid)
+                continue
+            stopped = self.ports.terminate_tree(pid, "previous Codex", quiet) or stopped
+            self.repository.release(path, pid)
+        self.ports.log(
+            "INFO",
+            f"codex_tracked_processes_terminated reason={reason} "
+            f"stopped={str(stopped).lower()}",
+        )
+        return stopped
+
+    def ancestor_pids(self, platform_name: str, limit: int = 12) -> set[int]:
+        ancestors = {self.ports.current_pid(), self.ports.parent_pid()}
+        if platform_name == "nt":
+            return ancestors
+        current = self.ports.current_pid()
+        for _ in range(max(0, limit)):
+            info = self.ports.parent_info(current)
+            if info is None:
+                break
+            parent, _command = info
+            if parent <= 0 or parent in ancestors:
+                break
+            ancestors.add(parent)
+            current = parent
+        return ancestors
+
+    def untracked_pids(
+        self,
+        cwd: Path | None,
+        *,
+        platform_name: str,
+        enabled: bool,
+    ) -> list[int]:
+        if platform_name == "nt" or not enabled:
+            return []
+        target_cwd = (cwd or Path.cwd()).resolve()
+        protected = self.ancestor_pids(platform_name)
+        matches = [
+            pid
+            for pid, stat, command in self.ports.process_rows()
+            if pid not in protected
+            and not stat.startswith("Z")
+            and self.ports.managed_process(pid, command)
+            and self.ports.process_cwd(pid) == target_cwd
+        ]
+        return sorted(set(matches))
+
+    def terminate_untracked(
+        self,
+        reason: str,
+        cwd: Path | None,
+        quiet: bool,
+        *,
+        platform_name: str,
+        enabled: bool,
+    ) -> bool:
+        pids = self.untracked_pids(cwd, platform_name=platform_name, enabled=enabled)
+        if not pids:
+            return False
+        stopped = False
+        for pid in pids:
+            stopped = (
+                self.ports.terminate_tree(pid, "previous untracked Codex", quiet)
+                or stopped
+            )
+        self.ports.log(
+            "WARN",
+            f"codex_untracked_processes_terminated reason={reason} "
+            f"pids={','.join(map(str, pids))} stopped={str(stopped).lower()}",
+        )
+        return stopped

package/ciel_runtime_support/codex_router.py

@@ -2,11 +2,149 @@
 
 from __future__ import annotations
 
+import json
+from dataclasses import dataclass
 from typing import Any, Callable
 
 from .agent_router import COMMON_RUNTIME_ROUTER_CAPABILITIES, RouterCapability
 
 
+CODEX_CAPACITY_ERROR_CODES = frozenset({"server_is_overloaded", "slow_down"})
+CODEX_RESPONSE_PREAMBLE_LIMIT = 256 * 1024
+_CODEX_NON_OUTPUT_EVENT_TYPES = frozenset({"response.created", "response.in_progress"})
+
+
+@dataclass(frozen=True)
+class CodexResponsePreamble:
+    payload: bytes
+    capacity_error_code: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class CodexChannelContextPorts:
+    to_anthropic: Callable[[dict[str, Any], str], dict[str, Any]]
+    inject_pending: Callable[[dict[str, Any]], dict[str, Any]]
+    inject_tool_results: Callable[[dict[str, Any]], dict[str, Any]]
+    content_to_text: Callable[[Any], str]
+
+
+class CodexChannelContextProjector:
+    def __init__(self, ports: CodexChannelContextPorts) -> None:
+        self._ports = ports
+
+    @staticmethod
+    def input_items(value: Any) -> list[dict[str, Any]]:
+        if isinstance(value, str):
+            return [{"type": "message", "role": "user", "content": [{"type": "input_text", "text": value}]}]
+        if isinstance(value, dict):
+            return [dict(value)]
+        if isinstance(value, list):
+            return [dict(item) for item in value if isinstance(item, dict)]
+        return []
+
+    @staticmethod
+    def message_item(role: str, text: str) -> dict[str, Any]:
+        role = role if role in {"user", "assistant", "system", "developer"} else "user"
+        text_type = "output_text" if role == "assistant" else "input_text"
+        return {"type": "message", "role": role, "content": [{"type": text_type, "text": text}]}
+
+    def project(self, body: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        delivery = self._ports.to_anthropic(body, str(body.get("model") or ""))
+        original_count = len(delivery.get("messages") or [])
+        delivery = self._ports.inject_pending(delivery)
+        delivery = self._ports.inject_tool_results(delivery)
+        messages = [message for message in delivery.get("messages") or [] if isinstance(message, dict)]
+        additions = messages[original_count:]
+        metadata = delivery.get("metadata") if isinstance(delivery.get("metadata"), dict) else {}
+        projected = dict(body)
+        projected.pop("metadata", None)
+        if not additions and not metadata:
+            return projected, delivery
+        input_items = self.input_items(body.get("input", []))
+        for message in additions:
+            text = self._ports.content_to_text(message.get("content"))
+            if text.strip():
+                input_items.append(self.message_item(str(message.get("role") or "user"), text))
+        if input_items:
+            projected["input"] = input_items
+        return projected, delivery
+
+
+def _codex_sse_event(block: bytes) -> dict[str, Any] | None:
+    text = block.decode("utf-8", errors="replace").strip()
+    if not text:
+        return None
+    data_lines = []
+    for line in text.splitlines():
+        if line.startswith("data:"):
+            data_lines.append(line[5:].lstrip())
+    candidate = "\n".join(data_lines).strip() if data_lines else text
+    try:
+        value = json.loads(candidate)
+    except (TypeError, ValueError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def _codex_capacity_error_code(event: dict[str, Any]) -> str | None:
+    if event.get("type") != "response.failed":
+        return None
+    response = event.get("response")
+    if not isinstance(response, dict):
+        return None
+    error = response.get("error")
+    if not isinstance(error, dict):
+        return None
+    code = str(error.get("code") or "").strip()
+    return code if code in CODEX_CAPACITY_ERROR_CODES else None
+
+
+def read_codex_response_preamble(
+    stream: Any,
+    *,
+    max_bytes: int = CODEX_RESPONSE_PREAMBLE_LIMIT,
+) -> CodexResponsePreamble:
+    """Read control-only SSE events until output starts or a safe retry is known."""
+    buffered = bytearray()
+    while len(buffered) < max_bytes:
+        block = bytearray()
+        reached_eof = False
+        while len(buffered) + len(block) < max_bytes:
+            remaining = max_bytes - len(buffered) - len(block)
+            line = stream.readline(remaining + 1)
+            if not line:
+                reached_eof = True
+                break
+            block.extend(line)
+            if line in (b"\n", b"\r\n"):
+                break
+            if len(block) > remaining:
+                break
+        if not block:
+            return CodexResponsePreamble(bytes(buffered))
+        buffered.extend(block)
+        if len(buffered) >= max_bytes:
+            return CodexResponsePreamble(bytes(buffered))
+
+        event = _codex_sse_event(bytes(block))
+        if event is None:
+            # SSE comments and keepalives carry no model output.
+            meaningful = [line for line in block.splitlines() if line and not line.startswith(b":")]
+            if not meaningful and not reached_eof:
+                continue
+            return CodexResponsePreamble(bytes(buffered))
+
+        capacity_code = _codex_capacity_error_code(event)
+        if capacity_code:
+            return CodexResponsePreamble(bytes(buffered), capacity_code)
+        if event.get("type") not in _CODEX_NON_OUTPUT_EVENT_TYPES:
+            return CodexResponsePreamble(bytes(buffered))
+        if reached_eof:
+            return CodexResponsePreamble(bytes(buffered))
+
+    return CodexResponsePreamble(bytes(buffered))
+
+
 class CodexRouter:
     name = "codex"
     runtime = "codex"
@@ -21,6 +159,7 @@ class CodexRouter:
             ("pending_delivery_ack", "Injected channel cursors are committed after successful delivery."),
             ("request_observability", "Responses requests are traced and published to the runtime event bus."),
             ("upstream_error_mapping", "Upstream HTTP and client disconnect errors are mapped for Codex."),
+            ("capacity_retry", "Capacity-only failures are retried before any output or tool call is delivered."),
             ("backend_passthrough", "Non-responses Codex backend endpoints are passed through."),
             ("legacy_responses", "The legacy /v1/responses path remains supported."),
         )
@@ -77,4 +216,11 @@ class CodexRouter:
 assert all(any(capability.name == required for capability in CodexRouter.capabilities) for required in COMMON_RUNTIME_ROUTER_CAPABILITIES)
 
 
-__all__ = ["CodexRouter"]
+__all__ = [
+    "CODEX_CAPACITY_ERROR_CODES",
+    "CodexChannelContextPorts",
+    "CodexChannelContextProjector",
+    "CodexResponsePreamble",
+    "CodexRouter",
+    "read_codex_response_preamble",
+]

package/ciel_runtime_support/codex_session_repository.py

@@ -0,0 +1,115 @@
+"""Read-only repository for the Codex local resume index."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import re
+import sqlite3
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from ciel_runtime_support.codex_config import (
+    codex_config_paths_for_launch,
+    toml_scalar_without_comment,
+    unquote_toml_string,
+)
+
+
+def codex_sqlite_home(
+    passthrough: list[str] | None = None,
+    env: dict[str, str] | None = None,
+    cwd: Path | None = None,
+) -> Path:
+    launch_env = env or os.environ
+    launch_cwd = (cwd or Path.cwd()).resolve()
+    configured: str | None = None
+    for path in codex_config_paths_for_launch(
+        passthrough or [], env=launch_env, cwd=launch_cwd
+    ):
+        try:
+            text = path.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        table = ""
+        for line in text.splitlines():
+            stripped = toml_scalar_without_comment(line)
+            if not stripped:
+                continue
+            table_match = re.fullmatch(r"\[(.+)\]", stripped)
+            if table_match:
+                table = table_match.group(1).strip()
+                continue
+            if table:
+                continue
+            match = re.match(r"sqlite_home\s*=\s*(.+)$", stripped)
+            if match:
+                configured = unquote_toml_string(match.group(1))
+    raw = configured or str(launch_env.get("CODEX_SQLITE_HOME") or "").strip()
+    if raw:
+        path = Path(os.path.expandvars(raw)).expanduser()
+        return path if path.is_absolute() else launch_cwd / path
+    return Path(launch_env.get("CODEX_HOME") or (Path.home() / ".codex")).expanduser()
+
+
+class CodexSessionRepository:
+    def __init__(self, database: Path, log: Callable[[str, str], None]) -> None:
+        self.database = database
+        self.log = log
+
+    def resumable(
+        self,
+        limit: int = 200,
+        *,
+        include_non_interactive: bool = False,
+        cwd: Path | None = None,
+    ) -> list[dict[str, Any]]:
+        if not self.database.is_file():
+            return []
+        sources = ["cli", "vscode"]
+        if include_non_interactive:
+            sources.extend(["exec", "app-server"])
+        placeholders = ", ".join("?" for _ in sources)
+        where = f"archived = 0 AND source IN ({placeholders})"
+        parameters: list[Any] = list(sources)
+        if cwd is not None:
+            normalized_cwd = str(cwd.resolve()).replace("\\", "/").rstrip("/")
+            slash_cwd = "REPLACE(cwd, CHAR(92), '/')"
+            portable_cwd = (
+                f"CASE WHEN {slash_cwd} LIKE '//?/UNC/%' "
+                f"THEN '//' || SUBSTR({slash_cwd}, 9) "
+                f"WHEN {slash_cwd} LIKE '//?/%' THEN SUBSTR({slash_cwd}, 5) "
+                f"ELSE {slash_cwd} END"
+            )
+            cwd_expression = f"RTRIM(({portable_cwd}), '/')"
+            if os.name == "nt":
+                cwd_expression = f"LOWER({cwd_expression})"
+                normalized_cwd = normalized_cwd.lower()
+            where += f" AND {cwd_expression} = ?"
+            parameters.append(normalized_cwd)
+        uri = self.database.resolve().as_uri() + "?mode=ro"
+        try:
+            with contextlib.closing(
+                sqlite3.connect(uri, uri=True, timeout=1.0)
+            ) as connection:
+                connection.row_factory = sqlite3.Row
+                rows = connection.execute(
+                    f"""
+                    SELECT id, title, first_user_message, cwd, model_provider,
+                           COALESCE(NULLIF(updated_at_ms, 0), updated_at * 1000) AS activity_ms
+                    FROM threads
+                    WHERE {where}
+                    ORDER BY COALESCE(NULLIF(recency_at_ms, 0),
+                                      NULLIF(updated_at_ms, 0), updated_at * 1000) DESC
+                    LIMIT ?
+                    """,
+                    (*parameters, max(1, min(1000, int(limit)))),
+                ).fetchall()
+        except (OSError, sqlite3.Error) as exc:
+            self.log(
+                "WARN",
+                f"codex_resume_index_read_failed error={type(exc).__name__}: {exc}",
+            )
+            return []
+        return [dict(row) for row in rows]

package/ciel_runtime_support/codex_session_selection.py

@@ -0,0 +1,114 @@
+"""Codex resume-session query, presentation, and selection workflow."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class CodexSessionRepositoryPorts:
+    sqlite_home: Callable[..., Path]
+    resumable: Callable[[Path, int, bool, Path | None], list[dict[str, Any]]]
+
+
+@dataclass(frozen=True, slots=True)
+class CodexSessionPresentationPorts:
+    select: Callable[..., int | None]
+    compact_text: Callable[[str, int], str]
+    output: Callable[[str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class CodexSessionSelectionService:
+    repository: CodexSessionRepositoryPorts
+    presentation: CodexSessionPresentationPorts
+
+    def sqlite_home_for_launch(
+        self,
+        passthrough: list[str] | None = None,
+        env: dict[str, str] | None = None,
+        cwd: Path | None = None,
+    ) -> Path:
+        return self.repository.sqlite_home(passthrough, env=env, cwd=cwd)
+
+    def local_resume_sessions(
+        self,
+        env: dict[str, str] | None = None,
+        limit: int = 200,
+        include_non_interactive: bool = False,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        session_cwd: Path | None = None,
+    ) -> list[dict[str, Any]]:
+        database = (
+            self.sqlite_home_for_launch(passthrough, env=env, cwd=cwd)
+            / "state_5.sqlite"
+        )
+        return self.repository.resumable(
+            database,
+            limit,
+            include_non_interactive,
+            session_cwd,
+        )
+
+    def resume_session_row(self, session: dict[str, Any]) -> str:
+        title = str(
+            session.get("title")
+            or session.get("first_user_message")
+            or "Untitled session"
+        ).strip()
+        title = re.sub(r"\s+", " ", title)
+        cwd = str(session.get("cwd") or "").strip()
+        folder = Path(cwd).name if cwd else "-"
+        provider = str(session.get("model_provider") or "-").strip()
+        try:
+            activity = datetime.fromtimestamp(
+                int(session.get("activity_ms") or 0) / 1000
+            ).strftime("%Y-%m-%d %H:%M")
+        except (OSError, OverflowError, TypeError, ValueError):
+            activity = "unknown time"
+        title = self.presentation.compact_text(title, 66)
+        return f"{title}  [{folder} | {provider} | {activity}]"
+
+    def select_resume_session(
+        self,
+        env: dict[str, str] | None = None,
+        include_non_interactive: bool = False,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+    ) -> str | None:
+        launch_cwd = (cwd or Path.cwd()).resolve()
+        show_all = "--all" in (passthrough or [])
+        sessions = self.local_resume_sessions(
+            env,
+            include_non_interactive=include_non_interactive,
+            passthrough=passthrough,
+            cwd=launch_cwd,
+            session_cwd=None if show_all else launch_cwd,
+        )
+        if not sessions:
+            database = (
+                self.sqlite_home_for_launch(
+                    passthrough, env=env, cwd=launch_cwd
+                ) / "state_5.sqlite"
+            )
+            scope = "" if show_all else f" for the current directory ({launch_cwd})"
+            hint = "" if show_all else " Use `codex resume --all` to show every session."
+            self.presentation.output(
+                f"Ciel Runtime could not find resumable Codex sessions{scope} in: "
+                f"{database}.{hint}"
+            )
+            return None
+        selected = self.presentation.select(
+            "Resume Codex session",
+            [self.resume_session_row(session) for session in sessions],
+            footer="Up/Down moves. Enter resumes. Esc/q cancels.",
+        )
+        if selected is None:
+            return ""
+        return str(sessions[selected].get("id") or "").strip()