codexloop 0.1.0__py3-none-any.whl

codexloop/infrastructure/appserver/ratelimits.py

@@ -0,0 +1,100 @@
+"""Map app-server ``account/rateLimits/read`` results onto ``PlanWindows``.
+
+Field names match the exec JSONL rate-limit blob already parsed in
+``infrastructure.agent.events`` (``primary`` / ``secondary`` / ``plan_type`` /
+``rate_limit_reached_type``, ``used_percent`` / ``window_minutes`` /
+``resets_at`` / ``resets_in_seconds``). Helpers are duplicated here so this
+package does not depend on agent internals.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from codexloop.domain.capacity import PlanWindows, RateLimitWindow
+
+
+def plan_windows_from_rpc(result: object, *, now: datetime) -> PlanWindows | None:
+    """Return ``PlanWindows`` from an RPC ``result`` payload, or ``None``."""
+    if not isinstance(result, Mapping):
+        return None
+    blob = _rate_limits_blob(result)
+    if blob is None or not isinstance(blob, Mapping):
+        return None
+    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"]
+    if any(key in obj for key in ("primary", "secondary", "plan_type", "rate_limit_reached_type")):
+        return obj
+    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):  # pragma: no cover
+        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):  # pragma: no cover
+            return None
+    return None
+
+
+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/audit.py

@@ -0,0 +1,26 @@
+"""JSONL audit log — the AuditLog port's filesystem adapter."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from datetime import UTC, datetime
+from pathlib import Path
+
+from codexloop.infrastructure.redact import redact
+
+
+class JsonlAuditLog:
+    def __init__(self, path: Path) -> None:
+        self._path = path
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+
+    def append(self, event_type: str, payload: Mapping[str, object]) -> None:
+        entry: dict[str, object] = {
+            "timestamp": datetime.now(UTC).isoformat(),
+            "event_type": event_type,
+            **dict(payload),
+        }
+        safe = redact(entry)
+        with self._path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(safe, default=str) + "\n")

codexloop/infrastructure/capacity_probe.py

@@ -0,0 +1,57 @@
+"""Layered capacity probe: app-server (B), rollout (C), exec (A)."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from inspect import isawaitable
+
+from codexloop.application.dto import ProbeResult
+from codexloop.application.ports import CapacityProbe
+from codexloop.domain.capacity import PlanWindows
+
+AppServerLimits = Callable[[], Awaitable[PlanWindows | None] | PlanWindows | None]
+RolloutLimits = Callable[[], PlanWindows | None]
+
+
+class CompositeCapacityProbe:
+    """Exec is always authoritative; B and C only enrich the snapshot."""
+
+    def __init__(
+        self,
+        exec_probe: CapacityProbe,
+        *,
+        app_server: AppServerLimits | None = None,
+        rollout: RolloutLimits | None = None,
+    ) -> None:
+        self._exec = exec_probe
+        self._app_server = app_server
+        self._rollout = rollout
+
+    async def probe(self) -> ProbeResult:
+        snapshot = await self._read_app_server()
+        if snapshot is None:
+            snapshot = self._read_rollout()
+        exec_result = await self._exec.probe()
+        return ProbeResult(outcome=exec_result.outcome, snapshot=snapshot or exec_result.snapshot)
+
+    async def _read_app_server(self) -> PlanWindows | None:
+        if self._app_server is None:
+            return None
+        try:
+            result = self._app_server()
+            if isawaitable(result):
+                return await result
+            return result
+        except Exception:
+            return None
+
+    def _read_rollout(self) -> PlanWindows | None:
+        if self._rollout is None:
+            return None
+        try:
+            return self._rollout()
+        except Exception:
+            return None
+
+
+__all__ = ["CompositeCapacityProbe"]

codexloop/infrastructure/clock.py

@@ -0,0 +1,26 @@
+"""Real Clock and Sleeper adapters. Test doubles live in tests/application/fakes.py."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+import anyio
+
+from codexloop.application.ports import Clock
+
+
+class SystemClock:
+    def now(self) -> datetime:
+        return datetime.now(UTC)
+
+
+class AnyioSleeper:
+    """Sleep the remaining delta via ``anyio.sleep``; past targets are a no-op."""
+
+    def __init__(self, clock: Clock | None = None) -> None:
+        self._clock: Clock = clock if clock is not None else SystemClock()
+
+    async def sleep_until(self, when: datetime) -> None:
+        delay = (when - self._clock.now()).total_seconds()
+        if delay > 0:
+            await anyio.sleep(delay)

