codexloop 0.1.0__py3-none-any.whl

codexloop/infrastructure/agent/argv.py

@@ -0,0 +1,102 @@
+"""Pure Codex CLI argv construction — list building only, no subprocess."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from codexloop.domain.approval import (
+    DEFAULT_APPROVAL,
+    DEFAULT_SANDBOX,
+    ApprovalPolicy,
+    SandboxMode,
+)
+from codexloop.domain.model_profile import Effort
+
+PROBE_PROMPT = "reply with the single word OK"
+
+
+def _quote_c_value(value: str) -> str:
+    """Wrap ``value`` in double quotes, escaping any internal quotes."""
+    return '"' + value.replace('"', '\\"') + '"'
+
+
+def _c_override(key: str, value: str) -> list[str]:
+    return ["-c", f"{key}={_quote_c_value(value)}"]
+
+
+@dataclass(frozen=True, slots=True)
+class ExecOpts:
+    """Options for ``codex exec`` / ``codex exec resume`` argv construction."""
+
+    prompt: str
+    model: str | None = None
+    effort: Effort | None = None
+    approval: ApprovalPolicy = DEFAULT_APPROVAL
+    sandbox: SandboxMode = DEFAULT_SANDBOX
+    add_dirs: tuple[str, ...] = ()
+    output_schema: str | None = None
+    output_last_message: str | None = None
+    skip_git_repo_check: bool = False
+
+
+def _shared_flags(opts: ExecOpts) -> list[str]:
+    """Flags common to exec and resume (after ``--json``)."""
+    argv: list[str] = []
+    if opts.model is not None:
+        argv.extend(["--model", opts.model])
+    argv.extend(_c_override("approval_policy", opts.approval.value))
+    argv.extend(_c_override("sandbox_mode", opts.sandbox.value))
+    if opts.effort is not None:
+        argv.extend(_c_override("model_reasoning_effort", opts.effort.value))
+    for directory in opts.add_dirs:
+        argv.extend(["--add-dir", directory])
+    if opts.output_schema is not None:
+        argv.extend(["--output-schema", opts.output_schema])
+    if opts.output_last_message is not None:
+        argv.extend(["--output-last-message", opts.output_last_message])
+    if opts.skip_git_repo_check:
+        argv.append("--skip-git-repo-check")
+    return argv
+
+
+def build_exec_argv(opts: ExecOpts) -> list[str]:
+    """Build ``codex exec … -- <prompt>``."""
+    argv: list[str] = ["codex", "exec", "--json"]
+    argv.extend(_shared_flags(opts))
+    argv.extend(["--", opts.prompt])
+    return argv
+
+
+def build_resume_argv(thread_id: str | None, opts: ExecOpts) -> list[str]:
+    """Build ``codex exec resume <id|--last> … -- <prompt>``.
+
+    Policy is always expressed via ``-c`` overrides — never a bare ``--sandbox``.
+    """
+    argv: list[str] = ["codex", "exec", "resume"]
+    if thread_id is None:
+        argv.append("--last")
+    else:
+        argv.append(thread_id)
+    argv.append("--json")
+    argv.extend(_shared_flags(opts))
+    argv.extend(["--", opts.prompt])
+    return argv
+
+
+def build_probe_argv(opts: ExecOpts) -> list[str]:
+    """Build the capacity-probe argv (ephemeral, read-only, fixed prompt).
+
+    ``opts`` is accepted for API symmetry with exec/resume; probe policy and
+    prompt are fixed and do not vary with ``opts``.
+    """
+    _ = opts
+    return [
+        "codex",
+        "exec",
+        "--json",
+        "--ephemeral",
+        *_c_override("approval_policy", ApprovalPolicy.NEVER.value),
+        *_c_override("sandbox_mode", SandboxMode.READ_ONLY.value),
+        "--",
+        PROBE_PROMPT,
+    ]

codexloop/infrastructure/agent/events.py

@@ -0,0 +1,274 @@
+"""Forgiving parser for ``codex exec --json`` JSONL events (R3, R4)."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from codexloop.domain.capacity import PlanWindows, RateLimitWindow
+
+_ERROR_PATHS: tuple[tuple[str, ...], ...] = (
+    ("error",),
+    ("payload", "error"),
+    ("item", "error"),
+    ("turn", "error"),
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Usage:
+    input_tokens: int | None = None
+    cached_input_tokens: int | None = None
+    output_tokens: int | None = None
+    reasoning_output_tokens: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ErrorPayload:
+    code: str | None
+    type: str | None
+    message: str | None
+    status: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class ThreadStarted:
+    thread_id: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class TurnStarted:
+    pass
+
+
+@dataclass(frozen=True, slots=True)
+class TurnCompleted:
+    usage: Usage | None
+
+
+@dataclass(frozen=True, slots=True)
+class TurnFailed:
+    error: ErrorPayload | None
+
+
+@dataclass(frozen=True, slots=True)
+class ItemStarted:
+    item: Mapping[str, object] | None
+
+
+@dataclass(frozen=True, slots=True)
+class ItemCompleted:
+    item: Mapping[str, object] | None
+
+
+@dataclass(frozen=True, slots=True)
+class RateLimitsUpdated:
+    plan_windows: PlanWindows | None
+
+
+@dataclass(frozen=True, slots=True)
+class ErrorEvent:
+    error: ErrorPayload | None
+
+
+@dataclass(frozen=True, slots=True)
+class UnknownEvent:
+    type: str
+
+
+CodexEvent = (
+    ThreadStarted
+    | TurnStarted
+    | TurnCompleted
+    | TurnFailed
+    | ItemStarted
+    | ItemCompleted
+    | RateLimitsUpdated
+    | ErrorEvent
+    | UnknownEvent
+)
+
+
+class JsonlParser:
+    """Parse one JSONL line at a time. Unknown and malformed input never raises."""
+
+    def __init__(self, *, now: datetime | None = None) -> None:
+        self._now = now
+        self.malformed_count = 0
+
+    def parse_line(self, line: str) -> CodexEvent | None:
+        stripped = line.strip()
+        if not stripped:
+            return None
+        try:
+            decoded: object = json.loads(stripped)
+        except json.JSONDecodeError:
+            self.malformed_count += 1
+            return None
+        if not isinstance(decoded, dict):
+            self.malformed_count += 1
+            return None
+        return self._parse_obj(decoded)
+
+    def _parse_obj(self, obj: dict[str, Any]) -> CodexEvent | None:
+        event_type = obj.get("type")
+        if not isinstance(event_type, str) or not event_type:
+            return None
+        match event_type:
+            case "thread.started":
+                return ThreadStarted(thread_id=_opt_str(obj.get("thread_id")))
+            case "turn.started":
+                return TurnStarted()
+            case "turn.completed":
+                return TurnCompleted(usage=_usage(obj.get("usage")))
+            case "turn.failed":
+                return TurnFailed(error=_extract_error(obj))
+            case "item.started":
+                return ItemStarted(item=_item(obj.get("item")))
+            case "item.completed":
+                return ItemCompleted(item=_item(obj.get("item")))
+            case "rate_limits.updated":
+                return RateLimitsUpdated(plan_windows=self._plan_windows(obj))
+            case "event_msg":
+                payload = obj.get("payload")
+                if isinstance(payload, Mapping) and payload.get("type") == "token_count":
+                    return RateLimitsUpdated(plan_windows=self._plan_windows(obj))
+                return UnknownEvent(type=event_type)
+            case "error":
+                return ErrorEvent(error=_extract_error(obj))
+            case _:
+                return UnknownEvent(type=event_type)
+
+    def _plan_windows(self, obj: Mapping[str, Any]) -> PlanWindows | None:
+        blob = _rate_limits_blob(obj)
+        if blob is None:
+            return None
+        if not isinstance(blob, Mapping):
+            return None
+        now = self._now if self._now is not None else datetime.now(UTC)
+        return PlanWindows(
+            primary=_window(blob.get("primary"), now=now),
+            secondary=_window(blob.get("secondary"), now=now),
+            plan_type=_opt_str(blob.get("plan_type")),
+            limit_reached=_opt_str(blob.get("rate_limit_reached_type")),
+        )
+
+
+def _rate_limits_blob(obj: Mapping[str, Any]) -> object:
+    if "rate_limits" in obj:
+        return obj["rate_limits"]
+    payload = obj.get("payload")
+    if isinstance(payload, Mapping) and "rate_limits" in payload:
+        return payload["rate_limits"]
+    return None
+
+
+def _window(value: object, *, now: datetime) -> RateLimitWindow | None:
+    if not isinstance(value, Mapping):
+        return None
+    try:
+        minutes = _opt_int(value.get("window_minutes"))
+        if minutes is None:
+            return None
+        return RateLimitWindow(
+            used_percent=_opt_float(value.get("used_percent")),
+            window_minutes=minutes,
+            resets_at=_resets_at(value, now=now),
+        )
+    except (TypeError, ValueError, OverflowError, OSError):
+        return None
+
+
+def _resets_at(window: Mapping[str, Any], *, now: datetime) -> datetime | None:
+    raw_at = window.get("resets_at")
+    if isinstance(raw_at, bool):
+        raw_at = None
+    if isinstance(raw_at, int | float):
+        try:
+            return datetime.fromtimestamp(float(raw_at), tz=UTC)
+        except (OSError, OverflowError, ValueError):
+            return None
+    raw_in = window.get("resets_in_seconds")
+    if isinstance(raw_in, bool):
+        raw_in = None
+    if isinstance(raw_in, int | float):
+        try:
+            return now + timedelta(seconds=float(raw_in))
+        except (OverflowError, ValueError):
+            return None
+    return None
+
+
+def _usage(value: object) -> Usage | None:
+    if not isinstance(value, Mapping):
+        return None
+    return Usage(
+        input_tokens=_opt_int(value.get("input_tokens")),
+        cached_input_tokens=_opt_int(value.get("cached_input_tokens")),
+        output_tokens=_opt_int(value.get("output_tokens")),
+        reasoning_output_tokens=_opt_int(value.get("reasoning_output_tokens")),
+    )
+
+
+def _item(value: object) -> dict[str, object] | None:
+    if not isinstance(value, Mapping):
+        return None
+    return dict(value)
+
+
+def _extract_error(obj: Mapping[str, Any]) -> ErrorPayload | None:
+    for path in _ERROR_PATHS:
+        found = _dig(obj, path)
+        if found is None:
+            continue
+        payload = _error_payload(found)
+        if payload is not None:
+            return payload
+    return None
+
+
+def _dig(obj: Mapping[str, Any], path: tuple[str, ...]) -> object | None:
+    current: object = obj
+    for key in path:
+        if not isinstance(current, Mapping) or key not in current:
+            return None
+        current = current[key]
+    return current
+
+
+def _error_payload(value: object) -> ErrorPayload | None:
+    if isinstance(value, str):
+        return ErrorPayload(code=None, type=None, message=value, status=None)
+    if not isinstance(value, Mapping):
+        return None
+    return ErrorPayload(
+        code=_opt_str(value.get("code")),
+        type=_opt_str(value.get("type")),
+        message=_opt_str(value.get("message")),
+        status=_opt_int(value.get("status")),
+    )
+
+
+def _opt_str(value: object) -> str | None:
+    if isinstance(value, str):
+        return value
+    return None
+
+
+def _opt_int(value: object) -> int | None:
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float) and value.is_integer():
+        return int(value)
+    return None
+
+
+def _opt_float(value: object) -> float | None:
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        return None
+    return float(value)

