@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/header_forwarding.py

@@ -0,0 +1,73 @@
+"""Transparent end-to-end request header forwarding policies."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+HOP_BY_HOP_REQUEST_HEADERS = frozenset(
+    {
+        "accept-encoding",
+        "connection",
+        "content-length",
+        "expect",
+        "forwarded",
+        "host",
+        "keep-alive",
+        "proxy-authenticate",
+        "proxy-authorization",
+        "te",
+        "trailer",
+        "transfer-encoding",
+        "upgrade",
+        "via",
+        "x-forwarded-for",
+        "x-forwarded-host",
+        "x-forwarded-proto",
+    }
+)
+CONFIGURED_PROVIDER_CREDENTIAL_HEADERS = frozenset(
+    {"authorization", "cookie", "set-cookie", "x-api-key"}
+)
+
+
+def project_end_to_end_request_headers(
+    inbound_headers: Any | None,
+    *,
+    replace_credentials: bool,
+    transport_headers: frozenset[str] = HOP_BY_HOP_REQUEST_HEADERS,
+) -> dict[str, str]:
+    """Copy client headers verbatim except transport-owned connection headers.
+
+    Header names and values are not interpreted or reconstructed. Configured
+    provider routes additionally remove client credentials before the provider
+    adapter installs the selected provider credential.
+    """
+
+    if inbound_headers is None:
+        return {}
+    try:
+        items = inbound_headers.items()
+    except Exception:
+        return {}
+    excluded = transport_headers
+    if replace_credentials:
+        excluded = excluded | CONFIGURED_PROVIDER_CREDENTIAL_HEADERS
+    forwarded: dict[str, str] = {}
+    for raw_name, raw_value in items:
+        original_name = str(raw_name)
+        normalized_name = original_name.casefold()
+        if (
+            normalized_name not in excluded
+            and not normalized_name.startswith("x-ciel-runtime-")
+            and raw_value is not None
+        ):
+            forwarded[original_name] = str(raw_value)
+    return forwarded
+
+
+__all__ = [
+    "CONFIGURED_PROVIDER_CREDENTIAL_HEADERS",
+    "HOP_BY_HOP_REQUEST_HEADERS",
+    "project_end_to_end_request_headers",
+]

package/ciel_runtime_support/headless_config.py

@@ -0,0 +1,221 @@
+"""Application service for applying headless environment configuration."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessConfigCommands:
+    set_language: Callable[[str], None]
+    set_web_fetch: Callable[[bool], None]
+    set_provider: Callable[[str], None]
+    set_api_keys: Callable[[str, list[str]], None]
+    set_api_key: Callable[[str, str], None]
+    set_base_url: Callable[[str, str], None]
+    set_model: Callable[[str], None]
+    set_advisor_model: Callable[[str], None]
+    set_provider_options: Callable[[list[str]], None]
+    set_ollama_options: Callable[[list[str]], None]
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessChannelCommands:
+    add_channel: Callable[[str], None]
+    set_delivery: Callable[[str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessConfigServices:
+    environ: Mapping[str, str]
+    parse_bool: Callable[[str | None, bool | None], bool | None]
+    current_provider: Callable[[], str]
+    commands: HeadlessConfigCommands
+    channels: HeadlessChannelCommands
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessConfigResult:
+    skip_menu: bool
+    web_search_override: bool | None
+    update_check_override: bool | None
+    self_update_check_override: bool | None
+    force_menu: bool
+
+    def as_tuple(self) -> tuple[bool, bool | None, bool | None, bool | None, bool]:
+        return (
+            self.skip_menu,
+            self.web_search_override,
+            self.update_check_override,
+            self.self_update_check_override,
+            self.force_menu,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessEnvFileLoader:
+    load: Callable[..., None]
+
+    def pop_args(self, argv: list[str]) -> list[str]:
+        cleaned: list[str] = []
+        index = 0
+        while index < len(argv):
+            argument = argv[index]
+            if (
+                argument == "--ca-env-file"
+                or argument.startswith("--ca-env-file=")
+            ):
+                value = (
+                    argument.split("=", 1)[1]
+                    if "=" in argument
+                    else None
+                )
+                if value is None:
+                    if index + 1 >= len(argv):
+                        raise SystemExit(
+                            "Missing path for --ca-env-file"
+                        )
+                    value = argv[index + 1]
+                    index += 2
+                else:
+                    index += 1
+                path = Path(value).expanduser()
+                if not path.exists():
+                    raise SystemExit(
+                        f"--ca-env-file not found: {path}"
+                    )
+                self.load(path, override=True)
+                continue
+            cleaned.append(argument)
+            index += 1
+        return cleaned
+
+
+PROVIDER_OPTION_ENV = {
+    "CIEL_RUNTIME_MAX_OUTPUT_TOKENS": "max_output_tokens",
+    "CIEL_RUNTIME_CONTEXT_WINDOW": "context_window",
+    "CIEL_RUNTIME_REQUEST_TIMEOUT_MS": "request_timeout_ms",
+    "CIEL_RUNTIME_STREAM_IDLE_TIMEOUT_MS": "stream_idle_timeout_ms",
+    "CIEL_RUNTIME_RATE_LIMIT_RPM": "rate_limit_rpm",
+    "CIEL_RUNTIME_RATE_LIMIT_STATUS": "rate_limit_status",
+    "CIEL_RUNTIME_STREAM": "stream_enabled",
+    "CIEL_RUNTIME_STREAM_WORD_CHUNKING": "stream_word_chunking",
+}
+
+
+def apply_headless_config(services: HeadlessConfigServices) -> HeadlessConfigResult:
+    env = services.environ
+    commands = services.commands
+    skip_menu = env.get("CIEL_RUNTIME_SKIP_MENU") == "1"
+    force_menu = bool(services.parse_bool(env.get("CIEL_RUNTIME_FORCE_MENU"), False))
+    web_search_override = services.parse_bool(env.get("CIEL_RUNTIME_WEB_SEARCH"), None)
+    update_check_override = services.parse_bool(env.get("CIEL_RUNTIME_UPDATE_CHECK"), None)
+    self_update_check_override = services.parse_bool(env.get("CIEL_RUNTIME_SELF_UPDATE_CHECK"), None)
+
+    language = env.get("CIEL_RUNTIME_LANGUAGE", "").strip()
+    if language:
+        commands.set_language(language)
+        skip_menu = True
+    web_fetch = services.parse_bool(env.get("CIEL_RUNTIME_WEB_FETCH"), None)
+    if web_fetch is not None:
+        commands.set_web_fetch(web_fetch)
+        skip_menu = True
+    provider = env.get("CIEL_RUNTIME_PROVIDER", "").strip()
+    if provider:
+        commands.set_provider(provider)
+        skip_menu = True
+
+    current_provider = services.current_provider()
+    skip_menu = _apply_api_key_config(env, current_provider, commands) or skip_menu
+
+    base_url = env.get("CIEL_RUNTIME_BASE_URL", "").strip()
+    if base_url:
+        commands.set_base_url(services.current_provider(), base_url)
+        skip_menu = True
+    model = env.get("CIEL_RUNTIME_MODEL", "").strip()
+    if model:
+        commands.set_model(model)
+        skip_menu = True
+    advisor_model = env.get("CIEL_RUNTIME_ADVISOR_MODEL", "").strip()
+    if advisor_model:
+        commands.set_advisor_model(advisor_model)
+        skip_menu = True
+
+    provider_values = [
+        f"{option_key}={env[env_key].strip()}"
+        for env_key, option_key in PROVIDER_OPTION_ENV.items()
+        if env.get(env_key, "").strip()
+    ]
+    if provider_values:
+        commands.set_provider_options(provider_values)
+        skip_menu = True
+
+    ollama_values = _ollama_option_values(env)
+    if ollama_values:
+        commands.set_ollama_options(ollama_values)
+        skip_menu = True
+
+    for channel in _split_values(env.get("CIEL_RUNTIME_CHANNELS", "")):
+        services.channels.add_channel(channel)
+        skip_menu = True
+    for channel in _split_values(env.get("CIEL_RUNTIME_DEV_CHANNELS", "")):
+        services.channels.add_channel(channel)
+        skip_menu = True
+    channel_delivery = env.get("CIEL_RUNTIME_CHANNEL_DELIVERY", "").strip()
+    if channel_delivery:
+        services.channels.set_delivery(channel_delivery)
+        skip_menu = True
+
+    return HeadlessConfigResult(
+        skip_menu=skip_menu,
+        web_search_override=web_search_override,
+        update_check_override=update_check_override,
+        self_update_check_override=self_update_check_override,
+        force_menu=force_menu,
+    )
+
+
+def _apply_api_key_config(
+    env: Mapping[str, str],
+    provider: str,
+    commands: HeadlessConfigCommands,
+) -> bool:
+    api_keys_env = env.get("CIEL_RUNTIME_API_KEYS_ENV", "").strip()
+    api_keys = env.get("CIEL_RUNTIME_API_KEYS", "").strip()
+    api_key_env = env.get("CIEL_RUNTIME_API_KEY_ENV", "").strip()
+    api_key = env.get("CIEL_RUNTIME_API_KEY", "").strip()
+    if api_keys_env:
+        value = env.get(api_keys_env, "")
+        if not value:
+            raise SystemExit(f"Environment variable {api_keys_env} is empty or not set")
+        commands.set_api_keys(provider, [value])
+        return True
+    if api_keys:
+        commands.set_api_keys(provider, [api_keys])
+        return True
+    if api_key_env:
+        value = env.get(api_key_env, "")
+        if not value:
+            raise SystemExit(f"Environment variable {api_key_env} is empty or not set")
+        commands.set_api_key(provider, value)
+        return True
+    if api_key:
+        commands.set_api_key(provider, api_key)
+        return True
+    return False
+
+
+def _ollama_option_values(env: Mapping[str, str]) -> list[str]:
+    values: list[str] = []
+    num_ctx = env.get("CIEL_RUNTIME_OLLAMA_NUM_CTX", "").strip()
+    if num_ctx:
+        values.append(f"num_ctx={num_ctx}")
+    values.extend(item for item in env.get("CIEL_RUNTIME_OLLAMA_OPTIONS", "").replace(",", " ").split() if item)
+    return values
+
+
+def _split_values(value: str) -> list[str]:
+    return [item.strip() for item in re.split(r"[\s,]+", value.strip()) if item.strip()]

package/ciel_runtime_support/http_response.py

@@ -0,0 +1,129 @@
+"""HTTP response writer and pending channel-delivery guard."""
+
+from __future__ import annotations
+
+import errno
+import json
+from typing import Any, Callable
+
+
+CLIENT_DISCONNECT_ERRNOS = {
+    errno.EPIPE,
+    errno.ECONNRESET,
+    getattr(errno, "ECONNABORTED", errno.ECONNRESET),
+}
+
+
+class HttpResponseAdapter:
+    def __init__(self, log: Callable[[str, str], None]) -> None:
+        self.log = log
+
+    @staticmethod
+    def write_json(handler: Any, value: Any, status: int = 200) -> None:
+        body = json.dumps(value).encode("utf-8")
+        handler.send_response(status)
+        handler.send_header("content-type", "application/json")
+        handler.send_header("content-length", str(len(body)))
+        handler.end_headers()
+        handler.wfile.write(body)
+
+    @staticmethod
+    def is_client_disconnect(error: BaseException) -> bool:
+        if isinstance(error, (BrokenPipeError, ConnectionResetError, ConnectionAbortedError)):
+            return True
+        return isinstance(error, OSError) and getattr(error, "errno", None) in CLIENT_DISCONNECT_ERRNOS
+
+    def try_write_json(self, handler: Any, value: Any, status: int = 200) -> bool:
+        try:
+            self.write_json(handler, value, status)
+            return True
+        except Exception as exc:
+            if self.is_client_disconnect(exc):
+                self.log(
+                    "WARN",
+                    f"write_json_client_disconnected status={status} "
+                    f"error={type(exc).__name__}: {exc}",
+                )
+                return False
+            raise
+
+    @staticmethod
+    def response_status(handler: Any) -> int | None:
+        try:
+            return int(getattr(handler, "_ciel_runtime_response_status", None))
+        except Exception:
+            return None
+
+    @staticmethod
+    def write_empty(handler: Any, status: int = 202) -> None:
+        handler.send_response(status)
+        handler.send_header("content-length", "0")
+        handler.end_headers()
+
+    @staticmethod
+    def write_accepted(handler: Any) -> None:
+        body = b"Accepted"
+        handler.send_response(202)
+        handler.send_header("content-type", "text/plain")
+        handler.send_header("content-length", str(len(body)))
+        handler.end_headers()
+        handler.wfile.write(body)
+
+
+class ChannelDeliveryGuard:
+    def __init__(self, log: Callable[[str, str], None]) -> None:
+        self.log = log
+
+    @staticmethod
+    def metadata_enabled(metadata: dict[str, Any] | None) -> bool:
+        return isinstance(metadata, dict) and bool(
+            metadata.get("ciel_runtime_channel_cursor_last_id")
+        )
+
+    def begin(self, handler: Any | None, body: dict[str, Any]) -> None:
+        if handler is None:
+            return
+        metadata = body.get("metadata") if isinstance(body.get("metadata"), dict) else {}
+        if not self.metadata_enabled(metadata):
+            return
+        try:
+            setattr(handler, "_ciel_runtime_channel_delivery_guard", True)
+            setattr(handler, "_ciel_runtime_channel_delivery_ok", False)
+            setattr(handler, "_ciel_runtime_channel_delivery_reason", "pending")
+        except Exception as exc:
+            self.log(
+                "WARN",
+                f"channel_delivery_guard_begin_failed error={type(exc).__name__}: {exc}",
+            )
+
+    def success(self, handler: Any | None, reason: str = "response_complete") -> None:
+        if handler is None or not getattr(handler, "_ciel_runtime_channel_delivery_guard", False):
+            return
+        try:
+            setattr(handler, "_ciel_runtime_channel_delivery_ok", True)
+            setattr(handler, "_ciel_runtime_channel_delivery_reason", reason)
+        except Exception as exc:
+            self.log(
+                "WARN",
+                f"channel_delivery_guard_success_failed reason={reason} "
+                f"error={type(exc).__name__}: {exc}",
+            )
+
+    def failed(self, handler: Any | None, reason: str = "response_failed") -> None:
+        if handler is None or not getattr(handler, "_ciel_runtime_channel_delivery_guard", False):
+            return
+        try:
+            setattr(handler, "_ciel_runtime_channel_delivery_ok", False)
+            setattr(handler, "_ciel_runtime_channel_delivery_reason", reason)
+        except Exception as exc:
+            self.log(
+                "WARN",
+                f"channel_delivery_guard_failure_failed reason={reason} "
+                f"error={type(exc).__name__}: {exc}",
+            )
+
+    @staticmethod
+    def confirmed(handler: Any | None) -> bool:
+        if handler is None or not getattr(handler, "_ciel_runtime_channel_delivery_guard", False):
+            return True
+        return bool(getattr(handler, "_ciel_runtime_channel_delivery_ok", False))

package/ciel_runtime_support/install_diagnostics.py

@@ -0,0 +1,149 @@
+"""Discovery and presentation of duplicate Ciel Runtime installations."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True, slots=True)
+class InstallDiagnosticsSettings:
+    home: Path
+    environ: Mapping[str, str]
+    windows: bool
+
+
+@dataclass(frozen=True, slots=True)
+class InstallDiagnosticsPorts:
+    extra_dirs: Callable[[], list[Path]]
+    package_root: Callable[[Path], Path | None]
+    current_root: Callable[[], Path | None]
+    parse_version: Callable[[str], tuple[int, ...]]
+    diagnostics: Callable[[], list[dict[str, str]]]
+    stdin_isatty: Callable[[], bool]
+    stdout_isatty: Callable[[], bool]
+    write_error: Callable[[str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class InstallDiagnosticsService:
+    settings: InstallDiagnosticsSettings
+    ports: InstallDiagnosticsPorts
+
+    def candidate_dirs(self) -> list[Path]:
+        raw_dirs = [
+            Path(entry)
+            for entry in self.settings.environ.get("PATH", "").split(";" if self.settings.windows else ":")
+            if entry
+        ]
+        raw_dirs.extend(self.ports.extra_dirs())
+        raw_dirs.extend(
+            [self.settings.home / ".npm-global" / "bin", self.settings.home / "bin"]
+        )
+        if not self.settings.windows:
+            raw_dirs.extend([Path("/usr/local/bin"), Path("/usr/bin")])
+        return list(dict.fromkeys(raw_dirs))
+
+    def candidates(self) -> list[Path]:
+        names = ["ciel-runtime"]
+        if self.settings.windows:
+            names.extend(["ciel-runtime.cmd", "ciel-runtime.exe"])
+        candidates: list[Path] = []
+        seen: set[str] = set()
+        for directory in self.candidate_dirs():
+            for name in names:
+                candidate = directory / name
+                if not candidate.exists():
+                    continue
+                try:
+                    key = str(candidate.resolve(strict=False))
+                except Exception:
+                    key = str(candidate)
+                if key not in seen:
+                    seen.add(key)
+                    candidates.append(candidate)
+        return candidates
+
+    def launcher_version(self, path: Path, timeout: float = 5.0) -> str:
+        environ = dict(self.settings.environ)
+        environ.update(
+            CIEL_RUNTIME_SKIP_INSTALL_DIAGNOSTIC="1",
+            CIEL_RUNTIME_SKIP_SELF_UPDATE="1",
+            CIEL_RUNTIME_SELF_UPDATE_CHECK="off",
+        )
+        try:
+            process = subprocess.run(
+                [str(path), "--version"],
+                text=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                env=environ,
+                timeout=timeout,
+            )
+        except Exception:
+            return ""
+        if process.returncode != 0:
+            return ""
+        output = process.stdout or ""
+        match = re.search(r"ciel-runtime\s+(.+)", output, re.IGNORECASE)
+        return match.group(1).strip() if match else output.strip().splitlines()[-1].strip()
+
+    def diagnostics(self) -> list[dict[str, str]]:
+        rows: list[dict[str, str]] = []
+        for launcher in self.candidates():
+            root = self.ports.package_root(launcher)
+            rows.append(
+                {
+                    "launcher": str(launcher),
+                    "resolved": str(launcher.resolve(strict=False)),
+                    "package_root": str(root) if root else "",
+                    "version": self.launcher_version(launcher),
+                }
+            )
+        return rows
+
+    def warn_if_multiple(self) -> None:
+        if self.settings.environ.get("CIEL_RUNTIME_SKIP_INSTALL_DIAGNOSTIC") == "1":
+            return
+        if not (self.ports.stdin_isatty() and self.ports.stdout_isatty()):
+            return
+        rows = self.ports.diagnostics()
+        roots = {row["package_root"] for row in rows if row.get("package_root")}
+        if len(roots) <= 1:
+            return
+        current_root = str(self.ports.current_root() or "")
+        first = rows[0] if rows else {}
+        newest = max(
+            (row for row in rows if row.get("version")),
+            key=lambda row: self.ports.parse_version(row["version"]),
+            default=None,
+        )
+        self.ports.write_error(
+            "Ciel Runtime warning: multiple ciel-runtime npm installs are visible."
+        )
+        if first:
+            self.ports.write_error(
+                f"  shell resolves ciel-runtime to: {first.get('launcher')} "
+                f"({first.get('version') or 'unknown version'})"
+            )
+        if current_root:
+            self.ports.write_error(f"  current package root: {current_root}")
+        if newest and newest is not first:
+            self.ports.write_error(
+                f"  newer visible install: {newest.get('launcher')} "
+                f"({newest.get('version')})"
+            )
+        self.ports.write_error(
+            "  Fix by keeping one install prefix: update or uninstall the stale "
+            "higher-priority install."
+        )
+
+
+__all__ = [
+    "InstallDiagnosticsPorts",
+    "InstallDiagnosticsService",
+    "InstallDiagnosticsSettings",
+]

package/ciel_runtime_support/kimi_identity.py

@@ -0,0 +1,123 @@
+"""Official Kimi Code credential and request identity compatibility."""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import re
+import shutil
+import socket
+import subprocess
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+
+def code_home(home: Path, environ: dict[str, str] | None = None) -> Path:
+    values = os.environ if environ is None else environ
+    return Path(values.get("KIMI_CODE_HOME") or (home / ".kimi-code"))
+
+
+def oauth_token_record(home: Path) -> dict[str, Any] | None:
+    try:
+        value = json.loads(
+            (code_home(home) / "credentials" / "kimi-code.json").read_text(
+                encoding="utf-8"
+            )
+        )
+    except (OSError, TypeError, ValueError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def oauth_access_token(home: Path) -> str | None:
+    record = oauth_token_record(home)
+    if record is None:
+        return None
+    token = str(record.get("access_token") or "").strip()
+    try:
+        expires_at = float(record.get("expires_at") or 0)
+    except (TypeError, ValueError):
+        expires_at = 0
+    if not token or (expires_at > 0 and expires_at <= time.time() + 30):
+        return None
+    return token
+
+
+def oauth_configured(home: Path) -> bool:
+    if oauth_access_token(home) is None:
+        return False
+    try:
+        text = (code_home(home) / "config.toml").read_text(encoding="utf-8")
+    except OSError:
+        return False
+    return "managed:kimi-code" in text and ("oauth" in text or 'api_key = ""' in text)
+
+
+def code_version() -> str:
+    cached = getattr(code_version, "_cached", None)
+    if isinstance(cached, str) and cached:
+        return cached
+    executable = shutil.which("kimi")
+    version = "unknown"
+    if executable:
+        result = subprocess.run(
+            [executable, "--version"], text=True, capture_output=True, check=False
+        )
+        match = re.search(
+            r"\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?",
+            result.stdout or result.stderr,
+        )
+        if match:
+            version = match.group(0)
+    setattr(code_version, "_cached", version)
+    return version
+
+
+def device_id(home: Path) -> str:
+    path = code_home(home) / "device_id"
+    try:
+        existing = path.read_text(encoding="utf-8").strip()
+        if existing:
+            return existing
+    except OSError:
+        pass
+    value = str(uuid.uuid4())
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    try:
+        descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
+            stream.write(value)
+    except FileExistsError:
+        return path.read_text(encoding="utf-8").strip()
+    return value
+
+
+def identity_headers(home: Path) -> dict[str, str]:
+    version = code_version()
+    system = platform.system()
+    os_name = "Windows_NT" if system == "Windows" else "Darwin" if system == "Darwin" else system
+    release = platform.release()
+    architecture = platform.machine()
+    return {
+        "User-Agent": f"kimi-code-cli/{version}",
+        "X-Msh-Platform": "kimi_code_cli",
+        "X-Msh-Version": version,
+        "X-Msh-Device-Name": socket.gethostname(),
+        "X-Msh-Device-Model": f"{os_name} {release} {architecture}".strip(),
+        "X-Msh-Os-Version": release,
+        "X-Msh-Device-Id": device_id(home),
+    }
+
+
+__all__ = [
+    "code_home",
+    "code_version",
+    "device_id",
+    "identity_headers",
+    "oauth_access_token",
+    "oauth_configured",
+    "oauth_token_record",
+]