@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/launch_diagnostics.py

@@ -0,0 +1,204 @@
+"""Launch command observability and subprocess stderr capture adapters."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import threading
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import BinaryIO, Callable
+
+
+Log = Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class LaunchCommandDiagnostics:
+    log: Log
+    mask_secret: Callable[[str], str]
+    codex_api_key_env: str
+
+    def agy(self, command: list[str], environment: dict[str, str]) -> None:
+        routed = "yes" if "--dangerously-skip-permissions" in command else "no"
+        self.log("INFO", f"agy_launch_cmd argv_len={len(command)} routed_flags={routed}")
+        summary = [
+            f"{key}={environment[key]}"
+            for key in ("CIEL_RUNTIME_PROVIDER", "CIEL_RUNTIME_MODEL_ALIAS")
+            if key in environment
+        ]
+        if summary:
+            self.log("INFO", "agy_launch_env " + " ".join(summary))
+
+    def claude(self, command: list[str], environment: dict[str, str]) -> None:
+        try:
+            mcp_index = command.index("--mcp-config") if "--mcp-config" in command else -1
+            mcp_value = command[mcp_index + 1] if 0 <= mcp_index < len(command) - 1 else "-"
+        except Exception:
+            mcp_value = "-"
+        channel_specs: list[str] = []
+        if "--dangerously-load-development-channels" in command:
+            start = command.index("--dangerously-load-development-channels") + 1
+            for argument in command[start:]:
+                if argument.startswith("--"):
+                    break
+                channel_specs.append(argument)
+        self.log(
+            "INFO",
+            "claude_launch_cmd mcp_config=%s channels=%s argv_len=%d"
+            % (mcp_value, ",".join(channel_specs) or "-", len(command)),
+        )
+        keys = (
+            "ANTHROPIC_BASE_URL",
+            "ANTHROPIC_MODEL",
+            "ANTHROPIC_API_KEY",
+            "ANTHROPIC_AUTH_TOKEN",
+            "CIEL_RUNTIME_PROVIDER",
+            "CIEL_RUNTIME_MODEL_ALIAS",
+            "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
+            "CLAUDE_CODE_EFFORT_LEVEL",
+            "ANTHROPIC_CUSTOM_MODEL_OPTION_SUPPORTED_CAPABILITIES",
+            "ANTHROPIC_DEFAULT_HAIKU_MODEL_SUPPORTS",
+            "ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTS",
+            "ANTHROPIC_DEFAULT_SONNET_MODEL_SUPPORTS",
+        )
+        summary = self._environment_summary(environment, keys)
+        if summary:
+            self.log("INFO", "claude_launch_env " + " ".join(summary))
+
+    def codex(self, command: list[str], environment: dict[str, str]) -> None:
+        provider_args = [
+            argument
+            for argument in command
+            if argument.startswith("model_provider=") or argument.startswith("model_providers.")
+        ]
+        self.log(
+            "INFO",
+            f"codex_launch_cmd argv_len={len(command)} provider_overrides={len(provider_args)}",
+        )
+        summary = self._environment_summary(
+            environment,
+            ("CIEL_RUNTIME_PROVIDER", "CIEL_RUNTIME_MODEL_ALIAS", self.codex_api_key_env),
+        )
+        if summary:
+            self.log("INFO", "codex_launch_env " + " ".join(summary))
+
+    def codex_app_server(
+        self, command: list[str], environment: dict[str, str]
+    ) -> None:
+        provider_args = [
+            argument
+            for argument in command
+            if argument.startswith("model_provider=")
+            or argument.startswith("model_providers.")
+        ]
+        listen = ""
+        for index, argument in enumerate(command):
+            if argument == "--listen" and index + 1 < len(command):
+                listen = str(command[index + 1])
+                break
+            if argument.startswith("--listen="):
+                listen = argument.split("=", 1)[1]
+                break
+        self.log(
+            "INFO",
+            "codex_app_server_launch_cmd argv_len=%d provider_overrides=%d listen=%s"
+            % (len(command), len(provider_args), listen or "stdio/default"),
+        )
+        summary = self._environment_summary(
+            environment,
+            (
+                "CIEL_RUNTIME_PROVIDER",
+                "CIEL_RUNTIME_MODEL_ALIAS",
+                self.codex_api_key_env,
+            ),
+        )
+        if summary:
+            self.log("INFO", "codex_app_server_launch_env " + " ".join(summary))
+
+    def _environment_summary(
+        self,
+        environment: dict[str, str],
+        keys: tuple[str, ...],
+    ) -> list[str]:
+        summary: list[str] = []
+        for key in keys:
+            if key not in environment:
+                continue
+            value = environment[key]
+            if "KEY" in key or "TOKEN" in key:
+                value = self.mask_secret(value)
+            summary.append(f"{key}={value}")
+        return summary
+
+
+@dataclass(frozen=True, slots=True)
+class StderrCaptureAdapter:
+    config_dir: Path
+    stderr_log: Path
+    log: Log
+    rotation_bytes: int = 2_000_000
+
+    def call(self, command: list[str], environment: dict[str, str]) -> int:
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self._rotate()
+        try:
+            log_handle = self.stderr_log.open("ab", buffering=0)
+        except Exception as error:
+            self.log("WARN", f"claude_stderr_capture_open_failed error={type(error).__name__}: {error}")
+            return subprocess.call(command, env=environment)
+        self._write_header(log_handle)
+        try:
+            process = subprocess.Popen(command, env=environment, stderr=subprocess.PIPE)
+        except Exception as error:
+            self.log("WARN", f"claude_stderr_capture_spawn_failed error={type(error).__name__}: {error}")
+            self._close(log_handle)
+            return subprocess.call(command, env=environment)
+
+        def tee_stderr() -> None:
+            try:
+                if process.stderr is None:
+                    return
+                while chunk := process.stderr.read(4096):
+                    self._write_console(chunk)
+                    try:
+                        log_handle.write(chunk)
+                    except Exception as error:
+                        self.log("WARN", f"claude_stderr_log_tee_failed error={type(error).__name__}: {error}")
+            finally:
+                self._close(log_handle)
+
+        thread = threading.Thread(target=tee_stderr, daemon=True, name="claude-stderr-tee")
+        thread.start()
+        return_code = process.wait()
+        thread.join(timeout=2.0)
+        self.log("INFO", f"claude_exit code={return_code} stderr_log={self.stderr_log}")
+        return return_code
+
+    def _rotate(self) -> None:
+        try:
+            if self.stderr_log.exists() and self.stderr_log.stat().st_size > self.rotation_bytes:
+                self.stderr_log.replace(self.stderr_log.with_suffix(".log.1"))
+        except Exception as error:
+            self.log("WARN", f"claude_stderr_capture_rotate_failed error={type(error).__name__}: {error}")
+
+    def _write_header(self, log_handle: BinaryIO) -> None:
+        header = f"\n===== claude launch at {time.strftime('%Y-%m-%dT%H:%M:%S')} =====\n".encode()
+        try:
+            log_handle.write(header)
+        except Exception as error:
+            self.log("WARN", f"claude_stderr_capture_header_failed error={type(error).__name__}: {error}")
+
+    def _write_console(self, chunk: bytes) -> None:
+        try:
+            sys.stderr.buffer.write(chunk)
+            sys.stderr.buffer.flush()
+        except Exception as error:
+            self.log("WARN", f"claude_stderr_console_tee_failed error={type(error).__name__}: {error}")
+
+    def _close(self, log_handle: BinaryIO) -> None:
+        try:
+            log_handle.close()
+        except Exception as error:
+            self.log("WARN", f"claude_stderr_capture_close_failed error={type(error).__name__}: {error}")

package/ciel_runtime_support/launch_state.py

@@ -0,0 +1,127 @@
+"""Runtime launch history repository and session-switch policy."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class LaunchStateRepository:
+    path: Path
+    config_dir: Path
+    log: Callable[[str, str], None]
+    process_id: Callable[[], int]
+    clock: Callable[[], float]
+    clock_ns: Callable[[], int]
+
+    def read(self) -> dict[str, Any]:
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+        except Exception:
+            return {}
+        return data if isinstance(data, dict) else {}
+
+    def write(self, state: dict[str, Any]) -> None:
+        try:
+            self.config_dir.mkdir(parents=True, exist_ok=True)
+            tmp = self.path.with_name(
+                f"{self.path.name}.{self.process_id()}.{self.clock_ns()}.tmp"
+            )
+            tmp.write_text(json.dumps(state, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+            tmp.chmod(0o600)
+            tmp.replace(self.path)
+        except Exception as exc:
+            self.log("WARN", f"launch_state_write_failed error={type(exc).__name__}: {exc}")
+
+    def previous_for_cwd(self, cwd_key: str) -> dict[str, Any]:
+        state = self.read()
+        by_cwd = state.get("by_cwd")
+        if isinstance(by_cwd, dict) and isinstance(item := by_cwd.get(cwd_key), dict):
+            return item
+        legacy = state.get("last")
+        if isinstance(legacy, dict) and str(legacy.get("cwd") or "") == cwd_key:
+            return legacy
+        return {}
+
+    def record(self, cwd_key: str, provider: str, mode: str, model: str) -> None:
+        state = self.read()
+        by_cwd = state.get("by_cwd")
+        if not isinstance(by_cwd, dict):
+            by_cwd = {}
+        item = {
+            "cwd": cwd_key,
+            "provider": provider,
+            "mode": mode,
+            "model": model,
+            "pid": self.process_id(),
+            "time": self.clock(),
+        }
+        by_cwd[cwd_key] = item
+        state["by_cwd"] = by_cwd
+        state["last"] = item
+        self.write(state)
+
+
+def current_launch_cwd_key() -> str:
+    try:
+        return str(Path.cwd().resolve())
+    except Exception:
+        return str(Path.cwd())
+
+
+def launch_mode_name(
+    provider: str,
+    *,
+    use_native_anthropic: bool,
+    anthropic_routed: bool,
+) -> str:
+    if use_native_anthropic:
+        return "anthropic-native"
+    if anthropic_routed:
+        return "anthropic-routed"
+    return f"router:{provider}"
+
+
+def last_launch_runtime(repository: LaunchStateRepository, cwd_key: str) -> str:
+    state = repository.read()
+    item = repository.previous_for_cwd(cwd_key)
+    if not item:
+        candidate = state.get("last")
+        item = candidate if isinstance(candidate, dict) else {}
+    mode = str(item.get("mode") or "").strip().lower()
+    if mode.startswith("codex"):
+        return "codex"
+    if mode.startswith("agy"):
+        return "agy"
+    if mode.startswith("anthropic") or mode.startswith("router:"):
+        return "claude"
+    return ""
+
+
+def session_control_requested(passthrough: list[str]) -> bool:
+    names = ("-c", "--continue", "-r", "--resume", "--session-id", "--fork-session", "--from-pr")
+    return any(
+        argument in names or any(argument.startswith(name + "=") for name in names)
+        for argument in passthrough
+    )
+
+
+def should_fork_native_session(
+    *,
+    current_mode: str,
+    passthrough: list[str],
+    cwd_key: str,
+    use_native_anthropic: bool,
+    repository: LaunchStateRepository,
+) -> tuple[bool, str]:
+    if not use_native_anthropic:
+        return False, ""
+    if session_control_requested(passthrough):
+        return False, "explicit_session_control"
+    previous_mode = str(repository.previous_for_cwd(cwd_key).get("mode") or "")
+    if not previous_mode or previous_mode == current_mode:
+        return False, previous_mode or "no_previous_mode"
+    return True, previous_mode

package/ciel_runtime_support/live_api_key_controller.py

@@ -0,0 +1,58 @@
+"""Live API-key status and mutation command controller."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class LiveApiKeyPorts:
+    load_config: Callable[[], dict[str, Any]]
+    current_provider: Callable[[dict[str, Any]], tuple[str, dict[str, Any]]]
+    status_line: Callable[[str, dict[str, Any]], str]
+    stored_mask: Callable[[str, dict[str, Any]], str]
+    store_input: Callable[[str, str], list[str]]
+
+
+class LiveApiKeyController:
+    def __init__(self, ports: LiveApiKeyPorts) -> None:
+        self.ports = ports
+
+    def status(self, provider: str, provider_config: dict[str, Any]) -> list[str]:
+        return [
+            f"Live API key status for provider: {provider}",
+            self.ports.status_line(provider, provider_config),
+            f"Stored: {self.ports.stored_mask(provider, provider_config)}",
+        ]
+
+    def handle(self, value: str) -> tuple[list[str], bool]:
+        config = self.ports.load_config()
+        provider, provider_config = self.ports.current_provider(config)
+        raw = str(value or "").strip()
+        normalized = raw.lower()
+        if normalized in {"", "status", "state", "show", "current", "now"}:
+            return self.status(provider, provider_config), False
+        if normalized in {"help", "usage", "list"}:
+            return [
+                "Use `/api-key status` to show masked key status.",
+                "Use `/api-key clear` or `/api-key unset` to remove API keys for only the current provider.",
+                "Use `/api-key KEY` to set one key.",
+                "Use `/api-key KEY1,KEY2` or `/api-keys KEY1;KEY2` to set multiple round-robin keys.",
+                "Raw keys are never echoed; responses show only masked keys and fingerprints.",
+            ], False
+        try:
+            lines = self.ports.store_input(provider, raw)
+        except SystemExit as exc:
+            message = str(exc).strip() or "No API keys provided; unchanged."
+            return [message, "", *self.status(provider, provider_config)], False
+        config_after = self.ports.load_config()
+        provider_after, provider_config_after = self.ports.current_provider(
+            config_after
+        )
+        return lines + [
+            "",
+            "Updated live API key settings. The next model request uses these settings.",
+            *self.status(provider_after, provider_config_after),
+        ], True

package/ciel_runtime_support/llm_config_http.py

@@ -0,0 +1,148 @@
+"""HTTP controller and presentation projection for LLM configuration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class LlmConfigIdentity:
+    load_config: Callable[..., dict[str, Any]]
+    current_provider: Callable[..., tuple[str, dict[str, Any]]]
+    current_alias: Callable[..., str]
+    applied_preset: Callable[..., str]
+    context_status: Callable[..., str]
+    timeout_status: Callable[..., str]
+    provider_labels: dict[str, str]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmConfigPanels:
+    option_rows: Callable[..., tuple[list[str], list[str]]]
+    option_default: Callable[..., str]
+    preset_rows: Callable[..., tuple[list[str], list[str]]]
+    context_rows: Callable[..., tuple[list[str], list[str]]]
+    timeout_rows: Callable[..., tuple[list[str], list[str]]]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmConfigMutations:
+    set_model: Callable[..., list[str]]
+    set_advisor_model: Callable[..., list[str]]
+    apply_preset: Callable[..., list[str]]
+    apply_context: Callable[..., list[str]]
+    apply_timeout: Callable[..., list[str]]
+    set_option: Callable[..., list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmConfigHttpIO:
+    publish_event: Callable[..., Any]
+    write_json: Callable[..., Any]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmConfigHttpController:
+    identity: LlmConfigIdentity
+    panels: LlmConfigPanels
+    mutations: LlmConfigMutations
+    io: LlmConfigHttpIO
+
+    PATH = "/ca/config/llm"
+
+    def payload(self, messages: list[str] | None = None) -> dict[str, Any]:
+        cfg = self.identity.load_config()
+        provider, provider_config = self.identity.current_provider(cfg)
+        language = cfg.get("language", "en")
+        rows, values = self.panels.option_rows(provider, provider_config, language)
+        preset_rows, preset_values = self.panels.preset_rows(provider, provider_config, language)
+        context_rows, context_values = self.panels.context_rows(provider, provider_config, language)
+        timeout_rows, timeout_values = self.panels.timeout_rows(provider_config, language)
+        return {
+            "ok": True,
+            "messages": messages or [],
+            "provider": provider,
+            "provider_label": self.identity.provider_labels.get(provider, provider),
+            "model": str(provider_config.get("current_model") or ""),
+            "alias": self.identity.current_alias(cfg),
+            "advisor_model": str(provider_config.get("advisor_model") or ""),
+            "preset": self.identity.applied_preset(provider, provider_config),
+            "context": self.identity.context_status(provider, provider_config),
+            "timeout": self.identity.timeout_status(provider_config, language),
+            "options": [
+                {"label": row, "key": key, "value": self.panels.option_default(provider, provider_config, key)}
+                for row, key in zip(rows, values)
+                if key not in ("back", "__info__", "preset", "context_setup", "timeout_profile")
+            ],
+            "presets": self._selection_rows(preset_rows, preset_values),
+            "contexts": self._selection_rows(context_rows, context_values),
+            "timeouts": self._selection_rows(timeout_rows, timeout_values),
+        }
+
+    @staticmethod
+    def _selection_rows(rows: list[str], values: list[str]) -> list[dict[str, str]]:
+        return [
+            {"label": row, "value": value}
+            for row, value in zip(rows, values)
+            if value not in ("back", "__info__")
+        ]
+
+    def handle_get(self, handler: Any, path: str) -> bool:
+        if path != self.PATH:
+            return False
+        self.io.write_json(handler, self.payload())
+        return True
+
+    def handle_post(self, handler: Any, path: str, body: dict[str, Any]) -> bool:
+        if path != self.PATH:
+            return False
+        cfg = self.identity.load_config()
+        provider, _provider_config = self.identity.current_provider(cfg)
+        action = str(body.get("action") or "option").strip()
+        value = str(body.get("value") or "").strip()
+        key = str(body.get("key") or "").strip()
+        try:
+            messages = self._mutate(action, provider, key, value)
+            self.io.publish_event(
+                level="info",
+                category="config.llm",
+                message=f"updated {action} {key or value}",
+                provider=provider,
+                data={"action": action, "key": key, "value": value},
+            )
+            self.io.write_json(handler, self.payload(messages))
+        except SystemExit as exc:
+            self.io.write_json(handler, {"ok": False, "error": str(exc), "messages": [str(exc)]}, 400)
+        except Exception as exc:
+            error = f"{type(exc).__name__}: {exc}"
+            self.io.log("ERROR", f"llm config update failed: {error}")
+            self.io.write_json(handler, {"ok": False, "error": error, "messages": [error]}, 500)
+        return True
+
+    def _mutate(self, action: str, provider: str, key: str, value: str) -> list[str]:
+        if action == "model":
+            return self.mutations.set_model(value)
+        if action == "advisor_model":
+            return self.mutations.set_advisor_model(value)
+        if action == "preset":
+            return self.mutations.apply_preset(provider, value)
+        if action == "context_setup":
+            return self.mutations.apply_context(provider, value)
+        if action == "timeout_profile":
+            return self.mutations.apply_timeout(provider, value)
+        if action == "option":
+            if not key:
+                raise SystemExit("Missing option key")
+            return self.mutations.set_option(provider, key, value)
+        raise SystemExit(f"Unknown LLM config action: {action}")
+
+
+__all__ = [
+    "LlmConfigHttpController",
+    "LlmConfigHttpIO",
+    "LlmConfigIdentity",
+    "LlmConfigMutations",
+    "LlmConfigPanels",
+]