@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/runtime_restart.py

@@ -0,0 +1,84 @@
+"""Restart the active Ciel Runtime installation after self-update."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, MutableMapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def running_from_npm_package(path: Path, environ: MutableMapping[str, str]) -> bool:
+    if environ.get("CIEL_RUNTIME_NPM_MODE") is not None:
+        return True
+    normalized = str(path.resolve(strict=False)).replace("\\", "/")
+    return "/node_modules/@oneciel-ai/ciel-runtime/" in normalized
+
+
+def forced_upgrade_environment(environ: MutableMapping[str, str]) -> dict[str, str]:
+    result = dict(environ)
+    result.update(CI="1", NPM_CONFIG_YES="true", npm_config_yes="true")
+    result.setdefault("NPM_CONFIG_UPDATE_NOTIFIER", "false")
+    result.setdefault("npm_config_update_notifier", "false")
+    return result
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeRestartSettings:
+    argv: Sequence[str]
+    python_executable: str
+    environ: MutableMapping[str, str]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeRestartPorts:
+    current_package_root: Callable[[], Path | None]
+    global_package_root: Callable[[str], Path | None]
+    find_executable: Callable[[str], str | None]
+    execv: Callable[[str, list[str]], object]
+    call: Callable[..., int]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeRestartService:
+    settings: RuntimeRestartSettings
+    ports: RuntimeRestartPorts
+
+    def user_args(self) -> list[str]:
+        arguments = list(self.settings.argv[1:])
+        return arguments[1:] if arguments and arguments[0] == "cli" else arguments
+
+    def restart(self, npm: str, package_root: Path | None = None) -> None:
+        self.settings.environ["CIEL_RUNTIME_SKIP_SELF_UPDATE"] = "1"
+        user_args = self.user_args()
+        root = (
+            package_root
+            or self.ports.current_package_root()
+            or self.ports.global_package_root(npm)
+        )
+        package_script = root / "ciel_runtime.py" if root else None
+        if package_script and package_script.exists():
+            self.ports.execv(
+                self.settings.python_executable,
+                [self.settings.python_executable, str(package_script), "cli", *user_args],
+            )
+            return
+        launcher = self.ports.find_executable("ciel-runtime")
+        if launcher:
+            raise SystemExit(
+                self.ports.call(
+                    [launcher, *user_args], env=dict(self.settings.environ)
+                )
+            )
+        self.ports.execv(
+            self.settings.python_executable,
+            [self.settings.python_executable, *self.settings.argv],
+        )
+
+
+__all__ = [
+    "RuntimeRestartPorts",
+    "RuntimeRestartService",
+    "RuntimeRestartSettings",
+    "forced_upgrade_environment",
+    "running_from_npm_package",
+]

package/ciel_runtime_support/runtime_upgrade.py

@@ -0,0 +1,149 @@
+"""Coordinated quiet upgrades for the runtime CLI toolchain."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeUpgradeSettings:
+    runtime_version: str
+    environ: Mapping[str, str]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeUpgradeNpmPorts:
+    find_executable: Callable[[str], str | None]
+    latest_version: Callable[[str, str], str]
+    version_newer: Callable[[str, str], bool]
+    current_package_root: Callable[[], Path | None]
+    package_prefix: Callable[[Path], Path | None]
+    current_prefix: Callable[[], Path | None]
+    global_install_command: Callable[[str, str, Path | None], list[str]]
+    runtime_install_command: Callable[[str | None, str, Path | None], list[str]]
+    run_command: Callable[[list[str], float], tuple[int, str]]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeUpgradeToolPorts:
+    claude_version: Callable[[str], str]
+    codex_version: Callable[[str], str]
+    install_claude: Callable[[], str | None]
+    install_codex: Callable[[], str | None]
+    install_agy: Callable[[], str | None]
+    update_agy: Callable[[str, bool], str]
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeUpgradeService:
+    settings: RuntimeUpgradeSettings
+    npm: RuntimeUpgradeNpmPorts
+    tools: RuntimeUpgradeToolPorts
+    output: Callable[[str], None]
+
+    def ciel_runtime(self) -> int:
+        npm = self.npm.find_executable("npm")
+        if not npm:
+            self.output("Ciel Runtime update skipped: npm was not found.")
+            return 1
+        package_spec = "@oneciel-ai/ciel-runtime@latest"
+        latest = self.npm.latest_version(npm, package_spec)
+        if latest and not self.npm.version_newer(
+            latest, self.settings.runtime_version
+        ):
+            self.output(
+                f"Ciel Runtime is up to date ({self.settings.runtime_version})."
+            )
+            return 0
+        self.output(f"Updating Ciel Runtime to {latest or 'latest'}...")
+        package_root = self.npm.current_package_root()
+        install_prefix = self.npm.package_prefix(package_root) if package_root else None
+        if install_prefix is not None:
+            self.output(f"Updating current Ciel Runtime install prefix: {install_prefix}")
+        return self._run_install(
+            self.npm.global_install_command(npm, package_spec, install_prefix),
+            "Ciel Runtime",
+            install_prefix,
+        )
+
+    def claude(self) -> int:
+        claude = self.npm.find_executable("claude")
+        if not claude:
+            return 0 if self.tools.install_claude() else 1
+        current = self.tools.claude_version(claude)
+        npm = self.npm.find_executable("npm")
+        package_spec = self.settings.environ.get(
+            "CIEL_RUNTIME_CLAUDE_CODE_PACKAGE", "@anthropic-ai/claude-code@latest"
+        )
+        latest = self.npm.latest_version(npm, package_spec) if npm else ""
+        if current and latest and not self.npm.version_newer(latest, current):
+            self.output(f"Claude Code is up to date ({current}).")
+            return 0
+        self.output(f"Updating Claude Code ({current or 'unknown'} -> {latest or 'latest'})...")
+        install_prefix = self.npm.current_prefix()
+        if install_prefix is not None:
+            self.output(f"Updating Claude Code in active npm prefix: {install_prefix}")
+        return self._run_install(
+            self.npm.runtime_install_command(npm, package_spec, install_prefix),
+            "Claude Code",
+        )
+
+    def codex(self) -> int:
+        codex = self.npm.find_executable("codex")
+        if not codex:
+            return 0 if self.tools.install_codex() else 1
+        current = self.tools.codex_version(codex)
+        npm = self.npm.find_executable("npm")
+        if not npm:
+            self.output("Codex update skipped: npm was not found.")
+            return 1
+        package_spec = self.settings.environ.get(
+            "CIEL_RUNTIME_CODEX_PACKAGE", "@openai/codex@latest"
+        )
+        latest = self.npm.latest_version(npm, package_spec)
+        if current and latest and not self.npm.version_newer(latest, current):
+            self.output(f"Codex is up to date ({current}).")
+            return 0
+        self.output(f"Updating Codex ({current or 'unknown'} -> {latest or 'latest'})...")
+        install_prefix = self.npm.current_prefix()
+        if install_prefix is not None:
+            self.output(f"Updating Codex in active npm prefix: {install_prefix}")
+        return self._run_install(
+            self.npm.runtime_install_command(npm, package_spec, install_prefix),
+            "Codex",
+        )
+
+    def agy(self) -> int:
+        agy = self.npm.find_executable("agy")
+        if not agy:
+            return 0 if self.tools.install_agy() else 1
+        return 0 if self.tools.update_agy(agy, True) else 1
+
+    def _run_install(
+        self,
+        command: list[str],
+        label: str,
+        install_prefix: Path | None = None,
+    ) -> int:
+        return_code, output = self.npm.run_command(command, 300.0)
+        if output:
+            self.output(output)
+        if return_code != 0:
+            self.output(f"{label} update failed ({return_code}).")
+            if install_prefix is not None:
+                self.output(
+                    f"Update targeted the active install prefix ({install_prefix}). "
+                    "If this prefix is not writable, reinstall or update with the "
+                    "permissions used for that prefix."
+                )
+        return return_code
+
+
+__all__ = [
+    "RuntimeUpgradeNpmPorts",
+    "RuntimeUpgradeService",
+    "RuntimeUpgradeSettings",
+    "RuntimeUpgradeToolPorts",
+]

