@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/channel_runtime_environment.py

@@ -0,0 +1,181 @@
+"""Bounded environment configuration policy for Channel runtime behavior."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Mapping
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelRuntimeEnvironmentPolicy:
+    environment: Mapping[str, str]
+    launch_recent_default: float
+    probe_timeout_default: float
+
+    def launch_recent_seconds(self) -> float:
+        raw = str(
+            self.environment.get(
+                "CIEL_RUNTIME_CHANNEL_LAUNCH_RECENT_SECONDS",
+                "",
+            )
+            or ""
+        ).strip()
+        if not raw:
+            return self.launch_recent_default
+        return self._float(raw, self.launch_recent_default)
+
+    def probe_timeout_seconds(self) -> float:
+        raw = self.environment.get(
+            "CIEL_RUNTIME_CHANNEL_PROBE_TIMEOUT_SECONDS"
+        )
+        if raw is None:
+            return self.probe_timeout_default
+        value = self._float(str(raw).strip(), self.probe_timeout_default)
+        return value if value > 0 else self.probe_timeout_default
+
+    def pending_scan_limit(self) -> int:
+        return self._bounded_int(
+            self.environment.get(
+                "CIEL_RUNTIME_CHANNEL_PENDING_SCAN_LIMIT",
+                "500",
+            ),
+            default=500,
+            minimum=100,
+            maximum=5000,
+        )
+
+    def wake_batch_limit(self) -> int:
+        return self._bounded_int(
+            self.environment.get(
+                "CIEL_RUNTIME_CHANNEL_WAKE_BATCH_LIMIT",
+                "8",
+            ),
+            default=8,
+            minimum=1,
+            maximum=50,
+        )
+
+    def wake_claim_ttl_seconds(self) -> float:
+        return self._bounded_float(
+            self.environment.get(
+                "CIEL_RUNTIME_CHANNEL_WAKE_CLAIM_TTL_SECONDS"
+            ),
+            default=300.0,
+            minimum=5.0,
+            maximum=1800.0,
+        )
+
+    def unseen_retry_seconds(self) -> float:
+        return self._bounded_float(
+            self.environment.get(
+                "CIEL_RUNTIME_CHANNEL_WAKE_UNSEEN_RETRY_SECONDS"
+            ),
+            default=20.0,
+            minimum=2.0,
+            maximum=300.0,
+        )
+
+    def inflight_stale_seconds(self) -> float:
+        return self._bounded_float(
+            self.environment.get(
+                "CIEL_RUNTIME_CHANNEL_WAKE_INFLIGHT_STALE_SECONDS"
+            ),
+            default=180.0,
+            minimum=30.0,
+            maximum=1800.0,
+        )
+
+    def codex_submit_retries(self) -> int:
+        return self._bounded_int(
+            self.environment.get(
+                "CIEL_RUNTIME_CODEX_CHANNEL_WAKE_SUBMIT_RETRIES"
+            ),
+            default=4,
+            minimum=1,
+            maximum=8,
+        )
+
+    def codex_submit_delay_seconds(self) -> float:
+        return self._bounded_milliseconds(
+            self.environment.get(
+                "CIEL_RUNTIME_CODEX_CHANNEL_WAKE_SUBMIT_DELAY_MS"
+            ),
+            default=0.25,
+            minimum=0.13,
+            maximum=5.0,
+        )
+
+    def windows_startup_grace_seconds(self) -> float:
+        return self._bounded_milliseconds(
+            self.environment.get(
+                "CIEL_RUNTIME_WINDOWS_CHANNEL_STARTUP_GRACE_MS"
+            ),
+            default=8.0,
+            minimum=0.0,
+            maximum=60.0,
+        )
+
+    @staticmethod
+    def inflight_is_stale(
+        state: str,
+        started_at: float,
+        current_time: float,
+        stale_seconds: float,
+    ) -> bool:
+        return bool(
+            state in {"queued", "unknown"}
+            and started_at > 0
+            and current_time - started_at >= stale_seconds
+        )
+
+    @staticmethod
+    def _float(raw: str, default: float) -> float:
+        try:
+            return float(raw)
+        except (TypeError, ValueError):
+            return default
+
+    @classmethod
+    def _bounded_float(
+        cls,
+        raw: str | None,
+        *,
+        default: float,
+        minimum: float,
+        maximum: float,
+    ) -> float:
+        if raw is None:
+            return default
+        value = cls._float(raw, default)
+        return max(minimum, min(maximum, value))
+
+    @staticmethod
+    def _bounded_int(
+        raw: str | None,
+        *,
+        default: int,
+        minimum: int,
+        maximum: int,
+    ) -> int:
+        try:
+            value = int(str(raw).strip())
+        except (TypeError, ValueError):
+            return default
+        return max(minimum, min(maximum, value))
+
+    @classmethod
+    def _bounded_milliseconds(
+        cls,
+        raw: str | None,
+        *,
+        default: float,
+        minimum: float,
+        maximum: float,
+    ) -> float:
+        if raw is None:
+            return default
+        value = cls._float(raw, default * 1000.0) / 1000.0
+        return max(minimum, min(maximum, value))
+
+
+__all__ = ["ChannelRuntimeEnvironmentPolicy"]

package/ciel_runtime_support/channel_session_lifecycle.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class ChannelSessionLifecycleServices:
+    streamable_headers: Callable[..., dict[str, str]]
+    http_error_body: Callable[[urllib.error.HTTPError], str]
+    session_not_found: Callable[[urllib.error.HTTPError, str], bool]
+    records: Callable[[], list[dict[str, Any]]]
+    forget: Callable[[str, str, str | None], None]
+    log: Callable[[str, str], None]
+    urlopen: Callable[..., Any] = urllib.request.urlopen
+
+
+def delete_channel_session(
+    name: str,
+    endpoint: str,
+    headers: dict[str, str],
+    protocol_version: str,
+    session_id: str | None,
+    reason: str,
+    services: ChannelSessionLifecycleServices,
+    *,
+    default_protocol_version: str,
+    timeout: float = 5.0,
+) -> bool:
+    session = str(session_id or "").strip()
+    if not session or not endpoint:
+        return True
+    request_headers = services.streamable_headers(
+        headers,
+        protocol_version or default_protocol_version,
+        session,
+        accept="application/json, text/event-stream",
+    )
+    try:
+        request = urllib.request.Request(endpoint, headers=request_headers, method="DELETE")
+        with services.urlopen(request, timeout=max(1.0, min(30.0, timeout))) as response:
+            try:
+                response.read()
+            except (OSError, ValueError) as exc:
+                services.log(
+                    "WARN",
+                    f"channel_http_mcp_session_delete_body_read_failed name={name} session={session} "
+                    f"error={type(exc).__name__}: {exc}",
+                )
+        services.log(
+            "INFO",
+            f"channel_http_mcp_session_deleted name={name} session={session} reason={reason}",
+        )
+        services.forget(name, endpoint, session)
+        return True
+    except urllib.error.HTTPError as exc:
+        body_text = services.http_error_body(exc)
+        if exc.code in {404, 405} or services.session_not_found(exc, body_text):
+            services.log(
+                "INFO",
+                f"channel_http_mcp_session_delete_not_needed name={name} session={session} "
+                f"status={exc.code} reason={reason}",
+            )
+            services.forget(name, endpoint, session)
+            return True
+        services.log(
+            "WARN",
+            f"channel_http_mcp_session_delete_failed name={name} session={session} "
+            f"status={exc.code} reason={reason}",
+        )
+        return False
+    except Exception as exc:
+        services.log(
+            "WARN",
+            f"channel_http_mcp_session_delete_failed name={name} session={session} "
+            f"error={type(exc).__name__}: {exc} reason={reason}",
+        )
+        return False
+
+
+def cleanup_stale_channel_sessions(
+    name: str,
+    url: str,
+    headers: dict[str, str],
+    protocol_version: str,
+    services: ChannelSessionLifecycleServices,
+    *,
+    default_protocol_version: str,
+    keep_session_id: str | None = None,
+) -> None:
+    keep = str(keep_session_id or "").strip()
+    for record in services.records():
+        if str(record.get("url") or "") != str(url):
+            continue
+        session = str(record.get("session_id") or "").strip()
+        if not session or session == keep:
+            continue
+        record_protocol = str(
+            record.get("protocol_version")
+            or protocol_version
+            or default_protocol_version
+        )
+        delete_channel_session(
+            name,
+            url,
+            headers,
+            record_protocol,
+            session,
+            "stale_session_cleanup",
+            services,
+            default_protocol_version=default_protocol_version,
+        )

package/ciel_runtime_support/channel_session_repository.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class ChannelSessionRepository:
+    path: Path
+    default_protocol_version: str
+    log: Callable[[str, str], None]
+    process_id: Callable[[], int] = os.getpid
+    timestamp: Callable[[], str] = lambda: time.strftime("%Y-%m-%dT%H:%M:%S")
+    chmod: Callable[[Path, int], None] = os.chmod
+
+    def records(self) -> list[dict[str, Any]]:
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+        except FileNotFoundError:
+            return []
+        except Exception as exc:
+            self.log(
+                "WARN",
+                f"channel_http_session_record_read_failed error={type(exc).__name__}: {exc}",
+            )
+            return []
+        records = data.get("sessions") if isinstance(data, dict) else data
+        if not isinstance(records, list):
+            return []
+        return [item for item in records if isinstance(item, dict)]
+
+    def write(self, records: list[dict[str, Any]]) -> None:
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            payload = {"sessions": records[-100:]}
+            self.path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+            try:
+                self.chmod(self.path, 0o600)
+            except Exception as exc:
+                self.log(
+                    "WARN",
+                    f"channel_http_session_record_chmod_failed error={type(exc).__name__}: {exc}",
+                )
+        except Exception as exc:
+            self.log(
+                "WARN",
+                f"channel_http_session_record_write_failed error={type(exc).__name__}: {exc}",
+            )
+
+    def record(
+        self,
+        name: str,
+        url: str,
+        session_id: str | None,
+        protocol_version: str,
+    ) -> None:
+        session = str(session_id or "").strip()
+        if not session:
+            return
+        url_text = str(url)
+        records = [
+            item
+            for item in self.records()
+            if str(item.get("url") or "") != url_text
+            and str(item.get("session_id") or "") != session
+        ]
+        records.append(
+            {
+                "name": str(name),
+                "url": url_text,
+                "session_id": session,
+                "protocol_version": str(protocol_version or self.default_protocol_version),
+                "pid": self.process_id(),
+                "recorded_at": self.timestamp(),
+            }
+        )
+        self.write(records)
+
+    def forget(self, session_id: str | None) -> None:
+        session = str(session_id or "").strip()
+        if not session:
+            return
+        records = self.records()
+        kept = [item for item in records if str(item.get("session_id") or "") != session]
+        if len(kept) != len(records):
+            self.write(kept)

package/ciel_runtime_support/channel_terminal_dispatch.py

@@ -0,0 +1,115 @@
+"""Platform dispatch and direct-process lifecycle for channel terminals."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelTerminalDispatchSettings:
+    platform_name: str
+    stdin_isatty: Callable[[], bool]
+    stdout_isatty: Callable[[], bool]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelTerminalProxyPorts:
+    windows_supported: Callable[[], bool]
+    run_windows: Callable[..., int]
+    run_posix: Callable[..., int]
+    posix_services: Callable[[], Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelDirectProcessPorts:
+    call: Callable[..., int]
+    popen: Callable[..., Any]
+    write_record: Callable[[Path | None, int, list[str]], None]
+    terminate: Callable[[Any, str], None]
+    release_record: Callable[[Path | None, int], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelTerminalDispatchService:
+    settings: ChannelTerminalDispatchSettings
+    proxy: ChannelTerminalProxyPorts
+    direct: ChannelDirectProcessPorts
+    log: Callable[[str, str], None]
+
+    def dispatch(
+        self,
+        cmd: list[str],
+        env: dict[str, str],
+        *,
+        inject_channel_messages: bool = True,
+        inject_web_chat_only: bool = False,
+        wake_for_llm_delivery: bool = False,
+        synthetic_enter_bytes: str | bytes | None = None,
+        normalize_bare_cr_for_synthetic_enter: bool = True,
+        channel_wake_submit_retries: int = 1,
+        channel_wake_confirm_submit: bool = False,
+        channel_wake_bracketed_paste: bool = False,
+        channel_wake_submit_delay_seconds: float | None = None,
+        tracked_child_pid_path: Path | None = None,
+    ) -> int:
+        options = {
+            "inject_channel_messages": inject_channel_messages,
+            "inject_web_chat_only": inject_web_chat_only,
+            "wake_for_llm_delivery": wake_for_llm_delivery,
+            "synthetic_enter_bytes": synthetic_enter_bytes,
+            "normalize_bare_cr_for_synthetic_enter": (
+                normalize_bare_cr_for_synthetic_enter
+            ),
+            "channel_wake_submit_retries": channel_wake_submit_retries,
+            "channel_wake_confirm_submit": channel_wake_confirm_submit,
+            "channel_wake_bracketed_paste": channel_wake_bracketed_paste,
+            "channel_wake_submit_delay_seconds": (
+                channel_wake_submit_delay_seconds
+            ),
+            "tracked_child_pid_path": tracked_child_pid_path,
+        }
+        if self.settings.platform_name == "nt" and self.proxy.windows_supported():
+            try:
+                return self.proxy.run_windows(cmd, env, **options)
+            except Exception as exc:
+                self.log(
+                    "WARN",
+                    "channel_windows_console_proxy_failed "
+                    f"error={type(exc).__name__}: {exc}; "
+                    "using direct subprocess call",
+                )
+        if (
+            self.settings.platform_name != "posix"
+            or not self.settings.stdin_isatty()
+            or not self.settings.stdout_isatty()
+        ):
+            self.log(
+                "INFO",
+                "channel_stdin_proxy_unavailable; using direct subprocess call",
+            )
+            return self.call_direct(cmd, env, tracked_child_pid_path)
+        return self.proxy.run_posix(
+            cmd,
+            env,
+            self.proxy.posix_services(),
+            **options,
+        )
+
+    def call_direct(
+        self,
+        cmd: list[str],
+        env: dict[str, str],
+        pid_path: Path | None = None,
+    ) -> int:
+        if pid_path is None:
+            return self.direct.call(cmd, env=env)
+        proc = self.direct.popen(cmd, env=env)
+        self.direct.write_record(pid_path, proc.pid, cmd)
+        try:
+            return proc.wait()
+        finally:
+            self.direct.terminate(proc, "current Codex")
+            self.direct.release_record(pid_path, proc.pid)