@oneciel-ai/ciel-runtime 0.2.37 → 0.2.39

package/ciel_runtime_support/claude_session_socket.py

@@ -0,0 +1,181 @@
+"""Claude Code cross-session socket transport for admitted runtime inputs."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import posixpath
+import re
+import secrets
+import socket
+import threading
+import uuid
+from typing import Any, Callable
+
+
+SESSION_KEY_LIMIT = 4096
+TOKEN_HEX_LENGTH = 32
+
+
+def generated_socket_path(platform_name: str | None = None) -> str:
+    platform_name = platform_name or os.name
+    nonce = secrets.token_hex(16)
+    if platform_name == "nt":
+        return rf"\\.\pipe\LOCAL\cc-msg-{nonce}"
+    uid = os.getuid() if hasattr(os, "getuid") else 0
+    temp_root = os.environ.get("TMPDIR") or "/tmp"
+    if not temp_root.startswith("/"):
+        temp_root = "/tmp"
+    return posixpath.join(temp_root, f"cc-socks-{uid}", f"ciel-{nonce}.sock")
+
+
+def canonical_socket_path(path: str, platform_name: str | None = None) -> str:
+    if (platform_name or os.name) == "nt":
+        match = re.fullmatch(
+            r"[\\/]{2}[.?][\\/]pipe[\\/](?:(LOCAL)[\\/])?([^\\/]+)",
+            path,
+            flags=re.IGNORECASE,
+        )
+        if match is None:
+            return path
+        local_prefix = "LOCAL\\" if match.group(1) else ""
+        canonical = rf"\\.\pipe\{local_prefix}{match.group(2)}"
+        return re.sub(r"[A-Z]", lambda value: value.group(0).lower(), canonical)
+    return str(Path(path).expanduser().resolve(strict=False))
+
+
+def session_key_hash(path: str, platform_name: str | None = None) -> str:
+    canonical = canonical_socket_path(path, platform_name)
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def prepared_socket_path(config: dict[str, Any], passthrough: list[str]) -> str:
+    for index, value in enumerate(passthrough):
+        if value == "--messaging-socket-path" and index + 1 < len(passthrough):
+            return str(passthrough[index + 1])
+        text = str(value)
+        if text.startswith("--messaging-socket-path="):
+            return text.partition("=")[2]
+    claude_config = config.get("claude_code") if isinstance(config, dict) else {}
+    if isinstance(claude_config, dict) and claude_config.get("session_socket_input") is False:
+        return ""
+    return generated_socket_path()
+
+
+class ClaudeSessionSocketClient:
+    def __init__(
+        self,
+        home: Path,
+        log: Callable[[str, str], None],
+        *,
+        platform_name: str | None = None,
+    ) -> None:
+        self._home = home
+        self._log = log
+        self._platform_name = platform_name or os.name
+        self._target = ""
+        self._lock = threading.Lock()
+
+    @property
+    def target(self) -> str:
+        with self._lock:
+            return self._target
+
+    def configure(self, path: str | None) -> None:
+        target = str(path or "").strip()
+        with self._lock:
+            self._target = target
+        self._log(
+            "INFO",
+            "claude_session_socket_%s%s"
+            % ("configured" if target else "cleared", f" target={target}" if target else ""),
+        )
+
+    def available(self) -> bool:
+        return bool(self.target)
+
+    def send(self, prompt: str, _messages: list[dict[str, Any]] | None = None) -> bool:
+        target = self.target
+        if not target:
+            self._log("INFO", "claude_session_socket_deferred reason=target_unconfigured")
+            return False
+        token = self._read_peer_token(target)
+        if not token:
+            self._log("INFO", "claude_session_socket_deferred reason=auth_key_unavailable")
+            return False
+        frames = (
+            json.dumps({"type": "auth", "token": token}, separators=(",", ":"))
+            + "\n"
+            + json.dumps(
+                {
+                    "type": "user",
+                    "uuid": str(uuid.uuid4()),
+                    "message": {"role": "user", "content": prompt},
+                    "priority": "next",
+                },
+                ensure_ascii=False,
+                separators=(",", ":"),
+            )
+            + "\n"
+        ).encode("utf-8")
+        try:
+            self._write(target, frames)
+        except OSError as exc:
+            self._log(
+                "INFO",
+                f"claude_session_socket_deferred reason=connect_failed error={type(exc).__name__}: {exc}",
+            )
+            return False
+        self._log(
+            "INFO",
+            f"claude_session_socket_injected bytes={len(frames)} target={target}",
+        )
+        return True
+
+    def _read_peer_token(self, target: str) -> str:
+        digest = session_key_hash(target, self._platform_name)
+        directory = self._home / ".claude" / "sessions"
+        try:
+            candidates = sorted(
+                directory.glob(f"*.{digest}.key"),
+                key=lambda item: item.stat().st_mtime_ns,
+                reverse=True,
+            )
+        except OSError:
+            return ""
+        for path in candidates:
+            try:
+                if path.stat().st_size > SESSION_KEY_LIMIT:
+                    continue
+                payload = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+                continue
+            token = str(payload.get("peerToken") or "") if isinstance(payload, dict) else ""
+            if len(token) == TOKEN_HEX_LENGTH and all(char in "0123456789abcdefABCDEF" for char in token):
+                return token
+        return ""
+
+    def _write(self, target: str, frames: bytes) -> None:
+        if self._platform_name == "nt":
+            with open(target, "wb", buffering=0) as stream:
+                stream.write(frames)
+            return
+        client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        try:
+            client.settimeout(2.0)
+            client.connect(target)
+            client.sendall(frames)
+            client.shutdown(socket.SHUT_WR)
+        finally:
+            client.close()
+
+
+__all__ = [
+    "ClaudeSessionSocketClient",
+    "canonical_socket_path",
+    "generated_socket_path",
+    "prepared_socket_path",
+    "session_key_hash",
+]

package/ciel_runtime_support/cli_application_context.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import argparse
 from dataclasses import dataclass
-from typing import Any, Callable, Sequence
+from typing import Any, Callable, Mapping, Sequence
 
 
 @dataclass(frozen=True, slots=True)
@@ -17,8 +17,7 @@ class CliApplicationDispatchPorts:
     launch_agy: Callable[[list[str]], int]
     launch_kimi: Callable[[list[str]], int]
     kimi_login: Callable[[], int]
-    launch_grok: Callable[[list[str]], int] = lambda _argv: 127
-    launch_zcode: Callable[[list[str]], int] = lambda _argv: 127
+    extra_launchers: Mapping[str, Callable[[list[str]], int]]
 
 
 @dataclass(frozen=True, slots=True)
@@ -59,10 +58,13 @@ class CliApplicationContext:
         raise SystemExit(self.dispatch.launch_agy(args.argv))
 
     def cmd_launch_grok(self, args: argparse.Namespace) -> None:
-        raise SystemExit(self.dispatch.launch_grok(args.argv))
+        raise SystemExit(self.dispatch.extra_launchers["grok"](args.argv))
 
     def cmd_launch_zcode(self, args: argparse.Namespace) -> None:
-        raise SystemExit(self.dispatch.launch_zcode(args.argv))
+        raise SystemExit(self.dispatch.extra_launchers["zcode"](args.argv))
+
+    def cmd_launch_muse(self, args: argparse.Namespace) -> None:
+        raise SystemExit(self.dispatch.extra_launchers["muse"](args.argv))
 
     def cmd_version(self, _: argparse.Namespace) -> None:
         self.presentation.output(f"ciel-runtime {self.presentation.version}")
@@ -85,11 +87,14 @@ class CliApplicationContext:
             "kimi": self.dispatch.launch_kimi,
             "kimi-code": self.dispatch.launch_kimi,
             "launch-kimi": self.dispatch.launch_kimi,
-            "grok": self.dispatch.launch_grok,
-            "grok-build": self.dispatch.launch_grok,
-            "launch-grok": self.dispatch.launch_grok,
-            "zcode": self.dispatch.launch_zcode,
-            "launch-zcode": self.dispatch.launch_zcode,
+            "grok": self.dispatch.extra_launchers["grok"],
+            "grok-build": self.dispatch.extra_launchers["grok"],
+            "launch-grok": self.dispatch.extra_launchers["grok"],
+            "zcode": self.dispatch.extra_launchers["zcode"],
+            "launch-zcode": self.dispatch.extra_launchers["zcode"],
+            "muse": self.dispatch.extra_launchers["muse"],
+            "muse-code": self.dispatch.extra_launchers["muse"],
+            "launch-muse": self.dispatch.extra_launchers["muse"],
         }
         if len(arguments) >= 2 and arguments[1] in routes:
             raise SystemExit(routes[arguments[1]](arguments[2:]))
@@ -133,6 +138,9 @@ class CliApplicationCompatibilityApi:
     def cmd_launch_zcode(self, args: argparse.Namespace) -> None:
         self.context().cmd_launch_zcode(args)
 
+    def cmd_launch_muse(self, args: argparse.Namespace) -> None:
+        self.context().cmd_launch_muse(args)
+
     def cmd_version(self, args: argparse.Namespace) -> None:
         self.context().cmd_version(args)
 

package/ciel_runtime_support/cli_dispatch.py

@@ -35,6 +35,7 @@ class CliRuntime:
     native_codex_enabled: Any
     launch_grok: Any = lambda *_args, **_kwargs: 127
     launch_zcode: Any = lambda *_args, **_kwargs: 127
+    launch_muse: Any = lambda *_args, **_kwargs: 127
 
 
 @dataclass(frozen=True)
@@ -123,6 +124,7 @@ def dispatch_cli(argv: list[str], services: CliServices) -> int:
     launch_codex_app_server = services.runtime.launch_codex_app_server
     launch_grok = services.runtime.launch_grok
     launch_zcode = services.runtime.launch_zcode
+    launch_muse = services.runtime.launch_muse
     load_config = services.core.load_config
     native_agy_enabled = services.runtime.native_agy_enabled
     native_codex_enabled = services.runtime.native_codex_enabled
@@ -148,6 +150,8 @@ def dispatch_cli(argv: list[str], services: CliServices) -> int:
             return launch_grok(rest)
         if head in ("zcode", "launch-zcode"):
             return launch_zcode(rest)
+        if head in ("muse", "muse-code", "launch-muse"):
+            return launch_muse(rest)
         if head in ("version", "--version", "-v"):
             print(f"ciel-runtime {VERSION}")
             return 0
@@ -278,6 +282,8 @@ def dispatch_cli(argv: list[str], services: CliServices) -> int:
                 return launch_codex(argv)
             if runtime == "agy":
                 return launch_agy(argv)
+            if runtime == "muse":
+                return launch_muse(argv)
         if codex_passthrough_has_command(argv):
             cfg = load_config()
             provider, _ = get_current_provider(cfg)
@@ -324,8 +330,10 @@ def dispatch_cli(argv: list[str], services: CliServices) -> int:
             runtime = str(value or "").strip().lower()
             if runtime in ("codex-app", "codex-appserver"):
                 runtime = "codex-app-server"
-            if runtime not in ("claude", "codex", "codex-app-server", "agy", "grok", "zcode", "last"):
-                raise SystemExit("--ca-runtime must be claude, codex, codex-app-server, agy, grok, zcode, or last")
+            if runtime in ("muse-code", "musecode"):
+                runtime = "muse"
+            if runtime not in ("claude", "codex", "codex-app-server", "agy", "grok", "zcode", "muse", "last"):
+                raise SystemExit("--ca-runtime must be claude, codex, codex-app-server, agy, grok, zcode, muse, or last")
         elif arg in ("--ca-no-launch", "--ca-configure-only", "--ca-setup-only"):
             configure_only = True
             skip_menu = True
@@ -696,7 +704,7 @@ def dispatch_cli(argv: list[str], services: CliServices) -> int:
         return 0
     if runtime == "last":
         remembered_runtime = str(last_launch_runtime() or "").strip().lower()
-        runtime = remembered_runtime if remembered_runtime in {"claude", "codex", "agy", "grok", "zcode"} else "claude"
+        runtime = remembered_runtime if remembered_runtime in {"claude", "codex", "agy", "grok", "zcode", "muse"} else "claude"
     if runtime == "agy":
         return launch_agy(
             passthrough,
@@ -737,6 +745,14 @@ def dispatch_cli(argv: list[str], services: CliServices) -> int:
             update_check=update_check,
             self_update_check=self_update_check,
         )
+    if runtime == "muse":
+        return launch_muse(
+            passthrough,
+            skip_menu=skip_menu,
+            force_menu=force_menu,
+            update_check=update_check,
+            self_update_check=self_update_check,
+        )
     return launch_claude(
         passthrough,
         skip_menu=skip_menu,

package/ciel_runtime_support/cli_parser.py

@@ -18,6 +18,7 @@ class CliParserLaunch:
     remote_bridge: CliHandler
     launch_grok: CliHandler = lambda _args: None
     launch_zcode: CliHandler = lambda _args: None
+    launch_muse: CliHandler = lambda _args: None
 
 
 @dataclass(frozen=True)
@@ -87,6 +88,7 @@ def build_cli_parser(services: CliParserServices) -> argparse.ArgumentParser:
     _add_remainder_command(commands, "launch-agy", services.launch.launch_agy)
     _add_remainder_command(commands, "launch-grok", services.launch.launch_grok)
     _add_remainder_command(commands, "launch-zcode", services.launch.launch_zcode)
+    _add_remainder_command(commands, "launch-muse", services.launch.launch_muse)
     commands.add_parser("serve").set_defaults(func=services.launch.serve)
     bridge = commands.add_parser("bridge")
     bridge.add_argument(

package/ciel_runtime_support/cli_usage.py

@@ -8,6 +8,7 @@ def cli_usage_text() -> str:
   ciel-runtime agy [args...]           Launch Google Antigravity CLI through ciel-runtime
   ciel-runtime grok [args...]          Launch the official Grok Build CLI
   ciel-runtime zcode [args...]         Launch ZCode through ciel-runtime router
+  ciel-runtime muse [args...]          Launch Muse Code with its subscription login
   ciel-runtime resume                  Resume Codex/AGY when that runtime provider is selected
 
 Control plane, runs before Claude Code and does not require LLM connectivity:
@@ -45,8 +46,8 @@ Headless setup flags, namespaced to avoid Claude CLI collisions:
                                       Publish localhost through Tailscale Serve HTTPS
   ciel-runtime --ca-provider PROVIDER  Set provider, then launch
   ciel-runtime --ca-env-file PATH      Load CIEL_RUNTIME_* values from a .env file
-  ciel-runtime --ca-runtime claude|codex|codex-app-server|agy|grok|zcode
-                                      Select Claude Code, Codex, Codex app-server, AGY, or Grok Build
+  ciel-runtime --ca-runtime claude|codex|codex-app-server|agy|grok|zcode|muse
+                                      Select Claude Code, Codex, Codex app-server, AGY, Grok Build, ZCode, or Muse Code
   ciel-runtime --ca-menu               Apply setup values, then open the menu
   ciel-runtime --ca-language en|ko|ja|zh
   ciel-runtime --ca-base-url URL       Set current provider base URL, then launch

package/ciel_runtime_support/codex_backend_context.py

@@ -236,16 +236,19 @@ class CodexBackendContext:
         provider: str,
         pcfg: dict[str, Any],
         body: dict[str, Any],
+        protocol: str | None = None,
     ) -> dict[str, Any]:
         return self.provider_projection.apply_request_policy(
-            provider, pcfg, dict(body)
+            provider, pcfg, dict(body), protocol
         )
 
     def chat_passthrough(self) -> OpenAIChatPassthrough:
         return OpenAIChatPassthrough(
             OpenAIChatPassthroughPorts(
                 normalize_model=self.normalize_model,
-                normalize_request=self.normalize_request,
+                normalize_request=lambda provider, pcfg, body: self.normalize_request(
+                    provider, pcfg, body, "openai_chat"
+                ),
                 upstream_base=self.provider_transport.upstream_base,
                 join_url=self.provider_transport.join_url,
                 headers=self.provider_projection.chat_headers,
@@ -266,7 +269,9 @@ class CodexBackendContext:
                 project_channel_context=self.project_channel_context,
                 begin_channel_delivery=self.channel.begin_delivery,
                 normalize_model=self.normalize_model,
-                normalize_request=self.normalize_request,
+                normalize_request=lambda provider, pcfg, body: self.normalize_request(
+                    provider, pcfg, body, "openai_responses"
+                ),
                 upstream_base=self.provider_transport.upstream_base,
                 join_url=self.provider_transport.join_url,
                 headers=self.provider_projection.responses_headers,

package/ciel_runtime_support/codex_completion_gate.py

@@ -0,0 +1,198 @@
+"""Language-independent completion validation for Responses agent turns."""
+
+from __future__ import annotations
+
+import copy
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+from .codex_turn_recovery import (
+    CODEX_COMPLETION_TOOL_NAME,
+    CODEX_STRICT_CONTINUATION_NUDGE,
+)
+
+
+_MAX_SSE_EVENT_BYTES = 8 * 1024 * 1024
+
+
+def _event_payload(block: bytes) -> dict[str, Any] | None:
+    data = b"\n".join(
+        line[5:].lstrip()
+        for line in block.splitlines()
+        if line.startswith(b"data:")
+    )
+    if not data or data == b"[DONE]":
+        return None
+    try:
+        decoded = json.loads(data)
+    except (UnicodeDecodeError, ValueError):
+        return None
+    return decoded if isinstance(decoded, dict) else None
+
+
+def _message_text(item: dict[str, Any]) -> str:
+    if item.get("type") != "message":
+        return ""
+    parts: list[str] = []
+    for part in item.get("content") or []:
+        if not isinstance(part, dict):
+            continue
+        if part.get("type") not in {"output_text", "text", "refusal"}:
+            continue
+        value = part.get("text") or part.get("refusal")
+        if isinstance(value, str):
+            parts.append(value)
+    return "\n".join(parts)
+
+
+@dataclass(slots=True)
+class ResponsesCompletionObservation:
+    """Incrementally retain only terminal Responses protocol state."""
+
+    response_id: str = ""
+    status: str = ""
+    output: list[dict[str, Any]] = field(default_factory=list)
+    parseable: bool = True
+    _pending: bytearray = field(default_factory=bytearray, repr=False)
+    _items: dict[int, dict[str, Any]] = field(default_factory=dict, repr=False)
+
+    def feed(self, chunk: bytes) -> None:
+        if not self.parseable or not chunk:
+            return
+        self._pending.extend(chunk)
+        if (
+            len(self._pending) > _MAX_SSE_EVENT_BYTES
+            and b"\n\n" not in self._pending
+            and b"\r\n\r\n" not in self._pending
+        ):
+            self.parseable = False
+            self._pending.clear()
+            return
+        while True:
+            candidates = [
+                (index, len(separator))
+                for separator in (b"\n\n", b"\r\n\r\n")
+                if (index := self._pending.find(separator)) >= 0
+            ]
+            marker, marker_size = min(candidates, default=(-1, 0))
+            if marker < 0:
+                return
+            block = bytes(self._pending[:marker])
+            del self._pending[: marker + marker_size]
+            self._accept(_event_payload(block))
+
+    def finish(self) -> None:
+        if self.parseable and self._pending:
+            self._accept(_event_payload(bytes(self._pending)))
+        self._pending.clear()
+        if not self.output and self._items:
+            self.output = [self._items[index] for index in sorted(self._items)]
+
+    def _accept(self, event: dict[str, Any] | None) -> None:
+        if not event:
+            return
+        event_type = event.get("type")
+        if event_type == "response.output_item.done":
+            item = event.get("item")
+            index = event.get("output_index")
+            if isinstance(item, dict) and isinstance(index, int):
+                self._items[index] = item
+            return
+        if event_type not in {"response.completed", "response.incomplete", "response.failed"}:
+            return
+        response = event.get("response")
+        if not isinstance(response, dict):
+            return
+        self.response_id = str(response.get("id") or "")
+        self.status = str(response.get("status") or "")
+        output = response.get("output")
+        if isinstance(output, list):
+            self.output = [item for item in output if isinstance(item, dict)]
+
+    @property
+    def has_reasoning(self) -> bool:
+        return any(item.get("type") == "reasoning" for item in self.output)
+
+    @property
+    def has_action(self) -> bool:
+        # Responses output items other than messages/reasoning are protocol-level
+        # actions or state. Treat unknown future item types conservatively as work.
+        return any(item.get("type") not in {"message", "reasoning"} for item in self.output)
+
+    @property
+    def visible_text(self) -> str:
+        return "\n".join(filter(None, (_message_text(item) for item in self.output)))
+
+    @property
+    def completion_confirmed(self) -> bool:
+        actions = [
+            item for item in self.output if item.get("type") not in {"message", "reasoning"}
+        ]
+        return bool(actions) and all(
+            item.get("name") == CODEX_COMPLETION_TOOL_NAME for item in actions
+        )
+
+
+def request_requires_completion_check(
+    body: dict[str, Any], observation: ResponsesCompletionObservation
+) -> bool:
+    """Use response structure only; never classify natural-language wording."""
+
+    return bool(
+        body.get("tools")
+        and observation.parseable
+        and observation.status == "completed"
+        and observation.has_reasoning
+        and not observation.has_action
+        and observation.visible_text.strip()
+        and observation.output
+    )
+
+
+def completion_check_body(
+    body: dict[str, Any], observation: ResponsesCompletionObservation
+) -> dict[str, Any]:
+    """Continue from a candidate final response using the official state shapes."""
+
+    projected = copy.deepcopy(body)
+    prompt = {
+        "type": "message",
+        "role": "user",
+        "content": [{"type": "input_text", "text": CODEX_STRICT_CONTINUATION_NUDGE}],
+    }
+    if projected.get("conversation"):
+        projected["input"] = [prompt]
+    elif bool(projected.get("store")) and observation.response_id:
+        projected["previous_response_id"] = observation.response_id
+        projected["input"] = [prompt]
+    else:
+        current = projected.get("input")
+        items = list(current) if isinstance(current, list) else ([current] if current else [])
+        projected["input"] = [*items, *copy.deepcopy(observation.output), prompt]
+    projected["stream"] = True
+    tools = list(projected.get("tools") or [])
+    tools.append(
+        {
+            "type": "function",
+            "name": CODEX_COMPLETION_TOOL_NAME,
+            "description": "Confirm that every action requested by the user is complete.",
+            "parameters": {
+                "type": "object",
+                "properties": {},
+                "required": [],
+                "additionalProperties": False,
+            },
+            "strict": True,
+        }
+    )
+    projected["tools"] = tools
+    projected["tool_choice"] = "required"
+    return projected
+
+
+__all__ = [
+    "ResponsesCompletionObservation",
+    "completion_check_body",
+    "request_requires_completion_check",
+]