@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/runtime_llm_options.py

@@ -0,0 +1,312 @@
+"""Runtime LLM option snapshot, restore, slider, and status controller."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLlmSettings:
+    option_keys: frozenset[str]
+    original_key: str
+    slider_labels: Mapping[str, str]
+    ollama_providers: frozenset[str] = frozenset(("ollama", "ollama-cloud"))
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLlmConfigPorts:
+    load: Callable[[], dict[str, Any]]
+    save: Callable[[dict[str, Any]], None]
+    clear_model_cache: Callable[[], None]
+    deep_copy: Callable[[Any], Any]
+    current_provider: Callable[[dict[str, Any]], tuple[str, dict[str, Any]]]
+    normalize_preset: Callable[[str], str]
+    resolve_preset: Callable[[str], str | None]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLlmPresentationPorts:
+    applied_preset: Callable[[str, dict[str, Any]], str]
+    slider_presets: Callable[[], Sequence[str]]
+    preset_text: Callable[[str, str], tuple[str, str]]
+    provider_label: Callable[[str, dict[str, Any]], str]
+    context_status: Callable[[str, dict[str, Any]], str]
+    timeout_status: Callable[[dict[str, Any], str], str]
+    ollama_options: Callable[[dict[str, Any]], dict[str, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLlmMutationPorts:
+    apply_preset: Callable[..., list[str]]
+
+
+class RuntimeLlmOptionsController:
+    def __init__(
+        self,
+        settings: RuntimeLlmSettings,
+        config: RuntimeLlmConfigPorts,
+        presentation: RuntimeLlmPresentationPorts,
+        mutation: RuntimeLlmMutationPorts,
+    ) -> None:
+        self.settings = settings
+        self.config = config
+        self.presentation = presentation
+        self.mutation = mutation
+
+    def snapshot(self, provider: str, provider_config: dict[str, Any]) -> dict[str, Any]:
+        values = {
+            key: self.config.deep_copy(provider_config[key])
+            for key in sorted(self.settings.option_keys)
+            if key in provider_config
+        }
+        return {
+            "version": 1,
+            "captured_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "provider": provider,
+            "model": str(provider_config.get("current_model") or ""),
+            "values": values,
+        }
+
+    def ensure_snapshot(self, provider: str, provider_config: dict[str, Any]) -> bool:
+        existing = provider_config.get(self.settings.original_key)
+        if isinstance(existing, dict) and isinstance(existing.get("values"), dict):
+            return False
+        provider_config[self.settings.original_key] = self.snapshot(
+            provider,
+            provider_config,
+        )
+        return True
+
+    def restore(self, provider: str) -> list[str]:
+        config = self.config.load()
+        provider_config = config["providers"][provider]
+        snapshot = provider_config.get(self.settings.original_key)
+        if not isinstance(snapshot, dict) or not isinstance(snapshot.get("values"), dict):
+            return ["No captured live LLM options to restore."]
+        values = self.config.deep_copy(snapshot.get("values") or {})
+        for key in self.settings.option_keys:
+            provider_config.pop(key, None)
+        provider_config.update(values)
+        provider_config.pop(self.settings.original_key, None)
+        self._persist(config)
+        return [
+            "Restored live LLM options to the values captured before the first runtime preset change.",
+            f"Captured provider/model: {snapshot.get('provider') or provider} / "
+            f"{snapshot.get('model') or 'unknown'}",
+        ]
+
+    def apply_preset(self, provider: str, preset_id: str) -> list[str]:
+        config = self.config.load()
+        provider_config = config["providers"][provider]
+        captured = self.ensure_snapshot(provider, provider_config)
+        lines = self.mutation.apply_preset(
+            provider,
+            provider_config,
+            preset_id,
+            config.get("language", "en"),
+        )
+        if captured:
+            lines.insert(0, "Captured current live LLM options for /llm-restore.")
+        self._persist(config)
+        return lines
+
+    def slider_line(self, provider: str, provider_config: dict[str, Any]) -> str:
+        current = self.presentation.applied_preset(provider, provider_config)
+        parts = []
+        for preset_id in self.presentation.slider_presets():
+            label = self.settings.slider_labels.get(preset_id, preset_id)
+            parts.append(f"[{label}]" if preset_id == current else label)
+        return "< " + " | ".join(parts) + " >"
+
+    def apply_slider_delta(self, provider: str, delta: int) -> list[str]:
+        config = self.config.load()
+        provider_config = config["providers"][provider]
+        presets = list(self.presentation.slider_presets())
+        current = self.presentation.applied_preset(provider, provider_config)
+        try:
+            current_index = presets.index(current)
+        except ValueError:
+            current_index = 0
+        next_index = max(0, min(len(presets) - 1, current_index + delta))
+        next_preset = presets[next_index]
+        language = config.get("language", "en")
+        if next_index == current_index:
+            label = self.presentation.preset_text(next_preset, language)[0]
+            return [
+                f"Live LLM preset remains at {label}.",
+                f"Slider: {self.slider_line(provider, provider_config)}",
+            ]
+        captured = self.ensure_snapshot(provider, provider_config)
+        lines = self.mutation.apply_preset(
+            provider,
+            provider_config,
+            next_preset,
+            language,
+        )
+        if captured:
+            lines.insert(0, "Captured current live LLM options for /llm-restore.")
+        self._persist(config)
+        label = self.presentation.preset_text(next_preset, language)[0]
+        return [f"Live LLM preset moved to {label}."] + lines + [
+            f"Slider: {self.slider_line(provider, provider_config)}"
+        ]
+
+    def status_lines(
+        self,
+        provider: str,
+        provider_config: dict[str, Any],
+    ) -> list[str]:
+        language = self.config.load().get("language", "en")
+        applied = self.presentation.applied_preset(provider, provider_config)
+        lines = [
+            f"Provider: {self.presentation.provider_label(provider, provider_config)}",
+            f"Model: {provider_config.get('current_model') or 'unknown'}",
+            f"Preset: {applied} ({self.presentation.preset_text(applied, language)[0]})",
+            f"Slider: {self.slider_line(provider, provider_config)}",
+            f"Context: {self.presentation.context_status(provider, provider_config)}",
+            f"Timeout: {self.presentation.timeout_status(provider_config, language)}",
+        ]
+        if provider in self.settings.ollama_providers:
+            options = self.presentation.ollama_options(provider_config)
+            lines.append(f"Output tokens: {options.get('num_predict', 'default')}")
+        else:
+            lines.append(
+                f"Output tokens: {provider_config.get('max_output_tokens', 'default')}"
+            )
+        restore_available = isinstance(
+            provider_config.get(self.settings.original_key),
+            dict,
+        )
+        lines.append(f"Restore available: {'yes' if restore_available else 'no'}")
+        return lines
+
+    def preset_list_lines(
+        self,
+        provider: str,
+        provider_config: dict[str, Any],
+    ) -> list[str]:
+        language = self.config.load().get("language", "en")
+        applied = self.presentation.applied_preset(provider, provider_config)
+        lines = self.status_lines(provider, provider_config)
+        lines.extend(
+            (
+                "",
+                "Use `/llm left` or `/llm right` to move one step, or `/llm <preset-id>` to jump directly.",
+                "Preset ids:",
+            )
+        )
+        for preset_id in self.presentation.slider_presets():
+            label, description = self.presentation.preset_text(preset_id, language)
+            mark = "*" if preset_id == applied else " "
+            lines.append(f"{mark} {preset_id} — {label}: {description}")
+        lines.extend(
+            (
+                "  /llm-restore  restore captured original options",
+                "  /llm <left|right|preset-id|status|list|restore>",
+            )
+        )
+        return lines
+
+    def handle_action(
+        self,
+        action: str = "status",
+        preset: str = "",
+    ) -> tuple[list[str], bool]:
+        config = self.config.load()
+        provider, provider_config = self.config.current_provider(config)
+        raw_action = str(action or "").strip()
+        raw_preset = str(preset or "").strip()
+        if not raw_action and raw_preset:
+            raw_action = "apply"
+        value = raw_preset or raw_action
+        normalized = self.config.normalize_preset(value)
+        if normalized in {"", "status", "state", "show", "current", "now"}:
+            return self.status_lines(provider, provider_config), False
+        if normalized in {
+            "list", "presets", "preset", "help", "options", "menu", "select"
+        }:
+            return self.preset_list_lines(provider, provider_config), False
+        if normalized in {
+            "left", "prev", "previous", "backward", "back", "decrease", "minus"
+        }:
+            return self._slider_action(provider, -1)
+        if normalized in {"right", "next", "forward", "increase", "plus"}:
+            return self._slider_action(provider, 1)
+        if normalized in {"restore", "original", "reset", "revert", "undo"}:
+            had_snapshot = isinstance(
+                provider_config.get(self.settings.original_key), dict
+            )
+            lines = self.restore(provider)
+            config_after = self.config.load()
+            _provider_after, provider_config_after = self.config.current_provider(
+                config_after
+            )
+            return lines + [""] + self.status_lines(
+                provider, provider_config_after
+            ), had_snapshot
+        preset_id = self.config.resolve_preset(value)
+        if not preset_id:
+            return [
+                f"Unknown live LLM preset/action: {value or raw_action or raw_preset}",
+                "Use `/llm-options list` to see available presets, or `/llm-restore` to revert.",
+            ], False
+        lines = self.apply_preset(provider, preset_id)
+        return self._updated_lines(provider, lines), True
+
+    def _slider_action(self, provider: str, delta: int) -> tuple[list[str], bool]:
+        return self._updated_lines(
+            provider,
+            self.apply_slider_delta(provider, delta),
+        ), True
+
+    def _updated_lines(self, provider: str, lines: list[str]) -> list[str]:
+        config_after = self.config.load()
+        _provider_after, provider_config_after = self.config.current_provider(
+            config_after
+        )
+        return (
+            lines
+            + ["", "Updated live LLM options. The next model request uses these settings."]
+            + self.status_lines(provider, provider_config_after)
+        )
+
+    def _persist(self, config: dict[str, Any]) -> None:
+        self.config.save(config)
+        self.config.clear_model_cache()
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeLlmOptionsApi:
+    """Explicit public adapter for a late-bound runtime options controller."""
+
+    controller_factory: Callable[[], RuntimeLlmOptionsController]
+
+    def handle_live_llm_options_action(self, action: str = "status", preset: str = "") -> tuple[list[str], bool]:
+        return self.controller_factory().handle_action(action, preset)
+
+    def snapshot_from_provider(self, provider: str, pcfg: dict[str, Any]) -> dict[str, Any]:
+        return self.controller_factory().snapshot(provider, pcfg)
+
+    def ensure_original_snapshot(self, provider: str, pcfg: dict[str, Any]) -> bool:
+        return self.controller_factory().ensure_snapshot(provider, pcfg)
+
+    def restore_original_options(self, provider: str) -> list[str]:
+        return self.controller_factory().restore(provider)
+
+    def apply_preset_config(self, provider: str, preset_id: str) -> list[str]:
+        return self.controller_factory().apply_preset(provider, preset_id)
+
+    def slider_line(self, provider: str, pcfg: dict[str, Any]) -> str:
+        return self.controller_factory().slider_line(provider, pcfg)
+
+    def apply_slider_delta_config(self, provider: str, delta: int) -> list[str]:
+        return self.controller_factory().apply_slider_delta(provider, delta)
+
+    def status_lines(self, provider: str, pcfg: dict[str, Any]) -> list[str]:
+        return self.controller_factory().status_lines(provider, pcfg)
+
+    def preset_list_lines(self, provider: str, pcfg: dict[str, Any]) -> list[str]:
+        return self.controller_factory().preset_list_lines(provider, pcfg)

package/ciel_runtime_support/runtime_logging.py

@@ -0,0 +1,161 @@
+"""Runtime log-level repository and rotating file logger."""
+
+from __future__ import annotations
+
+import os
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+LOG_LEVELS = {"SILENT": 0, "ERROR": 1, "WARN": 2, "INFO": 3, "DEBUG": 4, "TRACE": 5}
+LOG_LEVEL_NAMES = {value: name for name, value in LOG_LEVELS.items()}
+
+
+def normalize_log_level(value: str) -> str | None:
+    raw = str(value or "").strip()
+    if not raw:
+        raise ValueError("log level is empty")
+    upper = {
+        "OFF": "SILENT",
+        "NONE": "SILENT",
+        "QUIET": "SILENT",
+        "WARNING": "WARN",
+        "WARNINGS": "WARN",
+    }.get(raw.upper(), raw.upper())
+    if upper in ("DEFAULT", "RESET", "UNSET", "AUTO"):
+        return None
+    if upper in LOG_LEVELS:
+        return upper
+    if upper.isdigit():
+        return LOG_LEVEL_NAMES[max(0, min(5, int(upper)))]
+    raise ValueError(f"unknown log level: {value}")
+
+
+@dataclass(frozen=True, slots=True)
+class LogLevelRepository:
+    config_dir: Path
+    path: Path
+    cache: dict[str, Any]
+    default_level: int
+    environ: dict[str, str]
+
+    def current(self) -> int:
+        now = time.time()
+        if self.cache["value"] is not None and now - float(self.cache["checked_at"]) < 1.0:
+            return int(self.cache["value"])
+        level = self._file_level(now)
+        if level is None:
+            value = self.environ.get("CIEL_RUNTIME_LOG_LEVEL", "").strip().upper()
+            if value in LOG_LEVELS:
+                level = LOG_LEVELS[value]
+            elif value.isdigit():
+                level = max(0, min(5, int(value)))
+        if level is None:
+            level = self.default_level
+        self.cache.update(value=level, checked_at=now)
+        return level
+
+    def _file_level(self, now: float) -> int | None:
+        try:
+            if not self.path.exists():
+                return None
+            modified = self.path.stat().st_mtime
+            if self.cache["value"] is not None and modified == self.cache["file_mtime"]:
+                self.cache["checked_at"] = now
+                return int(self.cache["value"])
+            text = self.path.read_text(encoding="utf-8").strip().upper()
+            self.cache["file_mtime"] = modified
+            if text in LOG_LEVELS:
+                return LOG_LEVELS[text]
+            if text.isdigit():
+                return max(0, min(5, int(text)))
+        except Exception:
+            pass
+        return None
+
+    def reset_cache(self) -> None:
+        self.cache.update(value=None, checked_at=0.0, file_mtime=0.0)
+
+    def name(self, value: int | None = None) -> str:
+        effective = self.current() if value is None else value
+        return str(LOG_LEVEL_NAMES.get(int(effective), effective))
+
+    def source(self) -> str:
+        if self.path.exists():
+            return "file"
+        if self.environ.get("CIEL_RUNTIME_LOG_LEVEL", "").strip():
+            return "env"
+        return "default"
+
+    def status(self) -> str:
+        return f"{self.name()} ({self.source()})"
+
+    def set(self, value: str) -> list[str]:
+        try:
+            level = normalize_log_level(value)
+        except ValueError as error:
+            return [f"{error}. Known levels: {', '.join(LOG_LEVELS)}, DEFAULT."]
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        if level is None:
+            try:
+                self.path.unlink()
+            except FileNotFoundError:
+                pass
+            self.reset_cache()
+            return [f"Log level reset to {self.status()}."]
+        self.path.write_text(level + "\n", encoding="utf-8")
+        try:
+            os.chmod(self.path, 0o600)
+        except Exception:
+            pass
+        self.reset_cache()
+        return [f"Log level set to {level}."]
+
+
+@dataclass(frozen=True, slots=True)
+class LogLevelApi:
+    """Explicit compatibility adapter for a late-bound log repository."""
+
+    repository_factory: Callable[[], LogLevelRepository]
+
+    def current(self) -> int:
+        return self.repository_factory().current()
+
+    def reset_cache(self) -> None:
+        self.repository_factory().reset_cache()
+
+    def name(self, value: int | None = None) -> str:
+        return self.repository_factory().name(value)
+
+    def source(self) -> str:
+        return self.repository_factory().source()
+
+    def status(self) -> str:
+        return self.repository_factory().status()
+
+    def set(self, value: str) -> list[str]:
+        return self.repository_factory().set(value)
+
+
+@dataclass(frozen=True, slots=True)
+class RouterFileLogger:
+    config_dir: Path
+    path: Path
+    max_bytes: int
+    levels: LogLevelRepository
+
+    def write(self, level: str, message: str) -> None:
+        threshold = LOG_LEVELS.get(level, 0)
+        if threshold <= 0 or threshold > self.levels.current():
+            return
+        try:
+            self.config_dir.mkdir(parents=True, exist_ok=True)
+            if self.path.exists() and self.path.stat().st_size > self.max_bytes:
+                self.path.replace(self.path.with_suffix(".log.1"))
+            with self.path.open("a", encoding="utf-8") as handle:
+                handle.write(f"{time.strftime('%Y-%m-%dT%H:%M:%S')} [{level}] {message}\n")
+        except Exception:
+            pass

package/ciel_runtime_support/runtime_paths.py

@@ -0,0 +1,157 @@
+"""Platform-aware filesystem and local router endpoint configuration."""
+from __future__ import annotations
+
+import getpass
+import hashlib
+import os
+import sys
+from pathlib import Path, PureWindowsPath
+from typing import Any
+
+from .web_endpoints import apply_startup_web_options, load_saved_web_backend
+
+
+# Web startup flags affect the process-wide router endpoint constants below.
+sys.argv[:] = apply_startup_web_options(sys.argv, os.environ)
+
+
+HOME = Path.home()
+
+
+def platform_path(value: str | os.PathLike[str]) -> Any:
+    if os.name == "nt" and sys.platform != "win32":
+        return PureWindowsPath(value)
+    return Path(value)
+
+
+def windows_appdata_root() -> Path:
+    for env_name in ("APPDATA", "LOCALAPPDATA"):
+        raw = os.environ.get(env_name)
+        if raw:
+            return platform_path(raw)
+    return HOME / "AppData" / "Roaming"
+
+
+def windows_local_appdata_root() -> Path:
+    raw = os.environ.get("LOCALAPPDATA")
+    if raw:
+        return platform_path(raw)
+    return HOME / "AppData" / "Local"
+
+
+def platform_config_dir(app_name: str) -> Path:
+    if os.name == "nt":
+        return windows_appdata_root() / app_name
+    return HOME / ".config" / app_name
+
+
+def ciel_runtime_user_bin_dir() -> Path:
+    if os.name == "nt":
+        return windows_local_appdata_root() / "ciel-runtime" / "bin"
+    return HOME / ".local" / "bin"
+
+
+def agy_user_bin_dir() -> Path:
+    if os.name == "nt":
+        return windows_local_appdata_root() / "agy" / "bin"
+    return HOME / ".local" / "bin"
+
+
+def path_with_ciel_runtime_user_dirs(env: dict[str, str]) -> str:
+    dirs = [ciel_runtime_user_bin_dir(), agy_user_bin_dir()]
+    if os.name == "nt":
+        appdata = env.get("APPDATA") or os.environ.get("APPDATA")
+        if appdata:
+            dirs.append(platform_path(appdata) / "npm")
+        local_appdata = env.get("LOCALAPPDATA") or os.environ.get("LOCALAPPDATA")
+        if local_appdata:
+            dirs.append(platform_path(local_appdata) / "Programs" / "nodejs")
+    existing = env.get("PATH", "")
+    prefix = os.pathsep.join(str(path) for path in dirs if str(path))
+    return prefix + (os.pathsep + existing if existing else "")
+
+
+def default_router_port(saved_port: int = 0) -> int:
+    configured = str(os.environ.get("CIEL_RUNTIME_ROUTER_PORT") or "").strip()
+    if configured:
+        try:
+            port = int(configured)
+            if 1 <= port <= 65535:
+                return port
+        except ValueError:
+            pass
+    if 1 <= saved_port <= 65535:
+        return saved_port
+    base = 8799
+    getuid = getattr(os, "getuid", None)
+    if callable(getuid):
+        try:
+            return base + (int(getuid()) % 1000)
+        except Exception:
+            pass
+    seed = f"{getpass.getuser()}|{HOME}"
+    digest = hashlib.sha256(seed.encode("utf-8", errors="replace")).hexdigest()
+    return base + (int(digest[:8], 16) % 1000)
+
+
+CONFIG_DIR = Path(os.environ.get("CIEL_RUNTIME_CONFIG_DIR") or platform_config_dir("ciel-runtime"))
+CONFIG_PATH = CONFIG_DIR / "config.json"
+LOG_PATH = CONFIG_DIR / "router.log"
+LOG_LEVEL_PATH = CONFIG_DIR / "log-level"
+REQUEST_DUMP_PATH = CONFIG_DIR / "requests.jsonl"
+RESPONSE_DUMP_PATH = CONFIG_DIR / "responses.jsonl"
+USAGE_EVENTS_PATH = CONFIG_DIR / "usage-events.jsonl"
+SSE_TRACE_PATH = CONFIG_DIR / "router-sse-trace.jsonl"
+SSE_LAST_PATH = CONFIG_DIR / "router-last-sse.json"
+TOOL_CALL_LOG_PATH = CONFIG_DIR / "tool-calls.jsonl"
+RATE_LIMIT_STATE_PATH = CONFIG_DIR / "rate-limit-state.json"
+ROUTER_ACTIVITY_PATH = CONFIG_DIR / "router-activity.json"
+CONTEXT_COMPACT_ACTIVITY_PATH = CONFIG_DIR / "context-compact-activity.json"
+CONTEXT_USAGE_PATH = CONFIG_DIR / "context-usage.json"
+OLLAMA_MODEL_CATALOG_PATH = CONFIG_DIR / "ollama-model-catalog.json"
+CHAT_MESSAGES_PATH = CONFIG_DIR / "chat-messages.jsonl"
+CHAT_FILES_DIR = CONFIG_DIR / "chat-files"
+MENU_KEY_DEBUG_PATH = CONFIG_DIR / "ca-key-debug.log"
+PLAN_ARTIFACTS_DIR = CONFIG_DIR / "plan-artifacts"
+PID_PATH = CONFIG_DIR / "router.pid"
+ROUTER_EXTERNAL_TOKEN_PATH = CONFIG_DIR / "router-external-token"
+ROUTER_CLIENTS_DIR = CONFIG_DIR / "router-clients"
+MODEL_LIST_CACHE_PATH = CONFIG_DIR / "model-list-cache.json"
+MODEL_REGISTRY_PATH = CONFIG_DIR / "model-registry.json"
+LAUNCH_STATE_PATH = CONFIG_DIR / "launch-state.json"
+WEB_TOOLS_MCP_CONFIG = CONFIG_DIR / "web-tools-mcp.json"
+DUCKDUCKGO_MCP_CONFIG = CONFIG_DIR / "duckduckgo-mcp.json"
+ZAI_MCP_CONFIG = CONFIG_DIR / "zai-mcp.json"
+CHANNEL_MCP_CONFIG = CONFIG_DIR / "channel-mcp.json"
+NATIVE_MCP_CONFIG = CONFIG_DIR / "native-mcp.json"
+CODEX_MCP_CONFIG = CONFIG_DIR / "codex-mcp.json"
+CODEX_PROCESS_DIR = CONFIG_DIR / "codex-processes"
+CODEX_PROMPTS_DIR_NAME = "prompts"
+CHANNEL_MCP_CURSOR_PATH = CONFIG_DIR / "channel-mcp-cursor.json"
+CHANNEL_LLM_CURSOR_PATH = CONFIG_DIR / "channel-llm-cursor.json"
+CHANNEL_LLM_CLEAR_FLOOR_PATH = CONFIG_DIR / "channel-llm-clear-floor.json"
+CHANNEL_LLM_LAUNCH_GUARD_PATH = CONFIG_DIR / "channel-llm-launch-guard.json"
+CHANNEL_COMPACT_REQUEST_PATH = CONFIG_DIR / "channel-compact-request.json"
+CHANNEL_STDIN_WAKE_CLAIMS_PATH = CONFIG_DIR / "channel-stdin-wake-claims.json"
+CHANNEL_PROBE_CACHE_PATH = CONFIG_DIR / "channel-probe-cache.json"
+MCP_PROXY_CONFIG = CONFIG_DIR / "mcp-proxy.json"
+_SAVED_WEB_BACKEND = load_saved_web_backend(CONFIG_PATH)
+ROUTER_HOST = (
+    os.environ.get("CIEL_RUNTIME_ROUTER_CLIENT_HOST", "").strip()
+    or _SAVED_WEB_BACKEND.client_host
+)
+ROUTER_PORT = default_router_port(_SAVED_WEB_BACKEND.port)
+ROUTER_BASE = f"http://{ROUTER_HOST}:{ROUTER_PORT}"
+CLAUDE_GATEWAY_CACHE = HOME / ".claude" / "cache" / "gateway-models.json"
+CLAUDE_SETTINGS_PATH = HOME / ".claude" / "settings.json"
+CLAUDE_COMMANDS_DIR = HOME / ".claude" / "commands"
+CIEL_RUNTIME_STATUSLINE_PATH = ciel_runtime_user_bin_dir() / "ciel-runtime-statusline.py"
+NCP_ENV = platform_config_dir("nvd-claude-proxy") / ".env"
+NCP_LOG = platform_config_dir("nvd-claude-proxy") / "proxy.log"
+
+
+__all__ = [name for name in globals() if name.isupper() or name in {
+    "agy_user_bin_dir", "ciel_runtime_user_bin_dir", "default_router_port",
+    "path_with_ciel_runtime_user_dirs", "platform_config_dir", "platform_path",
+    "windows_appdata_root", "windows_local_appdata_root",
+}]