codexloop/infrastructure/config.py

@@ -0,0 +1,150 @@
+"""Configuration precedence: flags > env > project toml > user toml > defaults."""
+
+from __future__ import annotations
+
+import os
+import re
+import tomllib
+from collections.abc import Mapping
+from dataclasses import dataclass, fields, replace
+from datetime import timedelta
+from pathlib import Path
+from typing import Any
+
+from codexloop.domain.errors import ConfigurationError
+
+_ENV_PREFIX = "CODEXLOOP_"
+_DURATION = re.compile(
+    r"^(?:(?P<days>\d+)d)?(?:(?P<hours>\d+)h)?(?:(?P<minutes>\d+)m)?"
+    r"(?:(?P<seconds>\d+(?:\.\d+)?)s)?$"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RunnerConfig:
+    """Runtime knobs. ``model=None`` leaves model selection to the Codex CLI."""
+
+    model: str | None = None
+    max_turns: int = 100
+    json_logs: bool = False
+    max_wait: timedelta = timedelta(hours=24)
+    add_dirs: tuple[str, ...] = ()
+    log_level: str = "INFO"
+    log_file: str | None = None
+    notify_command: str | None = None
+
+
+_KNOWN = {f.name for f in fields(RunnerConfig)}
+
+
+def _as_bool(value: object) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        lowered = value.strip().lower()
+        if lowered in {"1", "true", "yes", "on"}:
+            return True
+        if lowered in {"0", "false", "no", "off"}:
+            return False
+    raise ConfigurationError(f"invalid bool {value!r}")
+
+
+def _as_int(value: object) -> int:
+    if isinstance(value, bool):
+        raise ConfigurationError(f"invalid int {value!r}")
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str):
+        return int(value.strip())
+    raise ConfigurationError(f"invalid int {value!r}")
+
+
+def _as_duration(value: object) -> timedelta:
+    if isinstance(value, timedelta):
+        return value
+    if isinstance(value, bool):
+        raise ConfigurationError(f"invalid duration {value!r}")
+    if isinstance(value, int | float):
+        return timedelta(seconds=float(value))
+    if isinstance(value, str):
+        text = value.strip()
+        try:
+            return timedelta(seconds=float(text))
+        except ValueError:
+            pass
+        matched = _DURATION.fullmatch(text)
+        if matched is not None and any(matched.groups()):
+            days = int(matched.group("days") or 0)
+            hours = int(matched.group("hours") or 0)
+            minutes = int(matched.group("minutes") or 0)
+            seconds = float(matched.group("seconds") or 0)
+            return timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds)
+    raise ConfigurationError(f"invalid duration {value!r}")
+
+
+def _as_str_tuple(value: object) -> tuple[str, ...]:
+    if isinstance(value, str):
+        parts = [part.strip() for part in value.split(",")]
+        return tuple(part for part in parts if part)
+    if isinstance(value, list | tuple):
+        return tuple(str(item) for item in value)
+    raise ConfigurationError(f"invalid list {value!r}")
+
+
+def _coerce_field(name: str, value: object) -> Any:
+    if name in {"model", "log_level"}:
+        return str(value)
+    if name == "max_turns":
+        return _as_int(value)
+    if name == "json_logs":
+        return _as_bool(value)
+    if name == "max_wait":
+        return _as_duration(value)
+    if name == "add_dirs":
+        return _as_str_tuple(value)
+    if name in {"log_file", "notify_command"}:
+        return None if value is None else str(value)
+    return value
+
+
+def _from_file(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    with path.open("rb") as handle:
+        data = tomllib.load(handle)
+    return {key: value for key, value in data.items() if key in _KNOWN}
+
+
+def _from_env(environ: Mapping[str, str]) -> dict[str, Any]:
+    overrides: dict[str, Any] = {}
+    for name in _KNOWN:
+        raw = environ.get(_ENV_PREFIX + name.upper())
+        if raw is not None:
+            overrides[name] = raw
+    return overrides
+
+
+def load_config(
+    *,
+    cwd: Path | None = None,
+    home: Path | None = None,
+    environ: Mapping[str, str] | None = None,
+    flags: Mapping[str, object] | None = None,
+) -> RunnerConfig:
+    cwd = Path.cwd() if cwd is None else cwd
+    home = Path.home() if home is None else home
+    env = os.environ if environ is None else environ
+
+    merged: dict[str, Any] = {}
+    merged.update(_from_file(home / ".config" / "codexloop" / "codexloop.toml"))
+    merged.update(_from_file(cwd / "codexloop.toml"))
+    merged.update(_from_env(env))
+    if flags:
+        merged.update({key: value for key, value in flags.items() if value is not None})
+
+    if not merged:
+        return RunnerConfig()
+    coerced: dict[str, Any] = {
+        key: _coerce_field(key, value) for key, value in merged.items() if key in _KNOWN
+    }
+    return replace(RunnerConfig(), **coerced)

codexloop/infrastructure/control.py

@@ -0,0 +1,89 @@
+"""File-based RunControl — operator commands land in inbox/*.json."""
+
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Sequence
+from pathlib import Path
+
+from codexloop.application.ports import Logger, RunControl
+from codexloop.domain.control import ControlCommand, parse_control
+from codexloop.domain.errors import ConfigurationError
+from codexloop.infrastructure.logging import StructlogAppLogger
+
+
+class FileRunControl:
+    """Poll inbox JSON files; archive successes; quarantine malformed."""
+
+    def __init__(self, inbox: Path, *, logger: Logger | None = None) -> None:
+        self._inbox = inbox
+        self._archive = inbox / "archive"
+        self._quarantine = inbox / "quarantine"
+        self._logger: Logger = logger if logger is not None else StructlogAppLogger()
+        self._inbox.mkdir(parents=True, exist_ok=True)
+        self._archive.mkdir(parents=True, exist_ok=True)
+        self._quarantine.mkdir(parents=True, exist_ok=True)
+
+    def enqueue(self, command: ControlCommand) -> Path:
+        payload = command.to_dict()
+        kind = str(payload.get("kind", "command"))
+        name = f"{time.time_ns()}-{kind}.json"
+        path = self._inbox / name
+        path.write_text(json.dumps(payload) + "\n", encoding="utf-8")
+        return path
+
+    def poll(self) -> Sequence[ControlCommand]:
+        files = sorted(
+            path
+            for path in self._inbox.iterdir()
+            if path.is_file() and path.suffix == ".json" and path.name.endswith(".json")
+        )
+        commands: list[ControlCommand] = []
+        for path in files:
+            try:
+                raw = json.loads(path.read_text(encoding="utf-8"))
+                if not isinstance(raw, dict):
+                    raise ConfigurationError("control payload must be an object")
+                command = parse_control(raw)
+            except (
+                OSError,
+                json.JSONDecodeError,
+                ConfigurationError,
+                TypeError,
+                ValueError,
+            ) as exc:
+                self._quarantine_file(path, exc)
+                continue
+            dest = self._archive / path.name
+            path.replace(dest)
+            commands.append(command)
+        return commands
+
+    def _quarantine_file(self, path: Path, exc: BaseException) -> None:
+        dest = self._quarantine / path.name
+        try:
+            path.replace(dest)
+        except OSError:  # pragma: no cover — leave in place if move fails
+            dest = path
+        self._logger.warning(
+            "control.quarantined",
+            path=str(dest),
+            error=str(exc),
+        )
+
+
+class CompositeRunControl:
+    """Merge polls from several RunControl adapters (drain + inbox)."""
+
+    def __init__(self, *controls: RunControl) -> None:
+        self._controls = controls
+
+    def poll(self) -> Sequence[ControlCommand]:
+        commands: list[ControlCommand] = []
+        for control in self._controls:
+            commands.extend(control.poll())
+        return commands
+
+
+__all__ = ["CompositeRunControl", "FileRunControl"]

codexloop/infrastructure/doctor_env.py

@@ -0,0 +1,239 @@
+"""Doctor environment adapter — probes ``codex`` CLI, auth, and capacity sources."""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess  # nosec B404 — fixed argv to ``codex`` only, never shell=True
+from collections.abc import Callable, Mapping, Sequence
+from pathlib import Path
+
+from codexloop.application.usecases.doctor import DoctorCheck, DoctorReport
+
+MINIMUM_CODEX_VERSION: tuple[int, int, int] = (0, 40, 0)
+_REQUIRED_EXEC_FLAGS = ("--json", "--ephemeral", "-c")
+_VERSION_RE = re.compile(r"(\d+)\.(\d+)\.(\d+)")
+
+
+class CodexDoctorEnvironment:
+    """Injectable doctor probes over ``codex`` and the local filesystem."""
+
+    def __init__(
+        self,
+        *,
+        environ: Mapping[str, str] | None = None,
+        which: Callable[[str], str | None] | None = None,
+        run: Callable[..., subprocess.CompletedProcess[str]] | None = None,
+        home: Path | None = None,
+        minimum_version: tuple[int, int, int] = MINIMUM_CODEX_VERSION,
+        app_server_live: Callable[[], bool] | None = None,
+        rollout_live: Callable[[], bool] | None = None,
+        mcp_servers: Callable[[], Sequence[str]] | None = None,
+    ) -> None:
+        self._environ = dict(environ) if environ is not None else dict(os.environ)
+        self._which = which if which is not None else shutil.which
+        self._run = run if run is not None else _default_run
+        self._home = home if home is not None else Path.home()
+        self._minimum = minimum_version
+        self._app_server_live = app_server_live
+        self._rollout_live = rollout_live
+        self._mcp_servers = mcp_servers
+
+    def diagnose(self, *, cwd: Path) -> DoctorReport:
+        checks: list[DoctorCheck] = []
+        codex = self._which("codex")
+        if codex is None:
+            checks.append(
+                DoctorCheck(
+                    name="codex-cli",
+                    passed=False,
+                    detail="`codex` not found on PATH",
+                )
+            )
+            version_ok = False
+            version_text = None
+        else:
+            version_text = self._codex_version(codex)
+            version_ok = self._version_meets_floor(version_text)
+            checks.append(
+                DoctorCheck(
+                    name="codex-cli",
+                    passed=version_ok,
+                    detail=(
+                        f"found at {codex} ({version_text or 'version unknown'}); "
+                        f"minimum {'.'.join(str(p) for p in self._minimum)}"
+                    ),
+                )
+            )
+
+        login_ok = False
+        if codex is not None:
+            login_ok = self._login_status_ok(codex)
+        checks.append(
+            DoctorCheck(
+                name="login-status",
+                passed=login_ok,
+                detail="codex login status exit 0" if login_ok else "codex login status failed",
+            )
+        )
+
+        flags_ok = False
+        if codex is not None:
+            flags_ok = self._exec_help_has_flags(codex)
+        checks.append(
+            DoctorCheck(
+                name="exec-flags",
+                passed=flags_ok,
+                detail=(
+                    f"required flags present: {', '.join(_REQUIRED_EXEC_FLAGS)}"
+                    if flags_ok
+                    else f"missing one of {_REQUIRED_EXEC_FLAGS}"
+                ),
+            )
+        )
+
+        auth_mode = self._auth_mode()
+        checks.append(
+            DoctorCheck(
+                name="auth-mode",
+                passed=auth_mode != "none",
+                detail=f"active auth mode: {auth_mode}",
+            )
+        )
+
+        strategies = {
+            "exec": True,
+            "app-server": (
+                self._app_server_live()
+                if self._app_server_live is not None
+                else self._probe_app_server_live()
+            ),
+            "rollout": self._rollout_live() if self._rollout_live else False,
+        }
+        checks.append(
+            DoctorCheck(
+                name="probe-strategies",
+                passed=True,
+                detail=(
+                    "live: "
+                    + ", ".join(name for name, live in strategies.items() if live)
+                    + (
+                        "; unavailable: "
+                        + ", ".join(name for name, live in strategies.items() if not live)
+                        if any(not live for live in strategies.values())
+                        else ""
+                    )
+                ).rstrip("; "),
+            )
+        )
+
+        mcp = list(self._mcp_servers()) if self._mcp_servers is not None else []
+        if mcp:
+            checks.append(
+                DoctorCheck(
+                    name="mcp-oauth",
+                    passed=False,
+                    detail=(
+                        f"MCP servers requiring OAuth: {', '.join(mcp)} — "
+                        "authorize before an unattended run"
+                    ),
+                )
+            )
+        else:
+            checks.append(
+                DoctorCheck(name="mcp-oauth", passed=True, detail="no MCP OAuth servers named")
+            )
+
+        is_git = (cwd / ".git").is_dir()
+        checks.append(
+            DoctorCheck(
+                name="working-directory",
+                passed=is_git,
+                detail=(
+                    f"{cwd} is a git repository" if is_git else f"{cwd} is NOT a git repository"
+                ),
+            )
+        )
+
+        return DoctorReport(
+            checks=tuple(checks),
+            auth_mode=auth_mode,
+            probe_strategies=strategies,
+        )
+
+    def _codex_version(self, path: str) -> str | None:
+        try:
+            result = self._run([path, "--version"], timeout=10)
+        except (OSError, subprocess.TimeoutExpired):
+            return None
+        if result.returncode != 0:
+            return None
+        text = (result.stdout or result.stderr or "").strip()
+        return text or None
+
+    def _version_meets_floor(self, version_text: str | None) -> bool:
+        if version_text is None:
+            return False
+        match = _VERSION_RE.search(version_text)
+        if match is None:
+            return False
+        parsed = (int(match.group(1)), int(match.group(2)), int(match.group(3)))
+        return parsed >= self._minimum
+
+    def _login_status_ok(self, path: str) -> bool:
+        try:
+            result = self._run([path, "login", "status"], timeout=10)
+        except (OSError, subprocess.TimeoutExpired):
+            return False
+        return result.returncode == 0
+
+    def _exec_help_has_flags(self, path: str) -> bool:
+        try:
+            result = self._run([path, "exec", "--help"], timeout=10)
+        except (OSError, subprocess.TimeoutExpired):
+            return False
+        text = f"{result.stdout}\n{result.stderr}"
+        return all(flag in text for flag in _REQUIRED_EXEC_FLAGS)
+
+    def _auth_mode(self) -> str:
+        if self._environ.get("OPENAI_API_KEY") or self._environ.get("CODEX_API_KEY"):
+            return "api_key"
+        auth = self._home / ".codex" / "auth.json"
+        if auth.is_file():
+            return "chatgpt_plan"
+        return "none"
+
+    def _probe_app_server_live(self) -> bool:
+        """Return True when ``codex app-server --help`` succeeds (cheap live probe)."""
+        codex = self._which("codex")
+        if codex is None:
+            return False
+        try:
+            result = self._run([codex, "app-server", "--help"], timeout=10)
+        except (OSError, subprocess.TimeoutExpired):
+            return False
+        if result.returncode != 0:
+            return False
+        text = f"{result.stdout}\n{result.stderr}".lower()
+        return "stdio" in text or "app-server" in text
+
+
+def _default_run(
+    argv: Sequence[str],
+    *,
+    timeout: float = 10,
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(  # nosec B603
+        list(argv),
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        check=False,
+    )
+
+
+__all__ = [
+    "CodexDoctorEnvironment",
+    "MINIMUM_CODEX_VERSION",
+]