@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/channel_config_service.py

@@ -0,0 +1,281 @@
+"""Application service for persisted Channel configuration and CLI imports."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConfigPorts:
+    load: Callable[[], dict[str, Any]]
+    save: Callable[[dict[str, Any]], None]
+    invalidate: Callable[[], None]
+    dedupe: Callable[[Iterable[str]], list[str]]
+    log: Callable[[str, str], None]
+    environment: Mapping[str, str]
+
+
+class ChannelConfigService:
+    def __init__(
+        self,
+        builtin_spec: str,
+        ports: ChannelConfigPorts,
+    ) -> None:
+        self.builtin_spec = builtin_spec
+        self.ports = ports
+
+    @staticmethod
+    def is_tagged(spec: str) -> bool:
+        return spec.startswith("plugin:") or spec.startswith("server:")
+
+    def configured_specs(self, config: dict[str, Any]) -> list[str]:
+        raw = config.setdefault("claude_code", {}).get("channels", [])
+        if isinstance(raw, str):
+            items = [raw]
+        elif isinstance(raw, list):
+            items = raw
+        else:
+            items = []
+        return self.ports.dedupe(
+            [self.builtin_spec, *(str(item).strip() for item in items)]
+        )
+
+    def parse_passthrough(self, passthrough: list[str]) -> list[str]:
+        specs: list[str] = []
+        index = 0
+        options = ("--channels", "--dangerously-load-development-channels")
+        while index < len(passthrough):
+            argument = passthrough[index]
+            if argument in options:
+                index += 1
+                while index < len(passthrough) and self.is_tagged(passthrough[index]):
+                    specs.append(passthrough[index])
+                    index += 1
+                continue
+            if any(argument.startswith(option + "=") for option in options):
+                value = argument.split("=", 1)[1].strip()
+                if value and self.is_tagged(value):
+                    specs.append(value)
+            index += 1
+        return self.ports.dedupe(specs)
+
+    def normalize_passthrough(
+        self,
+        passthrough: list[str],
+    ) -> list[str]:
+        normalized: list[str] = []
+        index = 0
+        while index < len(passthrough):
+            argument = passthrough[index]
+            if argument == "--channels":
+                normalized.append(
+                    "--dangerously-load-development-channels"
+                )
+                index += 1
+                while (
+                    index < len(passthrough)
+                    and self.is_tagged(passthrough[index])
+                ):
+                    normalized.append(passthrough[index])
+                    index += 1
+                continue
+            if argument.startswith("--channels="):
+                value = argument.split("=", 1)[1].strip()
+                normalized.append(
+                    "--dangerously-load-development-channels"
+                )
+                if value:
+                    normalized.append(value)
+                index += 1
+                continue
+            normalized.append(argument)
+            index += 1
+        return normalized
+
+    def auto_import(self, passthrough: list[str]) -> list[str]:
+        specs = self.parse_passthrough(passthrough)
+        if not specs:
+            return []
+        config = self.ports.load()
+        existing = set(self.configured_specs(config))
+        if all(spec in existing for spec in specs):
+            return []
+        merged = [
+            spec
+            for spec in self.configured_specs(config)
+            if spec != self.builtin_spec
+        ]
+        added: list[str] = []
+        for spec in specs:
+            if spec not in existing and spec != self.builtin_spec:
+                merged.append(spec)
+                existing.add(spec)
+                added.append(spec)
+        if not added:
+            return []
+        config.setdefault("claude_code", {})["channels"] = merged
+        self.ports.save(config)
+        self.ports.invalidate()
+        self.ports.log(
+            "INFO",
+            f"channels_auto_imported_from_passthrough count={len(added)} "
+            f"specs={','.join(added)}",
+        )
+        return added
+
+    def launch_specs(
+        self,
+        config: dict[str, Any],
+        extra_specs: list[str] | None = None,
+    ) -> list[str]:
+        specs = [
+            spec
+            for spec in self.configured_specs(config)
+            if self.is_tagged(spec)
+        ]
+        if extra_specs:
+            specs.extend(extra_specs)
+        return self.ports.dedupe(spec for spec in specs if self.is_tagged(spec))
+
+    @staticmethod
+    def normalize_delivery(value: Any) -> str:
+        text = str(value or "").strip().lower().replace("_", "-")
+        if text in {
+            "native",
+            "native-channel",
+            "native-channel-bridge",
+            "claude-channel",
+            "claude/native",
+        }:
+            return "native"
+        if text in {
+            "stdin",
+            "pty",
+            "terminal",
+            "wake",
+            "wake-proxy",
+            "legacy",
+        }:
+            return "stdin"
+        return "llm"
+
+    def delivery_mode(self, config: dict[str, Any] | None = None) -> str:
+        environment_value = self.ports.environment.get("CIEL_RUNTIME_CHANNEL_DELIVERY")
+        if environment_value is not None:
+            return self.normalize_delivery(environment_value)
+        config = config or self.ports.load()
+        value = config.setdefault("claude_code", {}).get("channel_delivery", "llm")
+        return self.normalize_delivery(value)
+
+    def set_delivery(self, value: Any) -> list[str]:
+        mode = self.normalize_delivery(value)
+        config = self.ports.load()
+        config.setdefault("claude_code", {})["channel_delivery"] = mode
+        self.ports.save(config)
+        messages = {
+            "native": "Channel delivery set to native claude/channel bridge.",
+            "llm": "Channel delivery set to LLM context injection.",
+            "stdin": "Channel delivery set to stdin wake proxy.",
+        }
+        return [messages[mode]]
+
+    def add(self, spec: str) -> list[str]:
+        spec = spec.strip()
+        if not spec:
+            return ["Channel spec was empty."]
+        if not self.is_tagged(spec):
+            return ["Channel spec must start with plugin: or server:."]
+        if spec == self.builtin_spec:
+            return ["Ciel Runtime router channel is always enabled."]
+        config = self.ports.load()
+        channels = [
+            item
+            for item in self.configured_specs(config)
+            if item != self.builtin_spec
+        ]
+        if spec not in channels:
+            channels.append(spec)
+        config.setdefault("claude_code", {})["channels"] = channels
+        self.ports.save(config)
+        return [f"Channel added: {spec}."]
+
+    def remove(self, spec: str) -> list[str]:
+        if spec == self.builtin_spec:
+            return ["Ciel Runtime router channel is always enabled and cannot be removed."]
+        config = self.ports.load()
+        before = [
+            item
+            for item in self.configured_specs(config)
+            if item != self.builtin_spec
+        ]
+        after = [item for item in before if item != spec]
+        config.setdefault("claude_code", {})["channels"] = after
+        self.ports.save(config)
+        message = (
+            f"Channel removed: {spec}."
+            if len(after) != len(before)
+            else f"Channel was not configured: {spec}."
+        )
+        return [message]
+
+    def clear(self) -> list[str]:
+        config = self.ports.load()
+        config.setdefault("claude_code", {})["channels"] = []
+        self.ports.save(config)
+        return [
+            "External Claude Code channels cleared. Ciel Runtime router remains enabled."
+        ]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConfigApi:
+    """Explicit public adapter for late-bound Channel configuration services."""
+
+    service_factory: Callable[[], ChannelConfigService]
+
+    def parse_passthrough_channel_specs(self, passthrough: list[str]) -> list[str]:
+        return self.service_factory().parse_passthrough(passthrough)
+
+    def auto_import_passthrough_channels(self, passthrough: list[str]) -> list[str]:
+        return self.service_factory().auto_import(passthrough)
+
+    def normalize_channel_passthrough(
+        self,
+        passthrough: list[str],
+    ) -> list[str]:
+        return self.service_factory().normalize_passthrough(passthrough)
+
+    def channel_specs_for_launch(
+        self,
+        cfg: dict[str, Any],
+        passthrough: list[str],
+        extra_specs: list[str] | None = None,
+    ) -> list[str]:
+        del passthrough
+        return self.service_factory().launch_specs(cfg, extra_specs)
+
+    def is_channel_spec_tagged(self, spec: str) -> bool:
+        return self.service_factory().is_tagged(spec)
+
+    def normalize_channel_delivery(self, value: Any) -> str:
+        return self.service_factory().normalize_delivery(value)
+
+    def channel_delivery_mode(self, cfg: dict[str, Any] | None = None) -> str:
+        return self.service_factory().delivery_mode(cfg)
+
+    def set_channel_delivery_config(self, value: Any) -> list[str]:
+        return self.service_factory().set_delivery(value)
+
+    def add_channel_spec(
+        self, spec: str, *, development: bool = False
+    ) -> list[str]:
+        del development
+        return self.service_factory().add(spec)
+
+    def remove_channel_spec(self, spec: str) -> list[str]:
+        return self.service_factory().remove(spec)
+
+    def clear_channel_specs(self) -> list[str]:
+        return self.service_factory().clear()

package/ciel_runtime_support/channel_connection_lifecycle.py

@@ -0,0 +1,180 @@
+"""Lifecycle service for creating and stopping channel transport connections."""
+
+from __future__ import annotations
+
+import threading
+import time
+import urllib.parse
+import uuid
+from dataclasses import dataclass
+from threading import Lock
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionLifecycleEffects:
+    safe_segment: Callable[[str, str], str]
+    close_session: Callable[[dict[str, Any], str], None]
+    cleanup_stale_sessions: Callable[[str, str, dict[str, str], str], None]
+    public_status: Callable[[str, dict[str, Any]], dict[str, Any]]
+    all_statuses: Callable[[], dict[str, Any]]
+    sse_worker: Callable[[str, str | None], None]
+    streamable_http_worker: Callable[[str, str | None], None]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionLifecyclePolicy:
+    streamable_protocol_version: str
+    legacy_sse_protocol_version: str
+    parse_bool: Callable[[Any, bool], bool]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionLifecycleStore:
+    states: dict[str, dict[str, Any]]
+    lock: Lock
+
+    def replace(self, name: str, state: dict[str, Any]) -> dict[str, Any] | None:
+        with self.lock:
+            prior = self.states.get(name)
+            if prior:
+                prior["running"] = False
+            self.states[name] = state
+            return dict(prior) if prior else None
+
+    def stop(self, name: str | None) -> tuple[list[str], list[dict[str, Any]]]:
+        stopped: list[str] = []
+        states_to_close: list[dict[str, Any]] = []
+        with self.lock:
+            targets = [name] if name else list(self.states)
+            for target in targets:
+                if not target:
+                    continue
+                state = self.states.get(target)
+                if state:
+                    state["running"] = False
+                    states_to_close.append(dict(state))
+                    stopped.append(target)
+        return stopped, states_to_close
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionLifecycle:
+    store: ChannelConnectionLifecycleStore
+    effects: ChannelConnectionLifecycleEffects
+    policy: ChannelConnectionLifecyclePolicy
+
+    @staticmethod
+    def _headers(config: dict[str, Any]) -> dict[str, str]:
+        raw_headers = config.get("headers") if isinstance(config.get("headers"), dict) else {}
+        headers = {str(key): str(value) for key, value in raw_headers.items() if str(key).strip()}
+        token = str(config.get("bearer_token") or config.get("token") or "").strip()
+        if token and "Authorization" not in headers:
+            headers["Authorization"] = f"Bearer {token}"
+        return headers
+
+    @staticmethod
+    def _event_filter(config: dict[str, Any]) -> list[str]:
+        event_filter = config.get("event_filter")
+        if isinstance(event_filter, str):
+            return [item.strip() for item in event_filter.split(",") if item.strip()]
+        if isinstance(event_filter, list):
+            return [str(item).strip() for item in event_filter if str(item).strip()]
+        return []
+
+    def _new_state(
+        self,
+        config: dict[str, Any],
+        name: str,
+        url: str,
+        transport: str,
+        headers: dict[str, str],
+        connection_id: str,
+    ) -> dict[str, Any]:
+        protocol_version = (
+            self.policy.streamable_protocol_version
+            if transport == "streamable-http"
+            else self.policy.legacy_sse_protocol_version
+        )
+        return {
+            "name": name,
+            "connection_id": connection_id,
+            "url": url,
+            "headers": headers,
+            "channel": str(config.get("channel") or "default"),
+            "sender_id": str(config.get("sender_id") or config.get("sender") or name),
+            "recipient": str(config.get("recipient") or config.get("recipient_id") or config.get("to") or "all"),
+            "running": True,
+            "started_at": time.strftime("%Y-%m-%dT%H:%M:%S"),
+            "last_event_at": None,
+            "messages_received": 0,
+            "last_error": None,
+            "event_filter": self._event_filter(config),
+            "last_sse_event_id": str(
+                config.get("last_sse_event_id")
+                or config.get("last_event_id")
+                or config.get("lastEventId")
+                or ""
+            ).strip(),
+            "sse_reconnects": 0,
+            "read_timeout_seconds": float(config.get("read_timeout_seconds") or config.get("timeout") or 300.0),
+            "retry_seconds": float(config.get("retry_seconds") or 5.0),
+            "mcp_enabled": bool(config.get("mcp", config.get("mcp_enabled", True))),
+            "mcp_endpoint": None,
+            "mcp_initialized": False,
+            "mcp_session_id": None,
+            "mcp_last_error": None,
+            "mcp_rpc_results": {},
+            "transport": transport,
+            "streamable_requires_session": self.policy.parse_bool(
+                config.get(
+                    "streamable_requires_session",
+                    config.get("require_session", config.get("mcp_session_required", True)),
+                ),
+                True,
+            ),
+            "mcp_protocol_version": str(config.get("mcp_protocol_version") or protocol_version),
+            "mcp_timeout_seconds": float(config.get("mcp_timeout_seconds") or 20.0),
+        }
+
+    def start(self, config: dict[str, Any]) -> dict[str, Any]:
+        url = str(config.get("url") or "").strip()
+        if not url.startswith(("http://", "https://")):
+            raise ValueError("SSE url must start with http:// or https://")
+        name = self.effects.safe_segment(
+            str(config.get("name") or urllib.parse.urlparse(url).netloc or "sse"), "sse"
+        )
+        declared_transport = str(config.get("transport") or config.get("type") or "").strip().lower()
+        transport = "streamable-http" if declared_transport in {"http", "streamable-http"} else "sse"
+        headers = self._headers(config)
+        connection_id = uuid.uuid4().hex
+        state = self._new_state(config, name, url, transport, headers, connection_id)
+        prior_state = self.store.replace(name, state)
+        if prior_state:
+            self.effects.close_session(prior_state, "replace_connection")
+        if transport == "streamable-http":
+            self.effects.cleanup_stale_sessions(
+                name,
+                url,
+                headers,
+                str(state.get("mcp_protocol_version") or self.policy.streamable_protocol_version),
+            )
+        worker = (
+            self.effects.streamable_http_worker
+            if transport == "streamable-http"
+            else self.effects.sse_worker
+        )
+        thread = threading.Thread(
+            target=worker,
+            args=(name, connection_id),
+            daemon=True,
+            name=f"ciel-runtime-channel-{transport}-{name}",
+        )
+        thread.start()
+        return self.effects.public_status(name, state)
+
+    def stop(self, name: str | None = None) -> dict[str, Any]:
+        stopped, states_to_close = self.store.stop(name)
+        for state in states_to_close:
+            self.effects.close_session(state, "stop_connection")
+        return {"stopped": stopped, "connections": self.effects.all_statuses()}

package/ciel_runtime_support/channel_connection_registry.py

@@ -0,0 +1,128 @@
+"""Thread-safe repository for live channel transport connection state."""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from threading import Condition, Lock
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelConnectionRegistry:
+    states: dict[str, dict[str, Any]]
+    lock: Lock
+    rpc_condition: Condition
+    log: Callable[[str, str], None]
+    clock: Callable[[], float] = time.time
+
+    @staticmethod
+    def public_status(name: str, state: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "name": name,
+            "url": state.get("url"),
+            "channel": state.get("channel"),
+            "sender_id": state.get("sender_id"),
+            "recipient": state.get("recipient"),
+            "running": bool(state.get("running")),
+            "started_at": state.get("started_at"),
+            "last_event_at": state.get("last_event_at"),
+            "messages_received": int(state.get("messages_received") or 0),
+            "event_filter": state.get("event_filter") or [],
+            "read_timeout_seconds": state.get("read_timeout_seconds"),
+            "last_sse_event_id": state.get("last_sse_event_id"),
+            "sse_reconnects": int(state.get("sse_reconnects") or 0),
+            "transport": state.get("transport") or "sse",
+            "mcp_endpoint": state.get("mcp_endpoint"),
+            "mcp_initialized": bool(state.get("mcp_initialized")),
+            "mcp_session_id": state.get("mcp_session_id"),
+            "mcp_protocol_version": state.get("mcp_protocol_version"),
+            "mcp_last_error": state.get("mcp_last_error"),
+            "last_error": state.get("last_error"),
+        }
+
+    def statuses(self) -> dict[str, Any]:
+        with self.lock:
+            return {name: self.public_status(name, state) for name, state in self.states.items()}
+
+    def update(self, name: str, **updates: Any) -> None:
+        with self.lock:
+            if state := self.states.get(name):
+                state.update(updates)
+
+    def mark_session_lost(self, name: str, reason: str) -> None:
+        with self.lock:
+            state = self.states.get(name)
+            if not state:
+                return
+            state.update(
+                mcp_initialized=False,
+                mcp_session_id=None,
+                mcp_last_error=reason,
+                last_error=reason,
+                sse_reconnects=int(state.get("sse_reconnects") or 0) + 1,
+            )
+
+    def store_rpc_response(self, name: str, data_text: str) -> bool:
+        try:
+            payload = json.loads(str(data_text or "").strip())
+        except (json.JSONDecodeError, TypeError):
+            return False
+        if (
+            not isinstance(payload, dict)
+            or payload.get("id") is None
+            or ("result" not in payload and "error" not in payload)
+        ):
+            return False
+        rpc_id = str(payload["id"])
+        with self.rpc_condition:
+            with self.lock:
+                state = self.states.get(name)
+                if not state:
+                    return True
+                results = state.get("mcp_rpc_results")
+                if not isinstance(results, dict):
+                    results = {}
+                    state["mcp_rpc_results"] = results
+                results[rpc_id] = payload
+                for old_id in list(results)[: max(0, len(results) - 200)]:
+                    results.pop(old_id, None)
+            self.rpc_condition.notify_all()
+        self.log("INFO", f"channel_sse_mcp_rpc_response name={name} id={rpc_id}")
+        return True
+
+    def take_rpc_response(
+        self, name: str, rpc_id: Any, timeout: float
+    ) -> dict[str, Any] | None:
+        key = str(rpc_id)
+        deadline = self.clock() + max(0.1, timeout)
+        with self.rpc_condition:
+            while True:
+                with self.lock:
+                    state = self.states.get(name)
+                    results = state.get("mcp_rpc_results") if isinstance(state, dict) else None
+                    if isinstance(results, dict) and key in results:
+                        found = results.pop(key)
+                        return found if isinstance(found, dict) else None
+                remaining = deadline - self.clock()
+                if remaining <= 0:
+                    return None
+                self.rpc_condition.wait(min(remaining, 1.0))
+
+    @staticmethod
+    def public_mcp_name(name: str) -> str:
+        text = str(name or "").strip()
+        return text[4:] if text.startswith("mcp-") else text
+
+    def state_name_for_mcp_server(self, server_name: str) -> str | None:
+        text = str(server_name or "").strip()
+        candidates = [text, text[4:] if text.startswith("mcp-") else f"mcp-{text}"] if text else []
+        with self.lock:
+            for candidate in candidates:
+                if candidate in self.states:
+                    return candidate
+            return next(
+                (name for name in self.states if self.public_mcp_name(name) == text),
+                None,
+            )