codexloop/infrastructure/agent/gateway.py

@@ -0,0 +1,189 @@
+"""``codex exec --json`` adapter implementing :class:`AgentGateway`."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Protocol, assert_never
+
+from codexloop.application.dto import TokenUsage, TurnOutcome
+from codexloop.application.ports import PermissionMode
+from codexloop.domain.approval import ApprovalPolicy, SandboxMode
+from codexloop.domain.model_profile import ModelEffortProfile
+from codexloop.infrastructure.agent.argv import ExecOpts, build_exec_argv, build_resume_argv
+from codexloop.infrastructure.agent.events import CodexEvent, JsonlParser, ThreadStarted, Usage
+from codexloop.infrastructure.agent.process import ProcessResult
+from codexloop.infrastructure.agent.process import run_codex as default_run_codex
+from codexloop.infrastructure.agent.schema import write_output_schema
+from codexloop.infrastructure.agent.translate import to_turn_signals
+
+_DEFAULT_TIMEOUT_S = 300.0
+_DEFAULT_MAX_LINE_BYTES = 1_048_576
+
+
+class RunCodex(Protocol):
+    async def __call__(
+        self,
+        argv: Sequence[str],
+        *,
+        cwd: str | Path,
+        env: Mapping[str, str],
+        timeout: float,
+        max_line_bytes: int,
+    ) -> ProcessResult: ...
+
+
+class CodexExecGateway:
+    """One-shot ``codex exec`` / ``codex exec resume <thread_id>`` session.
+
+    Records ``thread_id`` from the first ``thread.started`` event and resumes by
+    that id thereafter — never ``--last``.
+    """
+
+    def __init__(
+        self,
+        *,
+        cwd: str | Path,
+        env: Mapping[str, str] | None = None,
+        opts: ExecOpts | None = None,
+        now: datetime | None = None,
+        run_codex: RunCodex | None = None,
+        timeout: float = _DEFAULT_TIMEOUT_S,
+        max_line_bytes: int = _DEFAULT_MAX_LINE_BYTES,
+    ) -> None:
+        self._cwd = Path(cwd)
+        self._env = dict(env) if env is not None else None
+        self._opts = opts if opts is not None else ExecOpts(prompt="")
+        self._now = now
+        self._run_codex = run_codex if run_codex is not None else default_run_codex
+        self._timeout = timeout
+        self._max_line_bytes = max_line_bytes
+        self._thread_id: str | None = None
+        self._closed = False
+
+    async def send_turn(self, prompt: str) -> TurnOutcome:
+        control = self._cwd / ".codexloop"
+        control.mkdir(parents=True, exist_ok=True)
+        schema_path = write_output_schema(control / "completion.schema.json")
+        last_message_path = control / "last-message.json"
+        if last_message_path.exists():
+            last_message_path.unlink()
+        opts = replace(
+            self._opts,
+            prompt=prompt,
+            output_schema=str(schema_path),
+            output_last_message=str(last_message_path),
+        )
+        if self._thread_id is None:
+            argv = build_exec_argv(opts)
+        else:
+            argv = build_resume_argv(self._thread_id, opts)
+        env = self._env if self._env is not None else os.environ.copy()
+        result = await self._run_codex(
+            argv,
+            cwd=self._cwd,
+            env=env,
+            timeout=self._timeout,
+            max_line_bytes=self._max_line_bytes,
+        )
+        events = self._parse_lines(result.stdout_lines)
+        self._record_thread_id(events)
+        signals = to_turn_signals(
+            events,
+            exit_code=result.exit_code,
+            stderr_tail=result.stderr_tail,
+            now=self._now if self._now is not None else datetime.now(UTC),
+        )
+        structured = _read_structured(last_message_path)
+        if structured is not None:
+            signals = replace(signals, structured_output=structured)
+        return TurnOutcome(
+            signals=signals,
+            usage=_token_usage(signals.usage),
+            exit_code=result.exit_code,
+            thread_id=self._thread_id,
+        )
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+
+    async def set_profile(self, profile: ModelEffortProfile) -> None:
+        self._opts = replace(self._opts, model=profile.model, effort=profile.effort)
+
+    async def set_permission_mode(self, mode: PermissionMode) -> None:
+        match mode:
+            case PermissionMode.AUTONOMOUS:
+                approval, sandbox = ApprovalPolicy.NEVER, SandboxMode.WORKSPACE_WRITE
+            case PermissionMode.READ_ONLY:
+                approval, sandbox = ApprovalPolicy.NEVER, SandboxMode.READ_ONLY
+            case PermissionMode.FULL_ACCESS:
+                approval, sandbox = ApprovalPolicy.NEVER, SandboxMode.DANGER_FULL_ACCESS
+            case _:  # pragma: no cover — exhaustive StrEnum
+                assert_never(mode)
+        self._opts = replace(self._opts, approval=approval, sandbox=sandbox)
+
+    async def set_cwd(self, path: str) -> None:
+        self._cwd = Path(path)
+
+    async def set_session_resources(self, resources: Mapping[str, object]) -> None:
+        updates: dict[str, object] = {}
+        add_dirs = resources.get("add_dirs")
+        if isinstance(add_dirs, list | tuple) and all(isinstance(item, str) for item in add_dirs):
+            updates["add_dirs"] = tuple(add_dirs)
+        approval = resources.get("approval_policy")
+        if isinstance(approval, str):
+            updates["approval"] = ApprovalPolicy(approval)
+        sandbox = resources.get("sandbox_mode")
+        if isinstance(sandbox, str):
+            updates["sandbox"] = SandboxMode(sandbox)
+        if updates:
+            self._opts = replace(self._opts, **updates)  # type: ignore[arg-type]
+
+    def resolve_tool_approval(self, request_id: str, *, allow: bool, reason: str = "") -> bool:
+        _ = request_id, reason
+        return allow
+
+    def _parse_lines(self, lines: Sequence[str]) -> list[CodexEvent | None]:
+        parser = JsonlParser(now=self._now if self._now is not None else datetime.now(UTC))
+        return [parser.parse_line(line) for line in lines]
+
+    def _record_thread_id(self, events: Sequence[CodexEvent | None]) -> None:
+        if self._thread_id is not None:
+            return
+        for event in events:
+            if isinstance(event, ThreadStarted) and event.thread_id:
+                self._thread_id = event.thread_id
+                return
+
+
+def _read_structured(path: Path) -> object | None:
+    if not path.is_file():
+        return None
+    try:
+        text = path.read_text(encoding="utf-8").strip()
+    except OSError:
+        return None
+    if not text:
+        return None
+    try:
+        parsed: object = json.loads(text)
+    except json.JSONDecodeError:
+        return text
+    return parsed
+
+
+def _token_usage(usage: object | None) -> TokenUsage | None:
+    if not isinstance(usage, Usage):
+        return None
+    return TokenUsage(
+        input_tokens=usage.input_tokens or 0,
+        cached_input_tokens=usage.cached_input_tokens or 0,
+        output_tokens=usage.output_tokens or 0,
+        reasoning_output_tokens=usage.reasoning_output_tokens or 0,
+    )

codexloop/infrastructure/agent/probe.py

@@ -0,0 +1,74 @@
+"""Ephemeral read-only ``codex exec`` capacity probe."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping, Sequence
+from datetime import UTC, datetime
+from pathlib import Path
+
+from codexloop.application.dto import ProbeResult
+from codexloop.domain.capacity import TransientBackendError
+from codexloop.domain.classify import classify
+from codexloop.domain.errors import CodexBinaryError
+from codexloop.infrastructure.agent.argv import ExecOpts, build_probe_argv
+from codexloop.infrastructure.agent.events import CodexEvent, JsonlParser
+from codexloop.infrastructure.agent.gateway import RunCodex
+from codexloop.infrastructure.agent.process import run_codex as default_run_codex
+from codexloop.infrastructure.agent.translate import to_turn_signals
+
+_DEFAULT_TIMEOUT_S = 300.0
+_DEFAULT_MAX_LINE_BYTES = 1_048_576
+
+
+class ExecCapacityProbe:
+    """Capacity probe that never resumes and never writes a thread.
+
+    Always uses :func:`build_probe_argv` (``--ephemeral``, read-only sandbox).
+    Spawn failures become :class:`TransientBackendError` rather than raising.
+    """
+
+    def __init__(
+        self,
+        *,
+        cwd: str | Path,
+        env: Mapping[str, str] | None = None,
+        opts: ExecOpts | None = None,
+        now: datetime | None = None,
+        run_codex: RunCodex | None = None,
+        timeout: float = _DEFAULT_TIMEOUT_S,
+        max_line_bytes: int = _DEFAULT_MAX_LINE_BYTES,
+    ) -> None:
+        self._cwd = Path(cwd)
+        self._env = dict(env) if env is not None else None
+        self._opts = opts if opts is not None else ExecOpts(prompt="")
+        self._now = now
+        self._run_codex = run_codex if run_codex is not None else default_run_codex
+        self._timeout = timeout
+        self._max_line_bytes = max_line_bytes
+
+    async def probe(self) -> ProbeResult:
+        argv = build_probe_argv(self._opts)
+        env = self._env if self._env is not None else os.environ.copy()
+        try:
+            result = await self._run_codex(
+                argv,
+                cwd=self._cwd,
+                env=env,
+                timeout=self._timeout,
+                max_line_bytes=self._max_line_bytes,
+            )
+        except (OSError, CodexBinaryError):
+            return ProbeResult(outcome=TransientBackendError())
+        events = self._parse_lines(result.stdout_lines)
+        signals = to_turn_signals(
+            events,
+            exit_code=result.exit_code,
+            stderr_tail=result.stderr_tail,
+            now=self._now if self._now is not None else datetime.now(UTC),
+        )
+        return ProbeResult(outcome=classify(signals), snapshot=signals.plan_windows)
+
+    def _parse_lines(self, lines: Sequence[str]) -> list[CodexEvent | None]:
+        parser = JsonlParser(now=self._now if self._now is not None else datetime.now(UTC))
+        return [parser.parse_line(line) for line in lines]