painapple-code 1.0.0__py3-none-any.whl

painapple_code/providers/codex_app_server/launch.py

@@ -0,0 +1,202 @@
+"""Codex app-server provider — launch argv + JSON-RPC param shaping.
+
+`build_command` is trivial (`codex app-server --stdio`); the interesting part is
+turning resolved `LaunchOptions` + a canonical user message into the
+`thread/start` / `turn/start` JSON-RPC params. That shaping lives here (the
+provider owns everything CLI-shaped) so the transport driver stays pure plumbing
+— it just calls `provider.thread_start_params(...)` etc. Mixed into
+`CodexAppServerProvider`.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from painapple_code import paths
+from painapple_code.providers.base import LaunchOptions
+
+# Effort → `turn/start.effort` (ReasoningEffort) goes through capabilities'
+# effort_for_model(): the CLI's own models_cache declares each model's
+# supported reasoning levels, and the requested level is clamped to the
+# TARGET model's range — mirroring codex exec (unknown/default model → the
+# range every listed model speaks; no cache → the low/medium/high triad).
+
+# Permission value → app-server `SandboxMode` (thread/start.sandbox). The
+# app-server's native vocabulary is identical to codex exec's, so new sessions
+# (which store the native value) map to themselves; the Claude-vocabulary rows
+# are a back-compat shim for sessions created before native modes existed.
+_SANDBOX_BY_MODE = {
+    # Codex-native (identity)
+    "read-only": "read-only",
+    "workspace-write": "workspace-write",
+    "danger-full-access": "danger-full-access",
+    # Legacy Claude-vocabulary (pre-native sessions)
+    "plan": "read-only",
+    "dontAsk": "read-only",
+    "acceptEdits": "workspace-write",
+    "auto": "workspace-write",
+    "bypassPermissions": "danger-full-access",
+}
+_DEFAULT_SANDBOX = "workspace-write"
+
+
+class _LaunchMixin:
+    """Builds the app-server launch argv and the JSON-RPC turn/thread params."""
+
+    def frame_input(self, message: dict) -> dict:
+        # Never called: turns go over the JSON-RPC transport (`send_turn`), not
+        # the stdin line path. Raise so a mis-wired send fails loudly.
+        raise NotImplementedError(
+            "codex app-server turns ride the JSON-RPC transport, not stdin lines")
+
+    def build_command(self, opts: LaunchOptions) -> list[str]:
+        # Persistent JSON-RPC process over stdio. Model/effort/sandbox are NOT
+        # argv here — they ride on the thread/start + turn/start params below.
+        return [self.binary(), "app-server", "--stdio"]
+
+    # --- JSON-RPC param shaping (called by the transport) -----------------
+
+    def thread_start_params(self, opts: LaunchOptions, cwd: str) -> dict:
+        """Params for a fresh `thread/start`.
+
+        P1 sets `approvalPolicy="never"`: the sandbox alone governs what
+        model-generated commands may do, exactly like `codex exec` (which runs
+        approvals-off). Interactive approvals are a later phase.
+        """
+        params: dict = {
+            "cwd": cwd,
+            "sandbox": _SANDBOX_BY_MODE.get(opts.permission_mode or "", _DEFAULT_SANDBOX),
+            "approvalPolicy": "never",
+        }
+        model = self._wire_model(opts.model)
+        if model:
+            params["model"] = model
+        return params
+
+    def thread_resume_params(self, opts: LaunchOptions, thread_id: str, cwd: str) -> dict:
+        """Params for `thread/resume` (continue an existing thread by id)."""
+        params: dict = {"threadId": thread_id, "cwd": cwd}
+        model = self._wire_model(opts.model)
+        if model:
+            params["model"] = model
+        return params
+
+    def thread_fork_params(self, opts: LaunchOptions, fork_from_id: str, cwd: str) -> dict:
+        """Params for `thread/fork` — branch a source thread into a fresh one.
+
+        The native equivalent of Claude's `--resume <id> --fork-session`: the
+        app-server loads the source thread from disk and forks it into a new
+        *persisted* thread (no rollout-file copy). Deliberately not `ephemeral`
+        — the fork becomes the new session's thread, captured from the
+        response and resumed on subsequent turns. Sandbox/approval/model mirror
+        `thread_start_params` so the branch inherits the session's resolved
+        settings. `sandbox` and `permissions` are mutually exclusive in the
+        schema; we use `sandbox` (our native vocabulary), so `permissions` is
+        omitted.
+        """
+        params: dict = {
+            "threadId": fork_from_id,
+            "cwd": cwd,
+            "sandbox": _SANDBOX_BY_MODE.get(opts.permission_mode or "", _DEFAULT_SANDBOX),
+            "approvalPolicy": "never",
+        }
+        model = self._wire_model(opts.model)
+        if model:
+            params["model"] = model
+        return params
+
+    def turn_start_params(self, opts: LaunchOptions, thread_id: str, input_items: list) -> dict:
+        """Params for `turn/start` — the per-turn input plus effort/model."""
+        # `summary` opts in to reasoning summaries — WITHOUT it the app-server
+        # emits reasoning items with empty summary/content arrays (thinking
+        # blocks would render blank). "auto" lets the backend pick the format,
+        # matching the codex TUI's own default.
+        params: dict = {"threadId": thread_id, "input": input_items,
+                        "summary": "auto"}
+        model = self._wire_model(opts.model)
+        if opts.effort:
+            # Clamp to the range the model that will actually run supports
+            # (forwarded pick, else the conservative default-model range).
+            mapped = self.effort_for_model(opts.effort, model)
+            if mapped:
+                params["effort"] = mapped
+        if model:
+            params["model"] = model
+        return params
+
+    def build_turn_input(self, message: dict) -> list[dict]:
+        """Canonical user message → app-server `UserInput[]`.
+
+        The canonical shape (built in ws_chat) is
+        ``{"type":"user","message":{"role":"user","content": str | [blocks]}}``.
+        Text becomes a ``text`` input; base64 image blocks are materialized to
+        temp files and passed as ``localImage`` inputs.
+        """
+        content = (message or {}).get("message", {}).get("content", "")
+        items: list[dict] = []
+        if isinstance(content, str):
+            if content:
+                items.append({"type": "text", "text": content})
+            return items
+        if isinstance(content, list):
+            image_sources = []
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                if block.get("type") == "text" and block.get("text"):
+                    items.append({"type": "text", "text": block["text"]})
+                elif block.get("type") == "image":
+                    image_sources.append(block)
+            for path in self._materialize_images(image_sources):
+                items.append({"type": "localImage", "path": path})
+        return items
+
+    @staticmethod
+    def _wire_model(model: Optional[str]) -> Optional[str]:
+        """Only forward a model the app-server would accept.
+
+        The session model hierarchy defaults to a *Claude* id (which Codex would
+        reject); never forward that — let the app-server use the model configured
+        by `codex login` / config.toml. A non-Claude id is passed through.
+        """
+        if model and not model.startswith("claude"):
+            return model
+        return None
+
+    @staticmethod
+    def _materialize_images(images: Optional[list]) -> list[str]:
+        """Decode base64 image blocks to temp files; return their paths."""
+        if not images:
+            return []
+        import base64
+        import tempfile
+        import uuid
+        out_dir = paths.DATA_HOME / "tmp" / "codex-images"
+        try:
+            out_dir.mkdir(parents=True, exist_ok=True)
+        except OSError:
+            out_dir = None
+        paths: list[str] = []
+        for img in images:
+            source = img.get("source", {}) if isinstance(img, dict) else {}
+            if source.get("type") != "base64" or not source.get("data"):
+                continue
+            media_type = source.get("media_type", "image/png")
+            ext = "jpg" if "jpeg" in media_type else media_type.split("/")[-1]
+            name = f"img_{uuid.uuid4().hex[:10]}.{ext}"
+            try:
+                data = base64.b64decode(source["data"])
+                if out_dir is not None:
+                    p = out_dir / name
+                    p.write_bytes(data)
+                else:
+                    fd = tempfile.NamedTemporaryFile(
+                        prefix="codex_img_", suffix=f".{ext}", delete=False
+                    )
+                    fd.write(data)
+                    fd.close()
+                    p = fd.name
+                paths.append(str(p))
+            except (OSError, ValueError):
+                continue
+        return paths

painapple_code/providers/codex_app_server/summary.py

@@ -0,0 +1,291 @@
+"""Codex app-server provider — native rich-commit summary over JSON-RPC.
+
+The sibling `codex` exec provider summarizes a turn by copying the thread's
+rollout JSONL under a fresh id and running `codex exec resume` on the copy
+(`codex exec resume` writes in place, so it can't summarize the real thread
+without polluting it). The app-server needs no such file copy: it can
+`thread/fork` the real thread into an *ephemeral* branch — a throwaway thread
+that never persists to disk — and run one `turn/start` with a native
+`outputSchema` to get the structured sections back. No rollout copy, no temp
+schema/output files, no pollution of the user's thread.
+
+Isolation: the summary runs on its OWN short-lived `codex app-server` process
+(spawned by the shadow-git layer from `build_summary_fork`'s argv), not the
+user's live session transport — so its turn notifications never interleave with
+the user's chat stream. `drive_summary_fork` conducts that process's JSON-RPC
+conversation and returns the structured sections + token usage.
+
+On any failure it returns `(None, None)`: the turn still gets a basic shadow
+commit, just without AI sections — exactly like any other unavailable fork.
+Subclasses the exec summary mixin only to reuse `_strictify_schema` (the
+app-server's `outputSchema` runs in the same OpenAI strict mode as exec's
+`--output-schema`). Mixed into `CodexAppServerProvider`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Optional
+
+from painapple_code import paths
+from painapple_code.providers.base import SummaryForkPlan
+from painapple_code.providers.codex.summary import _SummaryMixin as _CodexExecSummaryMixin
+
+logger = logging.getLogger("painapple_code")
+
+# Per-request waits. The handshake/fork/turn acks return promptly; the turn's
+# content streams as notifications, so awaiting an ack never blocks turn-length.
+_RPC_TIMEOUT = 60.0
+# Whole-turn wait for the streamed result; the shadow-git layer also caps the
+# entire fork at 300s, so this stays under that.
+_TURN_TIMEOUT = 240.0
+
+
+class _SummaryMixin(_CodexExecSummaryMixin):
+    """Native app-server rich-commit fork — ephemeral thread/fork + outputSchema."""
+
+    def build_summary_fork(
+        self,
+        *,
+        session_id: str,
+        fork_prompt: str,
+        schema_json: str,
+        cwd: str,
+        token_profile: Optional[str] = None,
+        session_model: Optional[str] = None,
+    ) -> Optional[SummaryForkPlan]:
+        """Plan a native (transport-driven) summary — no rollout copy.
+
+        The plan's argv launches a throwaway `codex app-server`; its `payload`
+        carries what `drive_summary_fork` needs: the source thread id to fork,
+        the prompt, the (strict) output schema, an optional cheaper summary
+        model, and the cwd. Nothing is copied to disk → empty `cleanup_paths`.
+        """
+        if not session_id:
+            return None
+        try:
+            schema_obj = json.loads(self._strictify_schema(schema_json))
+        except json.JSONDecodeError:
+            return None
+        # Optional cheaper summarizer model (seam-described override);
+        # default inherits the thread's model.
+        summary_model = self.get_summary_model_override()
+        if summary_model and summary_model.startswith("claude"):
+            summary_model = None
+        return SummaryForkPlan(
+            argv=[self.binary(), "app-server", "--stdio"],
+            env=None,                       # codex uses ambient auth
+            model=summary_model or "codex (app-server)",
+            output_file=None,
+            cleanup_paths=[],               # nothing copied — that's the win
+            payload={
+                "fork_from": session_id,
+                "prompt": fork_prompt,
+                "schema": schema_obj,
+                "model": summary_model,
+                "cwd": cwd,
+            },
+        )
+
+    async def drive_summary_fork(self, proc, plan):
+        """Conduct the throwaway app-server's JSON-RPC summary conversation.
+
+        initialize → thread/fork{ephemeral} → turn/start{outputSchema} → collect
+        the final structured agentMessage + token usage. Returns
+        `(structured_data, cost)` or `(None, None)` on any failure (→ no AI
+        sections this turn). Leaves the process terminated.
+        """
+        # Lazy import keeps the transport (and its asyncio plumbing) out of the
+        # package's static-description import path — same reason `make_transport`
+        # imports it lazily.
+        from painapple_code.providers.codex_app_server.transport import (
+            _APPROVAL_DENY, _client_version, JsonRpcTransport,
+        )
+
+        payload = plan.payload or {}
+        fork_from = payload.get("fork_from")
+        if not fork_from:
+            return None, None
+
+        client = _SummaryRpcClient(proc, deny_map=_APPROVAL_DENY)
+        await client.start()
+        try:
+            await client.request("initialize", {
+                "clientInfo": {"name": "painapple-code", "version": _client_version()},
+            }, timeout=_RPC_TIMEOUT)
+            await client.notify("initialized")
+
+            fork_params = {
+                "threadId": fork_from,
+                "ephemeral": True,            # throwaway branch — never persisted
+                "cwd": payload.get("cwd") or ".",
+                "sandbox": "read-only",       # the summarizer must not touch files
+                "approvalPolicy": "never",
+            }
+            if payload.get("model"):
+                fork_params["model"] = payload["model"]
+            res = await client.request("thread/fork", fork_params, timeout=_RPC_TIMEOUT)
+            fork_id = JsonRpcTransport._thread_id_from_result(res)
+            if not fork_id:
+                return None, None
+
+            turn_params = {
+                "threadId": fork_id,
+                "input": [{"type": "text", "text": payload.get("prompt") or ""}],
+                "outputSchema": payload.get("schema"),
+                "effort": "low",              # summarization needs no deep reasoning
+            }
+            if payload.get("model"):
+                turn_params["model"] = payload["model"]
+            await client.request("turn/start", turn_params, timeout=_RPC_TIMEOUT)
+
+            structured, usage = await client.await_turn(timeout=_TURN_TIMEOUT)
+            if not isinstance(structured, dict):
+                return None, None
+            cost = {
+                "cost": 0.0,                  # app-server reports no USD cost
+                "input_tokens": (usage or {}).get("inputTokens", 0) or 0,
+                "output_tokens": (usage or {}).get("outputTokens", 0) or 0,
+            }
+            return structured, cost
+        except Exception as e:
+            logger.info(f"codex app-server summary fork failed: {e}")
+            return None, None
+        finally:
+            await client.close()
+
+
+class _SummaryRpcClient:
+    """Minimal one-shot JSON-RPC client over a throwaway app-server process.
+
+    Distinct from `JsonRpcTransport` (session-coupled, driven externally by the
+    session's stdout reader): this owns its own read loop and collects only what
+    a summary needs — the final `agentMessage` text (the structured JSON produced
+    under `outputSchema`) and the latest token usage — resolving `await_turn` on
+    `turn/completed`.
+    """
+
+    def __init__(self, proc, deny_map=None):
+        self.proc = proc
+        self._deny = deny_map or {}
+        self._id = 0
+        self._pending: dict = {}
+        self._turn = None            # future resolved on turn/completed|error|EOF
+        self._last_text = None       # last agentMessage text == the structured JSON
+        self._usage: dict = {}
+        self._reader = None
+
+    async def start(self):
+        self._reader = asyncio.create_task(self._read_loop())
+
+    def _next_id(self) -> int:
+        self._id += 1
+        return self._id
+
+    async def _write(self, obj: dict):
+        self.proc.stdin.write((json.dumps(obj) + "\n").encode("utf-8"))
+        await self.proc.stdin.drain()
+
+    async def request(self, method: str, params: dict, timeout: float = _RPC_TIMEOUT):
+        rid = self._next_id()
+        fut = asyncio.get_running_loop().create_future()
+        self._pending[rid] = fut
+        await self._write({"jsonrpc": "2.0", "id": rid, "method": method, "params": params})
+        try:
+            return await asyncio.wait_for(fut, timeout)
+        finally:
+            self._pending.pop(rid, None)
+
+    async def notify(self, method: str, params: dict | None = None):
+        msg = {"jsonrpc": "2.0", "method": method}
+        if params is not None:
+            msg["params"] = params
+        await self._write(msg)
+
+    async def await_turn(self, timeout: float = _TURN_TIMEOUT):
+        """Wait for turn/completed; return (structured_or_None, usage)."""
+        self._turn = asyncio.get_running_loop().create_future()
+        try:
+            await asyncio.wait_for(self._turn, timeout)
+        except asyncio.TimeoutError:
+            return None, self._usage
+        structured = None
+        if self._last_text:
+            try:
+                structured = json.loads(self._last_text)
+            except json.JSONDecodeError:
+                structured = None
+        return structured, self._usage
+
+    async def _read_loop(self):
+        stdout = self.proc.stdout
+        while True:
+            line = await stdout.readline()
+            if not line:                          # EOF — process exited
+                self._finish_turn()
+                return
+            try:
+                msg = json.loads(line.decode(errors="replace").strip())
+            except (json.JSONDecodeError, ValueError):
+                continue
+            self._dispatch(msg)
+
+    def _dispatch(self, msg: dict):
+        has_id = msg.get("id") is not None
+        has_method = "method" in msg
+        if has_id and has_method:                 # server → client request: decline
+            asyncio.create_task(self._decline(msg))
+            return
+        if has_id and not has_method:             # response to one of our requests
+            fut = self._pending.get(msg["id"])
+            if fut is not None and not fut.done():
+                if msg.get("error") is not None:
+                    fut.set_exception(RuntimeError(str(msg["error"])))
+                else:
+                    fut.set_result(msg.get("result"))
+            return
+        method = msg.get("method")                # notification
+        params = msg.get("params") or {}
+        if method == "item/completed":
+            item = params.get("item") or {}
+            if item.get("type") == "agentMessage" and item.get("text"):
+                self._last_text = item["text"]
+        elif method == "thread/tokenUsage/updated":
+            tu = params.get("tokenUsage") or {}
+            self._usage = tu.get("last") or self._usage
+        elif method in ("turn/completed", "error"):
+            self._finish_turn()
+
+    def _finish_turn(self):
+        if self._turn is not None and not self._turn.done():
+            self._turn.set_result(None)
+
+    async def _decline(self, msg: dict):
+        rid = msg.get("id")
+        deny = self._deny.get(msg.get("method", ""))
+        try:
+            if deny is not None:
+                await self._write({"jsonrpc": "2.0", "id": rid, "result": deny})
+            else:
+                await self._write({
+                    "jsonrpc": "2.0", "id": rid,
+                    "error": {"code": -32601, "message": "not handled"},
+                })
+        except Exception:
+            pass
+
+    async def close(self):
+        if self._reader is not None:
+            self._reader.cancel()
+            try:
+                await self._reader
+            except (asyncio.CancelledError, Exception):
+                pass
+        if self.proc.returncode is None:
+            try:
+                self.proc.kill()
+                await self.proc.wait()
+            except Exception:
+                pass