package/ciel_runtime_support/secure_json_repository.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import os
+from pathlib import Path
+import time
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class SecureJsonEffects:
+    log: Callable[[str, str], None]
+    chmod: Callable[[Path, int], None] = os.chmod
+    process_id: Callable[[], int] = os.getpid
+    time_ns: Callable[[], int] = time.time_ns
+
+
+@dataclass(frozen=True)
+class SecureJsonRepository:
+    path: Path
+    effects: SecureJsonEffects
+
+    def load(self, purpose: str) -> dict[str, Any] | None:
+        if not self.path.exists():
+            return {}
+        try:
+            value = json.loads(self.path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, json.JSONDecodeError, TypeError) as exc:
+            self.effects.log(
+                "WARN",
+                f"secure_json_read_failed purpose={purpose} path={self.path} "
+                f"error={type(exc).__name__}: {exc}",
+            )
+            return None
+        return value if isinstance(value, dict) else {}
+
+    def save(self, value: dict[str, Any], purpose: str) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        temporary_path = self.path.with_name(
+            f"{self.path.name}.{self.effects.process_id()}.{self.effects.time_ns()}.tmp"
+        )
+        temporary_path.write_text(
+            json.dumps(value, indent=2, ensure_ascii=False) + "\n",
+            encoding="utf-8",
+        )
+        try:
+            self.effects.chmod(temporary_path, 0o600)
+        except OSError as exc:
+            self.effects.log(
+                "WARN",
+                f"secure_json_chmod_failed purpose={purpose} path={temporary_path} "
+                f"error={type(exc).__name__}: {exc}",
+            )
+        temporary_path.replace(self.path)

