@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/channel_message_repository.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from datetime import datetime, timezone
+import json
+from dataclasses import dataclass
+import os
+from pathlib import Path
+from typing import Any, Callable
+import time
+
+from ciel_runtime_support.channel_message_policy import string_list
+
+
+@contextmanager
+def exclusive_file_lock(path: Path):
+    """Hold a cross-platform advisory lock beside a repository artifact."""
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = path.with_name(path.name + ".lock")
+    with lock_path.open("a+b") as lock_file:
+        if os.name == "nt":
+            import msvcrt
+
+            lock_file.seek(0, os.SEEK_END)
+            if lock_file.tell() == 0:
+                lock_file.write(b"\0")
+                lock_file.flush()
+            lock_file.seek(0)
+            msvcrt.locking(lock_file.fileno(), msvcrt.LK_LOCK, 1)
+            try:
+                yield
+            finally:
+                lock_file.seek(0)
+                msvcrt.locking(lock_file.fileno(), msvcrt.LK_UNLCK, 1)
+        else:
+            import fcntl
+
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+            try:
+                yield
+            finally:
+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelMessageAppendPorts:
+    condition: Any
+    file_lock: Callable[..., Any]
+    duplicate: Callable[[dict[str, Any]], dict[str, Any] | None]
+    normalize_recipients: Callable[[Any], list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelMessageRepository:
+    path: Path
+    log: Callable[[str, str], None]
+    max_bytes: int = 10 * 1024 * 1024
+
+    def append(self, payload: dict[str, Any], ports: ChannelMessageAppendPorts) -> dict[str, Any]:
+        with ports.condition:
+            with ports.file_lock():
+                self.path.parent.mkdir(parents=True, exist_ok=True)
+                previous_max_id = self.max_id()
+                if self.path.exists() and self.path.stat().st_size > self.max_bytes:
+                    self.path.replace(self.path.with_suffix(".jsonl.1"))
+                next_id = previous_max_id + 1
+                message = {
+                    "id": next_id,
+                    "time": time.strftime("%Y-%m-%dT%H:%M:%S"),
+                    "channel": str(payload.get("channel") or "default"),
+                    "sender_id": str(payload.get("sender_id") or payload.get("sender") or "anonymous"),
+                    "recipients": ports.normalize_recipients(
+                        payload.get("recipients", payload.get("recipient_id"))
+                    ),
+                    "thread_id": str(payload.get("thread_id") or payload.get("parent_id") or next_id),
+                    "parent_id": payload.get("parent_id"),
+                    "message": str(payload.get("message") or payload.get("text") or ""),
+                    "kind": str(payload.get("kind") or "message"),
+                    "meta": payload.get("meta") if isinstance(payload.get("meta"), dict) else {},
+                }
+                if payload.get("visibility") is not None:
+                    message["visibility"] = str(payload.get("visibility") or "user")
+                if payload.get("delivery") is not None:
+                    message["delivery"] = ports.normalize_recipients(payload.get("delivery"))
+                duplicate = ports.duplicate(message)
+                if duplicate:
+                    returned = dict(duplicate)
+                    returned["_ciel_runtime_duplicate"] = True
+                    self.log(
+                        "INFO",
+                        f"chat_message_skipped_duplicate existing_id={duplicate.get('id')} "
+                        f"channel={message.get('channel')} kind={message.get('kind')}",
+                    )
+                    return returned
+                with self.path.open("a", encoding="utf-8") as stream:
+                    stream.write(json.dumps(message, ensure_ascii=False, separators=(",", ":")) + "\n")
+            ports.condition.notify_all()
+            return message
+
+    @staticmethod
+    def timestamp_seconds(item: dict[str, Any]) -> float | None:
+        raw = item.get("time") or item.get("created_at") or item.get("updated_at")
+        if not raw:
+            return None
+        if isinstance(raw, (int, float)):
+            return float(raw)
+        text = str(raw).strip()
+        if not text:
+            return None
+        try:
+            parsed = datetime.fromisoformat(text.replace("Z", "+00:00"))
+        except (TypeError, ValueError):
+            return None
+        if parsed.tzinfo is None:
+            parsed = parsed.replace(tzinfo=timezone.utc)
+        return parsed.timestamp()
+
+    def _jsonl_items(self, operation: str) -> list[dict[str, Any]]:
+        if not self.path.exists():
+            return []
+        items: list[dict[str, Any]] = []
+        try:
+            with self.path.open("r", encoding="utf-8") as stream:
+                for line in stream:
+                    try:
+                        item = json.loads(line)
+                    except (json.JSONDecodeError, TypeError):
+                        continue
+                    if isinstance(item, dict):
+                        items.append(item)
+        except OSError as exc:
+            self.log(
+                "WARN",
+                f"chat {operation} failed error={type(exc).__name__}: {exc}",
+            )
+        return items
+
+    def max_id(self) -> int:
+        max_id = 0
+        for item in self._jsonl_items("max id scan"):
+            try:
+                max_id = max(max_id, int(item.get("id") or 0))
+            except (TypeError, ValueError):
+                continue
+        return max_id
+
+    def max_id_before_epoch(self, cutoff_epoch: float) -> int:
+        max_id = 0
+        for item in self._jsonl_items("cutoff scan"):
+            try:
+                item_id = int(item.get("id") or 0)
+            except (TypeError, ValueError):
+                continue
+            if item_id <= 0:
+                continue
+            item_epoch = self.timestamp_seconds(item)
+            if item_epoch is not None and item_epoch < cutoff_epoch:
+                max_id = max(max_id, item_id)
+        return max_id
+
+    @staticmethod
+    def _visible_to(message: dict[str, Any], recipient: str | None) -> bool:
+        if not recipient:
+            return True
+        recipients = string_list(message.get("recipients"))
+        if not recipients or "all" in [value.lower() for value in recipients] or "*" in recipients:
+            return True
+        return recipient in recipients or recipient == str(message.get("sender_id") or "")
+
+    @classmethod
+    def _matches(
+        cls,
+        message: dict[str, Any],
+        channel: str | None,
+        recipient: str | None,
+    ) -> bool:
+        if channel:
+            meta = message.get("meta") if isinstance(message.get("meta"), dict) else {}
+            aliases = {
+                str(message.get("channel") or ""),
+                str(meta.get("room_id") or ""),
+                str(meta.get("room") or ""),
+                str(meta.get("channel") or ""),
+            }
+            if channel not in aliases:
+                return False
+        return cls._visible_to(message, recipient)
+
+    def read(
+        self,
+        after_id: int = 0,
+        channel: str | None = None,
+        recipient: str | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        messages: list[dict[str, Any]] = []
+        for item in self._jsonl_items("read"):
+            try:
+                if int(item.get("id") or 0) <= after_id:
+                    continue
+            except (TypeError, ValueError):
+                continue
+            if self._matches(item, channel, recipient):
+                messages.append(item)
+                if len(messages) >= limit:
+                    break
+        return messages
+
+    def read_before(
+        self,
+        before_id: int = 0,
+        channel: str | None = None,
+        recipient: str | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        messages: list[dict[str, Any]] = []
+        for item in self._jsonl_items("read before"):
+            try:
+                item_id = int(item.get("id") or 0)
+            except (TypeError, ValueError):
+                continue
+            if before_id > 0 and item_id >= before_id:
+                continue
+            if self._matches(item, channel, recipient):
+                messages.append(item)
+                if len(messages) > limit:
+                    messages = messages[-limit:]
+        return messages
+
+    def recent_rows(self, limit: int) -> list[dict[str, Any]]:
+        if limit <= 0:
+            return []
+        return self._jsonl_items("duplicate scan")[-limit:]

package/ciel_runtime_support/channel_notification_projection.py

@@ -0,0 +1,217 @@
+"""Native channel notification protocol projection."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelNotificationConfig:
+    notification_method: str
+    control_kinds: frozenset[str] | set[str] | tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelNotificationPorts:
+    json_safe: Callable[[Any], Any]
+    string_list: Callable[[Any], list[str]]
+    external_provenance: Callable[[dict[str, Any]], bool]
+    wake_noise_reason: Callable[[dict[str, Any]], str | None]
+    superseded_ids: Callable[[list[dict[str, Any]]], set[str]]
+    log: Callable[[str, str], None]
+
+
+class ChannelNotificationProjection:
+    def __init__(
+        self, config: ChannelNotificationConfig, ports: ChannelNotificationPorts
+    ) -> None:
+        self.config = config
+        self.ports = ports
+
+    def meta_value(self, value: Any) -> str:
+        if value is None:
+            return ""
+        if isinstance(value, str):
+            return value
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        if isinstance(value, (int, float)):
+            return str(value)
+        return json.dumps(
+            self.ports.json_safe(value),
+            ensure_ascii=False,
+            separators=(",", ":"),
+            default=str,
+        )
+
+    def meta(self, message: dict[str, Any]) -> dict[str, str]:
+        raw_meta = message.get("meta") if isinstance(message.get("meta"), dict) else {}
+        meta: dict[str, str] = {}
+        for key, value in raw_meta.items():
+            name = str(key or "").strip()
+            if not name:
+                continue
+            meta[name] = self.meta_value(value)
+        message_recipients = (
+            self.ports.string_list(message.get("recipients"))
+            if message.get("recipients") is not None
+            else None
+        )
+        base = {
+            "ciel_runtime_message_id": message.get("id"),
+            "channel": message.get("channel") or "default",
+            "sender_id": message.get("sender_id") or "channel",
+            "thread_id": message.get("thread_id"),
+            "parent_id": message.get("parent_id"),
+            "kind": message.get("kind"),
+            "recipients": message_recipients,
+        }
+        for key, value in base.items():
+            if value is not None:
+                meta[key] = self.meta_value(value)
+        if raw_meta:
+            meta["ciel_runtime_meta_json"] = json.dumps(
+                self.ports.json_safe(raw_meta),
+                ensure_ascii=False,
+                separators=(",", ":"),
+                default=str,
+            )
+        return meta
+
+    def param_value(self, value: Any) -> Any:
+        if value is None:
+            return None
+        if isinstance(value, (str, bool, int, float)):
+            return value
+        return self.ports.json_safe(value)
+
+    def notification(self, message: dict[str, Any]) -> dict[str, Any]:
+        text = re.sub(r"\s+", " ", str(message.get("message") or "")).strip()
+        channel = str(message.get("channel") or "default")
+        sender = str(message.get("sender_id") or "channel")
+        prefix = f"[{channel}] {sender}"
+        content = f"{prefix}: {text}" if text else prefix
+        raw_meta = message.get("meta") if isinstance(message.get("meta"), dict) else {}
+        params: dict[str, Any] = {
+            "content": content,
+            "message": text,
+            "text": text,
+            "channel": channel,
+            "source": channel,
+            "sender_id": sender,
+            "meta": self.meta(message),
+        }
+        for key in ("id", "thread_id", "parent_id", "kind", "time", "recipients"):
+            if message.get(key) is not None:
+                value = (
+                    self.ports.string_list(message.get(key))
+                    if key == "recipients"
+                    else message.get(key)
+                )
+                params[key] = self.param_value(value)
+        for key in (
+            "room_id",
+            "room",
+            "recipient_id",
+            "recipient",
+            "conversation_id",
+            "dm_id",
+        ):
+            value = raw_meta.get(key)
+            if value is not None and key not in params:
+                params[key] = self.param_value(value)
+        if "room_id" not in params and channel:
+            params["room_id"] = channel
+        return {
+            "jsonrpc": "2.0",
+            "method": self.config.notification_method,
+            "params": params,
+        }
+
+    def capabilities(
+        self,
+    ) -> dict[str, Any]:
+        return {
+            "tools": {"listChanged": False},
+            "experimental": {
+                "claude/channel": {},
+            },
+        }
+
+    def skip_reason(self, message: dict[str, Any]) -> str | None:
+        visibility = str(message.get("visibility") or "user").strip().lower()
+        if visibility in {"hidden", "internal", "transport", "control", "system"}:
+            return f"visibility_{visibility}"
+        meta = message.get("meta") if isinstance(message.get("meta"), dict) else {}
+        meta_kind = (
+            str(
+                meta.get("kind")
+                or meta.get("type")
+                or meta.get("event_type")
+                or meta.get("eventType")
+                or meta.get("event")
+                or meta.get("status")
+                or ""
+            )
+            .strip()
+            .lower()
+        )
+        if meta_kind in self.config.control_kinds:
+            return meta_kind
+        recipients = {
+            item.strip().lower()
+            for item in self.ports.string_list(message.get("recipients"))
+        }
+        if "internal" in recipients:
+            return "recipient_internal"
+        delivery = self.ports.string_list(message.get("delivery"))
+        if delivery:
+            normalized_delivery = {item.strip().lower() for item in delivery}
+            if not ({"all", "*", "native", "mcp"} & normalized_delivery):
+                return "delivery_not_native"
+        wake_reason = self.ports.wake_noise_reason(message)
+        if wake_reason:
+            return wake_reason
+        if not delivery and not self.ports.external_provenance(message):
+            return "unscoped_channel_message"
+        return None
+
+    def notifications_for_messages(
+        self,
+        messages: list[dict[str, Any]],
+        session: str = "",
+    ) -> tuple[int, list[tuple[int, dict[str, Any]]]]:
+        last_id = 0
+        events: list[tuple[int, dict[str, Any]]] = []
+        superseded_ids = self.ports.superseded_ids(messages)
+        for message in messages:
+            message_id = int(message.get("id") or 0)
+            last_id = max(last_id, message_id)
+            skip_reason = self.skip_reason(message)
+            if skip_reason:
+                self.ports.log(
+                    "INFO",
+                    f"channel_mcp_skipped_noise session={session or '-'} message_id={message.get('id')} channel={message.get('channel')} reason={skip_reason}",
+                )
+                continue
+            if message_id in superseded_ids:
+                self.ports.log(
+                    "INFO",
+                    f"channel_mcp_skipped_noise session={session or '-'} message_id={message.get('id')} channel={message.get('channel')} reason=superseded_channel_notice",
+                )
+                continue
+            notification = self.notification(message)
+            events.append((last_id, notification))
+            params = (
+                notification.get("params") if isinstance(notification, dict) else {}
+            )
+            room_id = params.get("room_id") if isinstance(params, dict) else None
+            recipients = params.get("recipients") if isinstance(params, dict) else None
+            self.ports.log(
+                "INFO",
+                f"channel_mcp_notification_prepared session={session or '-'} message_id={message.get('id')} channel={message.get('channel')} room_id={room_id or '-'} recipients={self.meta_value(recipients)[:120] if recipients is not None else '-'}",
+            )
+        return last_id, events

package/ciel_runtime_support/channel_panel.py

@@ -0,0 +1,162 @@
+"""Prelaunch channel panel projection policy."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import time
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class ChannelPanelPolicy:
+    builtin_router_probe_record: Callable[..., Any]
+    channel_specs: Callable[..., Any]
+    delivery_mode: Callable[..., Any]
+    official_plugins: dict[str, str]
+    probe_record_bucket: Callable[..., Any]
+    read_probe_cache: Callable[..., Any]
+
+
+def channel_panel_rows(
+    cfg: dict[str, Any], *, policy: ChannelPanelPolicy
+) -> tuple[list[str], list[str]]:
+    OFFICIAL_CHANNEL_PLUGINS = policy.official_plugins
+    _builtin_router_probe_record = policy.builtin_router_probe_record
+    channel_probe_record_bucket = policy.probe_record_bucket
+    channel_specs = policy.channel_specs
+    read_channel_probe_cache = policy.read_probe_cache
+    channels = set(channel_specs(cfg))
+    cache = read_channel_probe_cache()
+    records = cache.get("servers") or []
+    if not any(isinstance(r, dict) and r.get("name") == "ciel-runtime-router" for r in records):
+        records = [_builtin_router_probe_record(), *records]
+    probed_at = cache.get("probed_at") or 0
+    capable_records = [r for r in records if channel_probe_record_bucket(r) == "capable"]
+    non_capable_records = [r for r in records if channel_probe_record_bucket(r) == "non_capable"]
+    inconclusive_records = [r for r in records if channel_probe_record_bucket(r) == "inconclusive"]
+    skipped_records = [r for r in records if channel_probe_record_bucket(r) == "skipped"]
+
+    rows: list[str] = []
+    values: list[str] = []
+
+    rows.append("[Auto-detected channel-capable]")
+    values.append("__heading__")
+    if capable_records:
+        for r in capable_records:
+            name = str(r.get("name") or "")
+            spec = f"server:{name}"
+            mark = "*" if spec in channels else " "
+            transport = str(r.get("transport") or "?")
+            source = str(r.get("source_path") or "")
+            if source == "<built-in>":
+                rows.append(f"{mark} {name:<14} ({transport}, built-in)")
+            else:
+                rows.append(f"{mark} {name:<14} ({transport})")
+            values.append(spec)
+    else:
+        hint = "press Re-probe now" if not probed_at else "none capable"
+        rows.append(f"  ({hint})")
+        values.append("__noop__")
+
+    if non_capable_records:
+        rows.append("[Detected but not channel-capable]")
+        values.append("__heading__")
+        for r in non_capable_records:
+            name = str(r.get("name") or "")
+            transport = str(r.get("transport") or "?")
+            reason = str(r.get("reason") or "-")
+            rows.append(f"  {name:<14} ({transport}) {reason}")
+            values.append("__noop__")
+
+    if inconclusive_records:
+        rows.append("[Probe inconclusive / selectable anyway]")
+        values.append("__heading__")
+        for r in inconclusive_records:
+            name = str(r.get("name") or "")
+            spec = f"server:{name}"
+            mark = "*" if spec in channels else " "
+            transport = str(r.get("transport") or "?")
+            reason = str(r.get("reason") or "-")
+            rows.append(f"{mark} {name:<14} ({transport}) {reason}  [select anyway]")
+            values.append(spec)
+
+    if skipped_records:
+        rows.append("[Not probed]")
+        values.append("__heading__")
+        for r in skipped_records:
+            name = str(r.get("name") or "")
+            transport = str(r.get("transport") or "?")
+            reason = str(r.get("reason") or "-")
+            rows.append(f"  {name:<14} ({transport}) {reason}")
+            values.append("__noop__")
+
+    rows.append("[Official plugins]")
+    values.append("__heading__")
+    for plugin_name, spec in OFFICIAL_CHANNEL_PLUGINS.items():
+        mark = "*" if spec in channels else " "
+        rows.append(f"{mark} {plugin_name:<10} {spec}")
+        values.append(spec)
+
+    covered: set[str] = set(OFFICIAL_CHANNEL_PLUGINS.values())
+    for r in records:
+        covered.add(f"server:{r.get('name')}")
+    custom_specs = [spec for spec in channel_specs(cfg) if spec not in covered]
+    if custom_specs:
+        rows.append("[Configured custom / imported]")
+        values.append("__heading__")
+        for spec in custom_specs:
+            rows.append(f"* {spec}")
+            values.append(spec)
+
+    rows.append("[Actions]")
+    values.append("__heading__")
+    if probed_at:
+        ts_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(probed_at))
+        rows.append(f"Re-probe now (last: {ts_str})")
+    else:
+        rows.append("Re-probe now (no cache yet)")
+    values.append("__reprobe__")
+    rows.append("+ Add custom channel...")
+    values.append("__add_custom__")
+    if channels:
+        rows.append("- Remove channel...")
+        values.append("__remove__")
+        rows.append("Clear all channels")
+        values.append("__clear__")
+    rows.append("Back")
+    values.append("back")
+    return rows, values
+
+
+def _channel_panel_first_selectable(values: list[str]) -> int:
+    for idx, value in enumerate(values):
+        if value not in ("__heading__", "__noop__"):
+            return idx
+    return 0
+
+
+def _channel_panel_step(values: list[str], start: int, delta: int) -> int:
+    if not values:
+        return 0
+    n = len(values)
+    idx = start
+    for _ in range(n):
+        idx = (idx + delta) % n
+        if values[idx] not in ("__heading__", "__noop__"):
+            return idx
+    return start
+
+
+def channel_delivery_panel_rows(
+    cfg: dict[str, Any], *, policy: ChannelPanelPolicy
+) -> tuple[list[str], list[str]]:
+    channel_delivery_mode = policy.delivery_mode
+    current = channel_delivery_mode(cfg)
+    rows = [
+        f"{'*' if current == 'llm' else ' '} llm    inject channel messages into next model request",
+        f"{'*' if current == 'native' else ' '} native Claude Code claude/channel bridge; requires Channels",
+        f"{'*' if current == 'stdin' else ' '} stdin  PTY wake proxy; terminal input fallback",
+        "Back",
+    ]
+    return rows, ["llm", "native", "stdin", "back"]
+