byte-bot 0.1.0__py3-none-any.whl

byte_bot/__init__.py

@@ -0,0 +1,3 @@
+"""byte-bot."""
+
+__version__ = "0.1.0"

byte_bot/__main__.py

@@ -0,0 +1,3 @@
+from byte_bot.cli import main
+
+raise SystemExit(main())

byte_bot/adapters/__init__.py

@@ -0,0 +1,16 @@
+"""Static reviewed adapter-name registry.
+
+Importing the package must not eagerly import adapter implementations: config and
+legacy adapters depend on each other at module-load time. Runtime code imports the
+specific reviewed implementation it needs.
+"""
+
+from __future__ import annotations
+
+ADAPTER_NAMES: tuple[str, ...] = (
+    "codex-exec-jsonl",
+    "legacy-command",
+    "opencode-http",
+)
+
+__all__ = ["ADAPTER_NAMES"]

byte_bot/adapters/codex_exec_jsonl.py

@@ -0,0 +1,325 @@
+"""Version-pinned passive Codex exec JSONL observation.
+
+The adapter reads one explicitly configured existing capture. It never invokes
+Codex, resumes a thread, attaches to a session, or retains transcript/tool bodies.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import stat as stat_module
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from byte_bot.model import (
+    CollectionError,
+    Evidence,
+    Lifecycle,
+    Session,
+    SourceHealth,
+    SourceStatus,
+)
+
+ADAPTER_NAME = "codex-exec-jsonl"
+SUPPORTED_VERSION = "0.155.1"
+FIELD_VERSION = "codex-0.155.1-exec-jsonl"
+CAPABILITIES = ("sessions", "source-health")
+MAX_CAPTURE_BYTES = 64 * 1024
+MAX_RECORDS = 32
+MAX_THREAD_ID_LEN = 128
+
+_IGNORED_ITEM_TYPES = frozenset({"item.started", "item.updated", "item.completed"})
+_ALLOWED_TYPES = frozenset(
+    {
+        "thread.started",
+        "turn.started",
+        "turn.completed",
+        "turn.failed",
+        "error",
+        *_IGNORED_ITEM_TYPES,
+    }
+)
+
+
+class _CodexFailure(Exception):
+    def __init__(self, code: str, message: str) -> None:
+        super().__init__(code)
+        self.code = code
+        self.message = message
+
+
+@dataclass(frozen=True)
+class CodexObservation:
+    sessions: tuple[Session, ...] = ()
+    errors: tuple[CollectionError, ...] = ()
+    health: SourceHealth | None = None
+    complete: bool | None = None
+    version: str | None = None
+
+
+def _read_capture(path: Path) -> bytes:
+    """Read a bounded regular file without following a runtime symlink."""
+    path = Path(path)
+    # Reject FIFOs after opening without waiting for a writer, including
+    # regular-file replacement races between metadata checks and open().
+    flags = os.O_RDONLY | getattr(os, "O_NONBLOCK", 0)
+    nofollow = getattr(os, "O_NOFOLLOW", 0)
+    before: os.stat_result | None = None
+    if nofollow:
+        flags |= nofollow
+    else:
+        before = path.lstat()
+        if stat_module.S_ISLNK(before.st_mode):
+            raise _CodexFailure("unsafe_path", "Codex capture path is unsafe")
+
+    try:
+        fd = os.open(path, flags)
+    except OSError as exc:
+        raise _CodexFailure("capture_unavailable", "Codex capture is unavailable") from exc
+    try:
+        metadata = os.fstat(fd)
+        if not stat_module.S_ISREG(metadata.st_mode):
+            raise _CodexFailure("unsafe_path", "Codex capture path is unsafe")
+        if before is not None and (
+            before.st_dev != metadata.st_dev or before.st_ino != metadata.st_ino
+        ):
+            raise _CodexFailure("unsafe_path", "Codex capture changed while opening")
+        if metadata.st_size > MAX_CAPTURE_BYTES:
+            raise _CodexFailure(
+                "capture_too_large",
+                "Codex capture exceeds the validated byte limit",
+            )
+        data = os.read(fd, MAX_CAPTURE_BYTES + 1)
+        if len(data) > MAX_CAPTURE_BYTES:
+            raise _CodexFailure(
+                "capture_too_large",
+                "Codex capture exceeds the validated byte limit",
+            )
+        return data
+    finally:
+        with contextlib.suppress(OSError):
+            os.close(fd)
+
+
+def _valid_thread_id(value: object) -> bool:
+    return (
+        isinstance(value, str)
+        and bool(value)
+        and len(value) <= MAX_THREAD_ID_LEN
+        and not any(ord(char) < 0x20 or 0x7F <= ord(char) <= 0x9F for char in value)
+    )
+
+
+def _error(
+    source_id: str,
+    failure: _CodexFailure,
+    observed_at: datetime,
+    *,
+    version: str | None,
+) -> CodexObservation:
+    return CodexObservation(
+        errors=(
+            CollectionError(
+                code=failure.code,
+                message=failure.message,
+                source_id=source_id,
+            ),
+        ),
+        health=SourceHealth(
+            source_id=source_id,
+            status=SourceStatus.ERROR,
+            detail=failure.message,
+            observed_at=observed_at,
+        ),
+        version=version,
+    )
+
+
+def _records(data: bytes) -> tuple[list[dict[str, Any]], bool]:
+    try:
+        text = data.decode("utf-8")
+    except UnicodeDecodeError:
+        raise _CodexFailure("malformed_capture", "Codex capture is not valid UTF-8") from None
+
+    partial = bool(data) and not data.endswith(b"\n")
+    lines = text.splitlines()
+    if partial and lines:
+        lines = lines[:-1]
+    lines = [line for line in lines if line.strip()]
+    if len(lines) > MAX_RECORDS:
+        raise _CodexFailure(
+            "too_many_records",
+            "Codex capture exceeds the validated record limit",
+        )
+
+    records: list[dict[str, Any]] = []
+    for line in lines:
+        try:
+            raw = json.loads(line)
+        except json.JSONDecodeError:
+            raise _CodexFailure(
+                "malformed_capture", "Codex capture contains invalid JSON"
+            ) from None
+        if not isinstance(raw, dict):
+            raise _CodexFailure("malformed_capture", "Codex capture record must be an object")
+        event_type = raw.get("type")
+        if not isinstance(event_type, str) or event_type not in _ALLOWED_TYPES:
+            raise _CodexFailure(
+                "unsupported_event",
+                "Codex capture contains an unsupported event type",
+            )
+        records.append(raw)
+    return records, partial
+
+
+def observe_codex_capture(
+    *,
+    source_id: str,
+    path: Path,
+    source_version: str,
+    now: datetime | None = None,
+) -> CodexObservation:
+    """Map a validated Codex 0.155.1 exec capture to one typed session."""
+    observed_at = now or datetime.now(UTC)
+    version = source_version if isinstance(source_version, str) else None
+    try:
+        if source_version != SUPPORTED_VERSION:
+            raise _CodexFailure("unsupported_version", "Codex capture version is not supported")
+        records, partial = _records(_read_capture(path))
+        if not records:
+            raise _CodexFailure("empty_capture", "Codex capture contains no complete records")
+
+        thread_id: str | None = None
+        turn_started = False
+        lifecycle = Lifecycle.UNKNOWN
+        terminal = False
+
+        for raw in records:
+            event_type = raw["type"]
+            if event_type in _IGNORED_ITEM_TYPES:
+                continue
+
+            if event_type == "thread.started":
+                value = raw.get("thread_id")
+                if set(raw) != {"type", "thread_id"} or not _valid_thread_id(value):
+                    raise _CodexFailure("malformed_thread", "Codex thread identity is invalid")
+                if thread_id is not None:
+                    raise _CodexFailure(
+                        "multiple_threads",
+                        "Codex capture contains more than one thread",
+                    )
+                thread_id = value
+                continue
+
+            if thread_id is None:
+                raise _CodexFailure("event_order", "Codex lifecycle event precedes thread identity")
+
+            if event_type == "turn.started":
+                if set(raw) != {"type"} or turn_started or terminal:
+                    raise _CodexFailure(
+                        "unsupported_turn_sequence",
+                        "Codex capture turn sequence is unsupported",
+                    )
+                turn_started = True
+                continue
+
+            if event_type == "turn.completed":
+                if not turn_started or terminal or set(raw) != {"type", "usage"}:
+                    raise _CodexFailure(
+                        "unsupported_turn_sequence",
+                        "Codex capture turn sequence is unsupported",
+                    )
+                if not isinstance(raw.get("usage"), dict):
+                    raise _CodexFailure(
+                        "malformed_completion",
+                        "Codex turn completion shape is invalid",
+                    )
+                lifecycle = Lifecycle.DONE
+                terminal = True
+                continue
+
+            if event_type == "turn.failed":
+                if not turn_started or terminal or "error" not in raw:
+                    raise _CodexFailure(
+                        "unsupported_turn_sequence",
+                        "Codex capture turn sequence is unsupported",
+                    )
+                lifecycle = Lifecycle.FAILED
+                terminal = True
+                continue
+
+            if event_type == "error":
+                if terminal:
+                    raise _CodexFailure(
+                        "unsupported_turn_sequence",
+                        "Codex capture turn sequence is unsupported",
+                    )
+                lifecycle = Lifecycle.FAILED
+                terminal = True
+
+        if thread_id is None:
+            raise _CodexFailure("missing_thread", "Codex capture has no thread identity")
+
+        adapter_id = f"{ADAPTER_NAME}:{source_id}"
+        session = Session(
+            id=f"{adapter_id}/{thread_id}",
+            adapter_instance_id=adapter_id,
+            native_id=thread_id,
+            work_id=thread_id,
+            lifecycle=lifecycle,
+            observed_at=observed_at,
+            evidence=(
+                Evidence(
+                    source_kind=ADAPTER_NAME,
+                    source_id=source_id,
+                    field_version=FIELD_VERSION,
+                    observed_at=observed_at,
+                ),
+            ),
+        )
+        errors: tuple[CollectionError, ...] = ()
+        status = SourceStatus.OK
+        detail: str | None = None
+        complete = True
+        if partial:
+            errors = (
+                CollectionError(
+                    code="partial_record",
+                    message="Codex capture has an incomplete trailing record",
+                    source_id=source_id,
+                ),
+            )
+            status = SourceStatus.DEGRADED
+            detail = "Codex capture has an incomplete trailing record"
+            complete = False
+
+        return CodexObservation(
+            sessions=(session,),
+            errors=errors,
+            health=SourceHealth(
+                source_id=source_id,
+                status=status,
+                detail=detail,
+                observed_at=observed_at,
+            ),
+            complete=complete,
+            version=source_version,
+        )
+    except _CodexFailure as exc:
+        return _error(
+            source_id,
+            exc,
+            observed_at,
+            version=version,
+        )
+    except (OSError, TypeError, ValueError):
+        return _error(
+            source_id,
+            _CodexFailure("capture_unavailable", "Codex capture is unavailable"),
+            observed_at,
+            version=version,
+        )