package/ciel_runtime_support/session_import.py

@@ -0,0 +1,356 @@
+"""Cross-runtime transcript import repository and application service."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import uuid
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from ciel_runtime_support.channel_transcript import (
+    content_text,
+    is_assistant_message,
+    user_text,
+)
+
+
+def normalize_import_source(value: str) -> str:
+    normalized = re.sub(r"[^a-z0-9]+", "", str(value or "").strip().lower())
+    if normalized in {"codex", "openai", "codexcli"}:
+        return "codex"
+    if normalized in {"claude", "claudecode", "anthropic"}:
+        return "claude"
+    return ""
+
+
+@dataclass(frozen=True, slots=True)
+class ImportSessionLimits:
+    max_bytes: int
+    max_chars: int
+
+
+class ImportSessionRepository:
+    def __init__(
+        self,
+        home: Path,
+        environment: Mapping[str, str],
+        limits: ImportSessionLimits,
+    ) -> None:
+        self.home = home
+        self.environment = environment
+        self.limits = limits
+
+    def latest(self, source: str) -> Path | None:
+        if source == "claude":
+            root, pattern = self.home / ".claude" / "projects", "*/*.jsonl"
+        elif source == "codex":
+            codex_home = Path(
+                self.environment.get("CODEX_HOME") or (self.home / ".codex")
+            ).expanduser()
+            root, pattern = codex_home / "sessions", "**/*.jsonl"
+        else:
+            return None
+        return self._latest_under(root, pattern)
+
+    @staticmethod
+    def _latest_under(root: Path, pattern: str) -> Path | None:
+        latest: Path | None = None
+        latest_mtime = -1.0
+        try:
+            paths = root.glob(pattern)
+        except (OSError, ValueError):
+            return None
+        for path in paths:
+            try:
+                mtime = path.stat().st_mtime if path.is_file() else -1.0
+            except OSError:
+                continue
+            if mtime > latest_mtime:
+                latest = path
+                latest_mtime = mtime
+        return latest
+
+    def resolve(self, source: str, path_text: str) -> tuple[Path | None, str]:
+        raw = str(path_text or "").strip()
+        if not raw:
+            latest = self.latest(source)
+            if latest is None:
+                return None, (
+                    f"No {source} transcript path was provided and no recent "
+                    f"{source} transcript was found."
+                )
+            return latest, ""
+        if re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://", raw):
+            return None, "ImportSession only reads local transcript files, not URLs."
+        path = Path(os.path.expandvars(raw)).expanduser()
+        if path.is_dir():
+            latest = self._latest_under(path, "**/*.jsonl")
+            if latest is None:
+                return None, f"No .jsonl transcript files found under {path}."
+            return latest, ""
+        if not path.exists():
+            return None, f"Transcript file not found: {path}"
+        if not path.is_file():
+            return None, f"Transcript path is not a regular file: {path}"
+        return path, ""
+
+    def read(self, source: str, path: Path) -> tuple[str, dict[str, Any]]:
+        size = path.stat().st_size
+        truncated_bytes = size > self.limits.max_bytes
+        with path.open("rb") as stream:
+            if truncated_bytes:
+                stream.seek(max(0, size - self.limits.max_bytes))
+            raw = stream.read(self.limits.max_bytes)
+        text = raw.decode("utf-8", errors="replace")
+        lines: list[str] = []
+        parsed_jsonl = False
+        for raw_line in text.splitlines():
+            try:
+                record = json.loads(raw_line.strip())
+            except (TypeError, ValueError):
+                continue
+            if not isinstance(record, dict):
+                continue
+            parsed_jsonl = True
+            line = import_record_line(record)
+            if line:
+                lines.append(line)
+        imported = "\n\n".join(lines).strip() if parsed_jsonl else text.strip()
+        truncated_chars = len(imported) > self.limits.max_chars
+        if truncated_chars:
+            imported = imported[-self.limits.max_chars :].lstrip()
+        return imported, {
+            "source": source,
+            "path": str(path),
+            "bytes": size,
+            "bytes_read": len(raw),
+            "byte_truncated": truncated_bytes,
+            "char_truncated": truncated_chars,
+            "jsonl": parsed_jsonl,
+            "records": len(lines),
+        }
+
+
+def import_tool_text(record: dict[str, Any]) -> str:
+    record_type = str(record.get("type") or "")
+    payload = record.get("payload")
+    payload_object = payload if isinstance(payload, dict) else {}
+    payload_type = str(payload_object.get("type") or "")
+    call_types = {"function_call", "custom_tool_call", "local_shell_call"}
+    result_types = {
+        "function_call_output",
+        "custom_tool_call_output",
+        "local_shell_call_output",
+    }
+    if record_type == "response_item" and payload_type in call_types:
+        name = str(
+            payload_object.get("name")
+            or payload_object.get("tool_name")
+            or payload_type
+        ).strip()
+        arguments = payload_object.get("arguments")
+        if not isinstance(arguments, str):
+            arguments = (
+                json.dumps(arguments, ensure_ascii=False, default=str)
+                if arguments is not None
+                else ""
+            )
+        return f"tool_call {name}: {arguments}".strip()
+    if record_type == "response_item" and payload_type in result_types:
+        text = content_text(
+            payload_object.get("output")
+            or payload_object.get("content")
+            or payload_object.get("message")
+        )
+        return f"tool_result: {text}".strip() if text else "tool_result"
+    message = record.get("message")
+    message_object = message if isinstance(message, dict) else {}
+    content = message_object.get("content")
+    if not isinstance(content, list):
+        return ""
+    parts: list[str] = []
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        if block.get("type") == "tool_use":
+            arguments = json.dumps(
+                block.get("input") or {}, ensure_ascii=False, default=str
+            )
+            parts.append(f"tool_call {block.get('name') or 'tool'}: {arguments}")
+        elif block.get("type") == "tool_result":
+            parts.append(f"tool_result: {content_text(block.get('content'))}".strip())
+    return "\n".join(part for part in parts if part)
+
+
+def import_record_line(record: dict[str, Any]) -> str:
+    text = user_text(record).strip()
+    if text:
+        return "User: " + text
+    if is_assistant_message(record):
+        message = record.get("message")
+        message_object = message if isinstance(message, dict) else {}
+        payload = record.get("payload")
+        payload_object = payload if isinstance(payload, dict) else {}
+        text = content_text(message_object.get("content")).strip()
+        if not text:
+            text = content_text(
+                payload_object.get("content") or payload_object.get("message")
+            ).strip()
+        if text:
+            return "Assistant: " + text
+    tool_text = import_tool_text(record).strip()
+    return "Tool: " + tool_text if tool_text else ""
+
+
+class ImportSessionService:
+    def __init__(
+        self,
+        repository: ImportSessionRepository,
+        parse_args: Callable[[dict[str, Any]], tuple[str, str]],
+    ) -> None:
+        self.repository = repository
+        self.parse_args = parse_args
+
+    def response_text(self, client_runtime: str, body: dict[str, Any]) -> str:
+        raw_source, raw_path = self.parse_args(body)
+        source = normalize_import_source(raw_source)
+        if not source:
+            return (
+                "Usage: `/ImportSession Codex [transcript-path]` or "
+                "`/ImportSession Claude [transcript-path]`."
+            )
+        if client_runtime == "claude" and source == "claude":
+            return (
+                "Claude transcript import into a Claude session is blocked. "
+                "Use Claude Code's native resume/continue flow for Claude-to-Claude "
+                "sessions. Use ImportSession for cross-runtime import, for example "
+                "`/ImportSession Codex <path>`."
+            )
+        path, error = self.repository.resolve(source, raw_path)
+        if error or path is None:
+            return f"ImportSession failed: {error}"
+        try:
+            imported, metadata = self.repository.read(source, path)
+        except (OSError, UnicodeError, ValueError) as exc:
+            return (
+                f"ImportSession failed while reading {path}: "
+                f"{type(exc).__name__}: {exc}"
+            )
+        if not imported:
+            return f"ImportSession found no importable transcript content in {path}."
+        header = self._header(client_runtime, source, path, metadata)
+        return "\n".join(
+            [
+                *header,
+                "",
+                "Imported transcript context:",
+                f'<ciel-runtime-imported-session source="{source}" path="{path}">',
+                imported,
+                "</ciel-runtime-imported-session>",
+            ]
+        )
+
+    def _header(
+        self,
+        client_runtime: str,
+        source: str,
+        path: Path,
+        metadata: dict[str, Any],
+    ) -> list[str]:
+        header = [
+            "Ciel Runtime ImportSession completed.",
+            f"- current client: {client_runtime}",
+            f"- source transcript format: {source}",
+            f"- transcript: {path}",
+            f"- parsed jsonl: {str(bool(metadata.get('jsonl'))).lower()}",
+            f"- imported records: {metadata.get('records')}",
+        ]
+        if metadata.get("byte_truncated"):
+            header.append(
+                f"- warning: read tail only: {metadata.get('bytes_read'):,}/"
+                f"{metadata.get('bytes'):,} bytes"
+            )
+        if metadata.get("char_truncated"):
+            header.append(
+                f"- warning: trimmed to last {self.repository.limits.max_chars:,} chars"
+            )
+        return header
+
+
+@dataclass(frozen=True, slots=True)
+class ImportSessionHttpPorts:
+    is_request: Callable[[dict[str, Any]], bool]
+    response_text: Callable[[str, dict[str, Any]], str]
+    load_config: Callable[[], dict[str, Any]]
+    current_alias: Callable[[dict[str, Any]], str]
+    current_provider: Callable[[dict[str, Any]], tuple[str, dict[str, Any]]]
+    estimate_tokens: Callable[[Any], int]
+    write_openai: Callable[..., Any]
+    write_anthropic: Callable[..., Any]
+    publish_event: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ImportSessionHttpController:
+    ports: ImportSessionHttpPorts
+
+    def handle(
+        self,
+        handler: Any,
+        body: dict[str, Any],
+        *,
+        client_runtime: str,
+        response_format: str = "anthropic",
+        source_body: dict[str, Any] | None = None,
+    ) -> bool:
+        if not self.ports.is_request(body):
+            return False
+        text = self.ports.response_text(client_runtime, body)
+        config = self.ports.load_config()
+        model = str(body.get("model") or self.ports.current_alias(config))
+        source = source_body or body
+        stream = bool(source.get("stream", True))
+        if response_format == "openai":
+            message = {
+                "id": f"msg_ciel_runtime_import_{uuid.uuid4().hex[:12]}",
+                "type": "message",
+                "role": "assistant",
+                "model": model,
+                "content": [{"type": "text", "text": text}],
+                "stop_reason": "end_turn",
+                "usage": {
+                    "input_tokens": 1,
+                    "output_tokens": max(1, self.ports.estimate_tokens({"text": text})),
+                },
+            }
+            self.ports.write_openai(
+                handler, message, source_body=source, stream=stream
+            )
+        else:
+            self.ports.write_anthropic(handler, model, text, stream)
+        provider = self.ports.current_provider(config)[0]
+        self.ports.publish_event(
+            level="info",
+            category="import_session.short_circuit",
+            message="ImportSession request handled locally",
+            provider=provider,
+            model=model,
+            data={"client_runtime": client_runtime},
+        )
+        return True
+
+
+__all__ = [
+    "ImportSessionHttpController",
+    "ImportSessionHttpPorts",
+    "ImportSessionLimits",
+    "ImportSessionRepository",
+    "ImportSessionService",
+    "import_record_line",
+    "import_tool_text",
+    "normalize_import_source",
+]

package/ciel_runtime_support/settings_repository.py

@@ -0,0 +1,8 @@
+from ciel_runtime_support.secure_json_repository import SecureJsonEffects, SecureJsonRepository
+
+
+SettingsFileEffects = SecureJsonEffects
+JsonSettingsRepository = SecureJsonRepository
+
+
+__all__ = ["JsonSettingsRepository", "SettingsFileEffects"]