codexloop 0.1.0__py3-none-any.whl

codexloop/infrastructure/events.py

@@ -0,0 +1,23 @@
+"""RunEventSink — append-only JSONL under a run directory."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from pathlib import Path
+
+from codexloop.infrastructure.redact import redact
+
+
+class JsonlRunEventSink:
+    def __init__(self, path: Path) -> None:
+        self._path = path
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        if not self._path.exists():
+            self._path.touch()
+
+    def emit(self, event: Mapping[str, object]) -> None:
+        safe = redact(dict(event))
+        with self._path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(safe, default=str) + "\n")
+            handle.flush()

codexloop/infrastructure/git_savepoints.py

@@ -0,0 +1,176 @@
+"""Git-backed save points under ``refs/codexloop/<run_id>/<n>``."""
+
+from __future__ import annotations
+
+import json
+import subprocess  # nosec B404 — argv lists are fixed git subcommands, never shell=True
+from datetime import UTC, datetime
+from pathlib import Path
+
+from codexloop.domain.errors import ConfigurationError
+from codexloop.domain.savepoint import SavePointRef, UnwindResult
+from codexloop.domain.savepoint_message import format_savepoint_commit_message
+
+_CONTROL_PLANE_DIR = ".codexloop"
+
+
+class GitSavePointStore:
+    def __init__(self, *, cwd: Path, index_path: Path) -> None:
+        self._cwd = cwd
+        self._index_path = index_path
+        self._index_path.parent.mkdir(parents=True, exist_ok=True)
+        if not self._index_path.exists():
+            self._index_path.touch()
+
+    def create(
+        self,
+        *,
+        run_id: str,
+        label: str,
+        message: str | None = None,
+        attempt: int | None = None,
+        verdict_name: str = "Continue",
+        summary: str = "",
+        remaining_work: tuple[str, ...] = (),
+    ) -> SavePointRef | None:
+        if not self._is_git_repo():
+            return None
+        self._run(["git", "add", "-A"])
+        self._run(["git", "reset", "-q", "--", _CONTROL_PLANE_DIR], check=False)
+        has_staged = self._run(["git", "diff", "--cached", "--quiet"], check=False).returncode != 0
+        changed_paths = self._staged_paths() if has_staged else ()
+        turn_n = attempt if attempt is not None else self._next_n(run_id)
+        subject: str | None = None
+        if has_staged:
+            subject, body = format_savepoint_commit_message(
+                run_id=run_id,
+                attempt=turn_n,
+                verdict_name=verdict_name,
+                summary=summary or message or "",
+                remaining_work=remaining_work,
+                changed_paths=changed_paths,
+                label=label,
+            )
+            self._run(
+                ["git", "commit", "--no-verify", "-m", subject, "-m", body],
+            )
+        sha = self._run(["git", "rev-parse", "HEAD"]).stdout.strip()
+        n = self._next_n(run_id)
+        ref = f"refs/codexloop/{run_id}/{n}"
+        self._run(["git", "update-ref", ref, sha])
+        point = SavePointRef(
+            n=n,
+            ref=ref,
+            sha=sha,
+            label=label,
+            at=datetime.now(UTC),
+            plan_item=None,
+            committed=has_staged,
+        )
+        self._append_index(
+            point,
+            committed=has_staged,
+            subject=subject,
+            path_count=len(changed_paths),
+        )
+        return point
+
+    def list_points(self, run_id: str) -> list[SavePointRef]:
+        if not self._index_path.is_file():
+            return []
+        points: list[SavePointRef] = []
+        for line in self._index_path.read_text(encoding="utf-8").splitlines():
+            if not line.strip():
+                continue
+            data = json.loads(line)
+            if data.get("run_id") and data["run_id"] != run_id:
+                continue
+            points.append(
+                SavePointRef(
+                    n=int(data["n"]),
+                    ref=str(data["ref"]),
+                    sha=str(data["sha"]),
+                    label=str(data["label"]),
+                    at=datetime.fromisoformat(data["at"]),
+                    plan_item=data.get("plan_item"),
+                    committed=bool(data.get("committed", False)),
+                )
+            )
+        return points
+
+    def unwind(self, *, run_id: str, to: str, backup: bool, live: bool = False) -> UnwindResult:
+        if live:
+            raise ConfigurationError("unwind refuses while a run is live")
+        points = self.list_points(run_id)
+        target = self._resolve_target(points, to)
+        backup_ref: str | None = None
+        if backup:
+            stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+            backup_ref = f"refs/codexloop/backup/{run_id}/{stamp}"
+            head = self._run(["git", "rev-parse", "HEAD"]).stdout.strip()
+            self._run(["git", "update-ref", backup_ref, head])
+        self._run(["git", "reset", "--hard", target.sha])
+        return UnwindResult(to=target, backup_ref=backup_ref, restored_sha=target.sha)
+
+    def _next_n(self, run_id: str) -> int:
+        existing = self.list_points(run_id)
+        return (existing[-1].n + 1) if existing else 1
+
+    def _staged_paths(self) -> tuple[str, ...]:
+        result = self._run(["git", "diff", "--cached", "--name-only", "-z"], check=False)
+        if result.returncode != 0 or not result.stdout:
+            return ()
+        return tuple(p for p in result.stdout.split("\0") if p)
+
+    def _append_index(
+        self,
+        point: SavePointRef,
+        *,
+        committed: bool = False,
+        subject: str | None = None,
+        path_count: int = 0,
+    ) -> None:
+        parts = point.ref.split("/")
+        run_id = parts[2] if len(parts) >= 4 else ""
+        entry = {
+            "run_id": run_id,
+            "n": point.n,
+            "ref": point.ref,
+            "sha": point.sha,
+            "label": point.label,
+            "at": point.at.isoformat(),
+            "plan_item": point.plan_item,
+            "committed": committed,
+            "subject": subject,
+            "path_count": path_count,
+        }
+        with self._index_path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(entry) + "\n")
+
+    def _resolve_target(self, points: list[SavePointRef], to: str) -> SavePointRef:
+        if to.isdigit():
+            n = int(to)
+            for point in points:
+                if point.n == n:
+                    return point
+            raise ValueError(f"no save point numbered {n}")
+        for point in points:
+            if point.ref == to or point.sha.startswith(to) or point.label == to:
+                return point
+        raise ValueError(f"no save point matching {to!r}")
+
+    def _is_git_repo(self) -> bool:
+        result = self._run(["git", "rev-parse", "--is-inside-work-tree"], check=False)
+        return result.returncode == 0 and result.stdout.strip() == "true"
+
+    def _run(self, args: list[str], *, check: bool = True) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(  # nosec B603
+            args,
+            cwd=self._cwd,
+            check=check,
+            capture_output=True,
+            text=True,
+        )
+
+
+__all__ = ["GitSavePointStore"]

codexloop/infrastructure/lock.py

@@ -0,0 +1,88 @@
+"""SessionLock — advisory file lock keyed by thread id, with stale-pid break."""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+
+from codexloop.application.ports import Logger
+
+_LOG = logging.getLogger(__name__)
+
+
+class AdvisoryFileLock:
+    def __init__(self, directory: Path, *, logger: Logger | None = None) -> None:
+        self._directory = directory
+        self._directory.mkdir(parents=True, exist_ok=True)
+        self._logger = logger
+
+    def _path(self, thread_id: str) -> Path:
+        return self._directory / f"{thread_id}.lock"
+
+    def acquire(self, thread_id: str) -> bool:
+        path = self._path(thread_id)
+        if path.is_file():
+            pid = _read_pid(path)
+            if pid is None or _pid_alive(pid):
+                # Empty/unreadable/unparseable lockfile, or live/unknown pid: held.
+                return False
+            self._log_stale(thread_id, pid, "process is dead")
+            path.unlink(missing_ok=True)
+        return _publish_lock(path)
+
+    def release(self, thread_id: str) -> None:
+        self._path(thread_id).unlink(missing_ok=True)
+
+    def _log_stale(self, thread_id: str, pid: int | None, reason: str) -> None:
+        if self._logger is not None:
+            self._logger.warning(
+                "stale_lock_broken",
+                thread_id=thread_id,
+                pid=pid,
+                reason=reason,
+            )
+            return
+        _LOG.warning(
+            "stale lock broken for thread %s (pid=%s): %s",
+            thread_id,
+            pid,
+            reason,
+        )
+
+
+def _publish_lock(path: Path) -> bool:
+    """Atomically publish a non-empty lockfile (write pid, then link into place)."""
+    tmp = path.with_name(f"{path.name}.{os.getpid()}.tmp")
+    try:
+        tmp.write_text(f"{os.getpid()}\n", encoding="utf-8")
+        os.link(str(tmp), str(path))
+    except FileExistsError:
+        return False
+    except OSError:
+        return False
+    finally:
+        tmp.unlink(missing_ok=True)
+    return True
+
+
+def _read_pid(path: Path) -> int | None:
+    try:
+        return int(path.read_text(encoding="utf-8").strip())
+    except (OSError, ValueError):
+        return None
+
+
+def _pid_alive(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        # Unknown errno: treat as alive so we never break a maybe-held lock.
+        return True
+    return True

codexloop/infrastructure/logging.py

@@ -0,0 +1,124 @@
+"""structlog configuration: human console, optional JSON console, optional file."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from collections.abc import MutableMapping
+from pathlib import Path
+from typing import Any
+
+import structlog
+from structlog.stdlib import BoundLogger, LoggerFactory, ProcessorFormatter
+
+from codexloop.application.ports import Logger
+from codexloop.infrastructure.redact import redact
+
+
+class RedactionProcessor:
+    """structlog processor that recursively redacts secrets in the event dict."""
+
+    def __call__(
+        self,
+        _logger: object,
+        _method_name: str,
+        event_dict: MutableMapping[str, Any],
+    ) -> MutableMapping[str, Any]:
+        redacted = redact(dict(event_dict))
+        if not isinstance(redacted, dict):
+            return event_dict
+        return redacted
+
+
+def _json_renderer(logger: object, method_name: str, event_dict: MutableMapping[str, Any]) -> str:
+    rendered = structlog.processors.JSONRenderer()(logger, method_name, event_dict)
+    return str(rendered)
+
+
+def configure_logging(
+    *,
+    level: str = "INFO",
+    json_logs: bool = False,
+    log_file: Path | None = None,
+) -> None:
+    """Install a human console handler, optional JSON console, and optional file."""
+    level_value = getattr(logging, level.upper(), logging.INFO)
+    shared: list[Any] = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.processors.TimeStamper(fmt="iso"),
+        RedactionProcessor(),
+    ]
+
+    structlog.configure(
+        processors=[
+            structlog.stdlib.filter_by_level,
+            *shared,
+            ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=LoggerFactory(),
+        wrapper_class=structlog.make_filtering_bound_logger(level_value),
+        cache_logger_on_first_use=False,
+    )
+
+    root = logging.getLogger()
+    root.handlers.clear()
+    root.setLevel(level_value)
+
+    human = logging.StreamHandler(sys.stderr)
+    human.setLevel(level_value)
+    human.setFormatter(
+        ProcessorFormatter(
+            processor=structlog.dev.ConsoleRenderer(),
+            foreign_pre_chain=shared,
+        )
+    )
+    root.addHandler(human)
+
+    if json_logs:
+        json_console = logging.StreamHandler(sys.stderr)
+        json_console.setLevel(level_value)
+        json_console.setFormatter(
+            ProcessorFormatter(
+                processor=_json_renderer,
+                foreign_pre_chain=shared,
+            )
+        )
+        root.addHandler(json_console)
+
+    if log_file is not None:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(log_file, encoding="utf-8")
+        file_handler.setLevel(level_value)
+        file_handler.setFormatter(
+            ProcessorFormatter(
+                processor=_json_renderer,
+                foreign_pre_chain=shared,
+            )
+        )
+        root.addHandler(file_handler)
+
+
+def get_logger(**initial_context: Any) -> BoundLogger:
+    logger: BoundLogger = structlog.get_logger(**initial_context)
+    return logger
+
+
+class StructlogAppLogger:
+    """Adapter satisfying :class:`codexloop.application.ports.Logger`."""
+
+    def __init__(self, bound: BoundLogger | None = None, **context: Any) -> None:
+        self._log: BoundLogger = bound if bound is not None else get_logger(**context)
+
+    def bind(self, **kwargs: object) -> Logger:
+        return StructlogAppLogger(self._log.bind(**kwargs))
+
+    def info(self, event: str, **kwargs: object) -> None:
+        self._log.info(event, **kwargs)
+
+    def warning(self, event: str, **kwargs: object) -> None:
+        self._log.warning(event, **kwargs)
+
+    def error(self, event: str, **kwargs: object) -> None:
+        self._log.error(event, **kwargs)

codexloop/infrastructure/notify.py

@@ -0,0 +1,27 @@
+"""Notifier — run a configured command, or record a no-op when unset."""
+
+from __future__ import annotations
+
+import shlex
+import subprocess  # nosec B404 — argv list from operator config, never shell=True
+from collections.abc import Sequence
+
+from codexloop.infrastructure.redact import redact_string
+
+
+class CommandNotifier:
+    def __init__(self, command: str | Sequence[str] | None = None) -> None:
+        self._command = command
+        self.noop_notifications: list[tuple[str, str]] = []
+
+    def notify(self, title: str, body: str) -> None:
+        safe_title = redact_string(title)
+        safe_body = redact_string(body)
+        if not self._command:
+            self.noop_notifications.append((safe_title, safe_body))
+            return
+        argv = shlex.split(self._command) if isinstance(self._command, str) else list(self._command)
+        subprocess.run(  # nosec B603 — no shell; operator-configured argv
+            [*argv, safe_title, safe_body],
+            check=False,
+        )

codexloop/infrastructure/progress.py

@@ -0,0 +1,14 @@
+"""ProgressReporter — log-based adapter for operator-visible run events."""
+
+from __future__ import annotations
+
+from codexloop.application.ports import Logger
+from codexloop.infrastructure.logging import StructlogAppLogger
+
+
+class LoggingProgressReporter:
+    def __init__(self, logger: Logger | None = None) -> None:
+        self._logger: Logger = logger if logger is not None else StructlogAppLogger()
+
+    def report(self, event: str, **detail: object) -> None:
+        self._logger.info(event, **detail)

codexloop/infrastructure/redact.py

@@ -0,0 +1,52 @@
+"""Recursive redaction of secret-shaped keys and credential-looking strings."""
+
+from __future__ import annotations
+
+import re
+
+REDACTED_VALUE = "***REDACTED***"
+
+_REDACTED_KEYS = frozenset(
+    {
+        "openai_api_key",
+        "codex_api_key",
+        "authorization",
+        "access_token",
+        "refresh_token",
+        "client_secret",
+        "api_key",
+        "secret_value",
+        "secret",
+        "password",
+        "token",
+    }
+)
+
+_SK_PATTERN = re.compile(r"sk-[A-Za-z0-9_-]{16,}")
+
+
+def _normalize_key(key: object) -> str:
+    return str(key).lower().replace("-", "_")
+
+
+def redact_string(value: str) -> str:
+    return _SK_PATTERN.sub(REDACTED_VALUE, value)
+
+
+def redact[T](value: T) -> T:
+    """Recursively scrub secret keys and ``sk-`` credential substrings."""
+    if isinstance(value, dict):
+        out: dict[object, object] = {}
+        for key, item in value.items():
+            if _normalize_key(key) in _REDACTED_KEYS:
+                out[key] = REDACTED_VALUE
+            else:
+                out[key] = redact(item)
+        return out  # type: ignore[return-value]
+    if isinstance(value, list):
+        return [redact(item) for item in value]  # type: ignore[return-value]
+    if isinstance(value, tuple):
+        return tuple(redact(item) for item in value)  # type: ignore[return-value]
+    if isinstance(value, str):
+        return redact_string(value)  # type: ignore[return-value]
+    return value

codexloop/infrastructure/rollout.py

@@ -0,0 +1,113 @@
+"""Best-effort rollout-tail telemetry (confidence C, R5). Strictly read-only."""
+
+from __future__ import annotations
+
+import os
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+from codexloop.domain.capacity import PlanWindows
+from codexloop.infrastructure.agent.events import JsonlParser, RateLimitsUpdated
+
+_DEFAULT_MAX_AGE = timedelta(minutes=10)
+
+
+def read_rollout_rate_limits(
+    *,
+    codex_home: Path | None = None,
+    max_age: timedelta = _DEFAULT_MAX_AGE,
+    now: datetime | None = None,
+) -> PlanWindows | None:
+    """Return the newest contained rollout snapshot, or ``None``. Never raises."""
+    try:
+        return _read(codex_home=codex_home, max_age=max_age, now=now)
+    except Exception:
+        return None
+
+
+def _read(
+    *,
+    codex_home: Path | None,
+    max_age: timedelta,
+    now: datetime | None,
+) -> PlanWindows | None:
+    home = Path.home() / ".codex" if codex_home is None else Path(codex_home)
+    try:
+        root = home.resolve()
+    except OSError:
+        return None
+    if not root.is_dir():
+        return None
+
+    clock = now if now is not None else datetime.now(UTC)
+    newest = _newest_contained_jsonl(root)
+    if newest is None:
+        return None
+    if _is_stale(newest, now=clock, max_age=max_age):
+        return None
+    return _parse_file(newest, now=clock)
+
+
+def _newest_contained_jsonl(root: Path) -> Path | None:
+    """Pick the newest ``*.jsonl`` under ``root`` without following dir symlinks."""
+    newest: Path | None = None
+    newest_mtime = float("-inf")
+    try:
+        for dirpath, dirnames, filenames in os.walk(root, followlinks=False):
+            # Do not descend into symlinked directories (os.walk still lists them).
+            dirnames[:] = [name for name in dirnames if not Path(dirpath, name).is_symlink()]
+            for name in filenames:
+                if not name.endswith(".jsonl"):
+                    continue
+                path = Path(dirpath) / name
+                # File symlinks are allowed only when the target stays under root.
+                if not _contained(path, root):
+                    continue
+                try:
+                    target = path.resolve() if path.is_symlink() else path
+                    if not target.is_file():
+                        continue
+                    mtime = target.stat().st_mtime
+                except OSError:  # pragma: no cover
+                    continue
+                if mtime >= newest_mtime:
+                    newest = target
+                    newest_mtime = mtime
+    except OSError:
+        return None
+    return newest
+
+
+def _contained(path: Path, root: Path) -> bool:
+    try:
+        resolved = path.resolve()
+    except OSError:
+        return False
+    try:
+        return resolved.is_relative_to(root)
+    except ValueError:  # pragma: no cover
+        return False
+
+
+def _is_stale(path: Path, *, now: datetime, max_age: timedelta) -> bool:
+    try:
+        mtime = datetime.fromtimestamp(path.stat().st_mtime, tz=UTC)
+    except (OSError, OverflowError, ValueError):
+        return True
+    return now - mtime > max_age
+
+
+def _parse_file(path: Path, *, now: datetime) -> PlanWindows | None:
+    parser = JsonlParser(now=now)
+    last: PlanWindows | None = None
+    found = False
+    try:
+        with path.open(encoding="utf-8") as handle:
+            for line in handle:
+                event = parser.parse_line(line)
+                if isinstance(event, RateLimitsUpdated):
+                    last = event.plan_windows
+                    found = True
+    except (OSError, UnicodeDecodeError):
+        return None
+    return last if found else None

codexloop/infrastructure/rundir.py

@@ -0,0 +1,57 @@
+"""Per-run control directory layout under ``.codexloop/runs/<run_id>/``."""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from datetime import UTC, datetime
+from pathlib import Path
+
+
+class RunDirectory:
+    """Filesystem layout for one autonomous run's control plane."""
+
+    def __init__(self, root: Path) -> None:
+        self.root = root
+        self.run_id = root.name
+        self.meta_path = root / "meta.json"
+        self.state_path = root / "state.json"
+        self.events_path = root / "events.jsonl"
+        self.inbox = root / "inbox"
+        self.archive = root / "archive"
+        self.savepoints_path = root / "savepoints.jsonl"
+        self.snapshots = root / "snapshots"
+
+    @classmethod
+    def create(cls, runs_root: Path, *, run_id: str | None = None) -> RunDirectory:
+        if run_id is None:
+            run_id = str(uuid.uuid4())
+        directory = cls(runs_root / run_id)
+        directory.ensure_layout()
+        return directory
+
+    def ensure_layout(self) -> None:
+        self.root.mkdir(parents=True, exist_ok=True)
+        self.inbox.mkdir(exist_ok=True)
+        self.archive.mkdir(exist_ok=True)
+        (self.inbox / "archive").mkdir(exist_ok=True)
+        (self.inbox / "quarantine").mkdir(exist_ok=True)
+        self.snapshots.mkdir(exist_ok=True)
+        if not self.savepoints_path.is_file():
+            self.savepoints_path.touch()
+        if not self.meta_path.is_file():
+            meta = {
+                "run_id": self.run_id,
+                "pid": os.getpid(),
+                "started_at": datetime.now(UTC).isoformat(),
+            }
+            self.meta_path.write_text(json.dumps(meta, indent=2) + "\n", encoding="utf-8")
+        if not self.state_path.is_file():
+            self.state_path.write_text("{}\n", encoding="utf-8")
+        if not self.events_path.is_file():
+            self.events_path.touch()
+
+
+def runs_root_for(cwd: Path) -> Path:
+    return cwd / ".codexloop" / "runs"