codex-autorunner 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codex_autorunner/surfaces/web/pty_session.py

@@ -0,0 +1,370 @@
+import asyncio
+import collections
+import fcntl
+import logging
+import os
+import select
+import struct
+import termios
+import time
+from typing import Dict, Optional
+
+from ptyprocess import PtyProcess
+
+logger = logging.getLogger("codex_autorunner.web.pty_session")
+
+REPLAY_END = object()
+
+ALT_SCREEN_ENTER_SEQS = (
+    b"\x1b[?1049h",
+    b"\x1b[?47h",
+    b"\x1b[?1047h",
+)
+ALT_SCREEN_EXIT_SEQS = (
+    b"\x1b[?1049l",
+    b"\x1b[?47l",
+    b"\x1b[?1047l",
+)
+ALT_SCREEN_SEQS = tuple((seq, True) for seq in ALT_SCREEN_ENTER_SEQS) + tuple(
+    (seq, False) for seq in ALT_SCREEN_EXIT_SEQS
+)
+ALT_SCREEN_MAX_LEN = max(len(seq) for seq, _state in ALT_SCREEN_SEQS)
+PTY_WRITE_CHUNK_BYTES = 16 * 1024
+# Cap per-flush work to keep the event loop responsive.
+PTY_WRITE_FLUSH_MAX_BYTES = 256 * 1024
+# Hard cap to prevent unbounded buffering when the PTY can't accept input.
+PTY_PENDING_MAX_BYTES = 1024 * 1024
+
+
+def default_env(env: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+    base = os.environ.copy()
+    if env:
+        base.update(env)
+    base.setdefault("TERM", "xterm-256color")
+    base.setdefault("COLORTERM", "truecolor")
+    return base
+
+
+class PTYSession:
+    def __init__(self, cmd: list[str], cwd: str, env: Optional[Dict[str, str]] = None):
+        # echo=False to avoid double-printing user keystrokes
+        self.proc = PtyProcess.spawn(cmd, cwd=cwd, env=default_env(env), echo=False)
+        self.fd = self.proc.fd
+        self._set_nonblocking()
+        self.closed = False
+        self.last_active = time.time()
+
+    def _set_nonblocking(self) -> None:
+        """Ensure PTY IO doesn't block event loop."""
+        try:
+            flags = fcntl.fcntl(self.fd, fcntl.F_GETFL)
+            if not (flags & os.O_NONBLOCK):
+                fcntl.fcntl(self.fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+        except (OSError, IOError) as exc:
+            logger.debug("Failed to set PTY to non-blocking mode: %s", exc)
+
+    def resize(self, cols: int, rows: int) -> None:
+        if self.closed:
+            return
+        buf = struct.pack("HHHH", rows, cols, 0, 0)
+        fcntl.ioctl(self.fd, termios.TIOCSWINSZ, buf)
+        self.last_active = time.time()
+
+    def write(self, data: bytes) -> int:
+        """Best-effort non-blocking write; returns bytes written.
+
+        For user input, prefer ActiveSession.write_input so the loop never blocks.
+        """
+        if self.closed or not data:
+            return 0
+        try:
+            written = os.write(self.fd, data)
+        except (BlockingIOError, InterruptedError):
+            return 0
+        except OSError:
+            self.terminate()
+            return 0
+        if written:
+            self.last_active = time.time()
+        return written
+
+    def read(self, max_bytes: int = 4096) -> bytes:
+        if self.closed:
+            return b""
+        readable, _, _ = select.select([self.fd], [], [], 0)
+        if not readable:
+            return b""
+        try:
+            chunk = os.read(self.fd, max_bytes)
+        except BlockingIOError:
+            return b""
+        except OSError:
+            self.terminate()
+            return b""
+        if chunk:
+            self.last_active = time.time()
+        return chunk
+
+    def isalive(self) -> bool:
+        return not self.closed and self.proc.isalive()
+
+    def exit_code(self) -> Optional[int]:
+        return self.proc.exitstatus if not self.proc.isalive() else None
+
+    def is_stale(self, max_idle_seconds: int) -> bool:
+        return (time.time() - self.last_active) > max_idle_seconds
+
+    def terminate(self) -> None:
+        if self.closed:
+            return
+        try:
+            self.proc.terminate(force=True)
+        except (OSError, IOError) as exc:
+            logger.debug("Failed to terminate PTY process: %s", exc)
+        self.closed = True
+
+
+class ActiveSession:
+    def __init__(
+        self, session_id: str, pty: PTYSession, loop: asyncio.AbstractEventLoop
+    ):
+        self.id = session_id
+        self.pty = pty
+        # Keep a bounded scrollback buffer for reconnects.
+        # This is sized in bytes (not chunks) so behavior is predictable.
+        self._buffer_max_bytes = 512 * 1024  # 512KB
+        self._buffer_bytes = 0
+        self.buffer: collections.deque[bytes] = collections.deque()
+        self.subscribers: set[asyncio.Queue[object]] = set()
+        self.lock = asyncio.Lock()
+        self.loop = loop
+        # Buffered input keeps the event loop from blocking on PTY writes.
+        self._pending_input = bytearray()
+        self._writer_active = False
+        # Track recently-seen input IDs (from web UI) to make "send" retries idempotent.
+        self._seen_input_ids_max = 256
+        self._seen_input_ids: collections.deque[str] = collections.deque()
+        self._seen_input_ids_set: set[str] = set()
+        now = time.time()
+        self.last_output_at = now
+        self.last_input_at = now
+        self._output_since_idle = False
+        self._idle_notified_at: Optional[float] = None
+        self._alt_screen_active = False
+        self._alt_screen_tail = b""
+        self._setup_reader()
+
+    def mark_input_id_seen(self, input_id: str) -> bool:
+        """Return True if this is the first time we've seen input_id."""
+        if input_id in self._seen_input_ids_set:
+            return False
+        self._seen_input_ids_set.add(input_id)
+        self._seen_input_ids.append(input_id)
+        while len(self._seen_input_ids) > self._seen_input_ids_max:
+            dropped = self._seen_input_ids.popleft()
+            self._seen_input_ids_set.discard(dropped)
+        return True
+
+    def _setup_reader(self):
+        self.loop.add_reader(self.pty.fd, self._read_callback)
+
+    def write_input(self, data: bytes) -> None:
+        """Queue terminal input and flush without blocking the event loop."""
+        if self.pty.closed or not data:
+            return
+        if len(self._pending_input) >= PTY_PENDING_MAX_BYTES:
+            return
+        remaining = PTY_PENDING_MAX_BYTES - len(self._pending_input)
+        if len(data) > remaining:
+            data = data[-remaining:]
+        self._pending_input.extend(data)
+        self._flush_pending_input()
+
+    def _enable_writer(self) -> None:
+        if self._writer_active:
+            return
+        try:
+            self.loop.add_writer(self.pty.fd, self._flush_pending_input)
+            self._writer_active = True
+        except (OSError, IOError) as exc:
+            logger.debug("Failed to enable PTY writer: %s", exc)
+            self._writer_active = False
+
+    def _disable_writer(self) -> None:
+        if not self._writer_active:
+            return
+        try:
+            self.loop.remove_writer(self.pty.fd)
+        except (OSError, IOError) as exc:
+            logger.debug("Failed to disable PTY writer: %s", exc)
+        self._writer_active = False
+
+    def _flush_pending_input(self) -> None:
+        """Drain queued input without blocking the event loop."""
+        if self.pty.closed:
+            self._pending_input.clear()
+            self._disable_writer()
+            return
+        if not self._pending_input:
+            self._disable_writer()
+            return
+        bytes_flushed = 0
+        while self._pending_input and bytes_flushed < PTY_WRITE_FLUSH_MAX_BYTES:
+            limit = min(len(self._pending_input), PTY_WRITE_CHUNK_BYTES)
+            chunk = bytes(self._pending_input[:limit])
+            try:
+                written = os.write(self.pty.fd, chunk)
+            except BlockingIOError:
+                self._enable_writer()
+                return
+            except InterruptedError:
+                continue
+            except OSError:
+                self.close()
+                return
+            if written <= 0:
+                break
+            del self._pending_input[:written]
+            bytes_flushed += written
+            self.pty.last_active = time.time()
+        if self._pending_input:
+            self._enable_writer()
+        else:
+            self._disable_writer()
+
+    def _read_callback(self):
+        try:
+            if self.pty.closed:
+                return
+            try:
+                data = os.read(self.pty.fd, 4096)
+            except BlockingIOError:
+                return
+            if data:
+                self._update_alt_screen_state(data)
+                now = time.time()
+                self.pty.last_active = now
+                self.last_output_at = now
+                self._output_since_idle = True
+                self._idle_notified_at = None
+                self.buffer.append(data)
+                self._buffer_bytes += len(data)
+                while self._buffer_bytes > self._buffer_max_bytes and self.buffer:
+                    dropped = self.buffer.popleft()
+                    self._buffer_bytes -= len(dropped)
+                for queue in list(self.subscribers):
+                    try:
+                        queue.put_nowait(data)
+                    except asyncio.QueueFull:
+                        logger.debug(
+                            "Subscriber queue full, dropping data for session %s",
+                            self.id,
+                        )
+            else:
+                self.close()
+        except OSError:
+            self.close()
+
+    def add_subscriber(
+        self, *, include_replay_end: bool = True
+    ) -> asyncio.Queue[object]:
+        q: asyncio.Queue[object] = asyncio.Queue()
+        for chunk in self.buffer:
+            q.put_nowait(chunk)
+        if include_replay_end:
+            q.put_nowait(REPLAY_END)
+        self.subscribers.add(q)
+        return q
+
+    def refresh_alt_screen_state(self) -> None:
+        state = self._alt_screen_active
+        tail = b""
+        for chunk in self.buffer:
+            state, tail = self._scan_alt_screen_chunk(chunk, state, tail)
+        self._alt_screen_active = state
+        self._alt_screen_tail = tail
+
+    @property
+    def alt_screen_active(self) -> bool:
+        return self._alt_screen_active
+
+    def get_buffer_stats(self) -> tuple[int, int]:
+        return self._buffer_bytes, len(self.buffer)
+
+    def _scan_alt_screen_chunk(
+        self, data: bytes, state: bool, tail: bytes
+    ) -> tuple[bool, bytes]:
+        if not data:
+            return state, tail
+        haystack = tail + data
+        last_pos = -1
+        last_state: Optional[bool] = None
+        for seq, next_state in ALT_SCREEN_SEQS:
+            pos = haystack.rfind(seq)
+            if pos > last_pos:
+                last_pos = pos
+                last_state = next_state
+        if last_state is not None:
+            state = last_state
+        if ALT_SCREEN_MAX_LEN > 1:
+            tail = haystack[-(ALT_SCREEN_MAX_LEN - 1) :]
+        else:
+            tail = b""
+        return state, tail
+
+    def _update_alt_screen_state(self, data: bytes) -> None:
+        self._alt_screen_active, self._alt_screen_tail = self._scan_alt_screen_chunk(
+            data, self._alt_screen_active, self._alt_screen_tail
+        )
+
+    def remove_subscriber(self, q: asyncio.Queue[object]):
+        self.subscribers.discard(q)
+
+    def close(self):
+        try:
+            self._disable_writer()
+        except (OSError, IOError) as exc:
+            logger.debug("Failed to disable writer during close: %s", exc)
+        self._pending_input.clear()
+        if not self.pty.closed:
+            try:
+                self.loop.remove_reader(self.pty.fd)
+            except (OSError, IOError) as exc:
+                logger.debug("Failed to remove reader during close: %s", exc)
+            try:
+                self.pty.terminate()
+            except (OSError, IOError) as exc:
+                logger.debug("Failed to terminate PTY during close: %s", exc)
+        for queue in list(self.subscribers):
+            try:
+                queue.put_nowait(None)
+            except asyncio.QueueFull:
+                pass
+        self.subscribers.clear()
+
+    def mark_input_activity(self) -> None:
+        now = time.time()
+        self.last_input_at = now
+        self._output_since_idle = False
+        self._idle_notified_at = None
+
+    def should_notify_idle(self, idle_seconds: float) -> bool:
+        if idle_seconds <= 0:
+            return False
+        if not self._output_since_idle:
+            return False
+        if self._idle_notified_at is not None:
+            return False
+        if time.time() - self.last_output_at < idle_seconds:
+            return False
+        self._idle_notified_at = time.time()
+        self._output_since_idle = False
+        return True
+
+    async def wait_closed(self, timeout: float = 5.0):
+        """Wait for the underlying PTY process to terminate."""
+        start = time.time()
+        while time.time() - start < timeout:
+            if not self.pty.isalive():
+                return
+            await asyncio.sleep(0.1)

codex_autorunner/surfaces/web/review.py

@@ -0,0 +1,6 @@
+"""Backward-compatible review service wrapper.
+
+Review implementation lives under flows.review.service.
+"""
+
+from ...flows.review.service import *  # noqa: F401,F403

codex_autorunner/surfaces/web/routes/__init__.py

@@ -0,0 +1,82 @@
+"""
+Modular API routes for the codex-autorunner server.
+
+This package splits monolithic api_routes.py into focused modules:
+- base: Index, WebSocket terminal, and general endpoints
+- agents: Agent harness models and event streaming
+- app_server: App-server thread registry endpoints
+- workspace: Optional workspace docs (active_context/decisions/spec)
+- flows: Flow runtime management (start/stop/resume/status/events/artifacts)
+- messages: Inbox/message wrappers over ticket_flow dispatch + reply histories
+- repos: Run control (start/stop/resume/reset)
+- sessions: Terminal session registry endpoints
+- settings: Session settings for autorunner overrides
+- file_chat: Unified file chat (tickets + workspace docs)
+- voice: Voice transcription and config
+- terminal_images: Terminal image uploads
+"""
+
+from pathlib import Path
+
+from fastapi import APIRouter
+
+from .agents import build_agents_routes
+from .analytics import build_analytics_routes
+from .app_server import build_app_server_routes
+from .archive import build_archive_routes
+from .base import build_base_routes, build_frontend_routes
+from .file_chat import build_file_chat_routes
+from .filebox import build_filebox_routes
+from .flows import build_flow_routes
+from .messages import build_messages_routes
+from .repos import build_repos_routes
+from .review import build_review_routes
+from .sessions import build_sessions_routes
+from .settings import build_settings_routes
+from .system import build_system_routes
+from .templates import build_templates_routes
+from .terminal_images import build_terminal_image_routes
+from .usage import build_usage_routes
+from .voice import build_voice_routes
+from .workspace import build_workspace_routes
+
+
+def build_repo_router(static_dir: Path) -> APIRouter:
+    """
+    Build complete API router by combining all route modules.
+
+    Args:
+        static_dir: Path to static assets directory
+
+    Returns:
+        Combined APIRouter with all endpoints
+    """
+    router = APIRouter()
+
+    # Include all route modules
+    router.include_router(build_base_routes(static_dir))
+    router.include_router(build_analytics_routes())
+    router.include_router(build_archive_routes())
+    router.include_router(build_agents_routes())
+    router.include_router(build_app_server_routes())
+    router.include_router(build_workspace_routes())
+    router.include_router(build_flow_routes())
+    router.include_router(build_filebox_routes())
+    router.include_router(build_file_chat_routes())
+    router.include_router(build_messages_routes())
+    router.include_router(build_repos_routes())
+    router.include_router(build_review_routes())
+    router.include_router(build_sessions_routes())
+    router.include_router(build_settings_routes())
+    router.include_router(build_system_routes())
+    router.include_router(build_templates_routes())
+    router.include_router(build_terminal_image_routes())
+    router.include_router(build_usage_routes())
+    router.include_router(build_voice_routes())
+    # Include frontend routes last to avoid shadowing API routes
+    router.include_router(build_frontend_routes(static_dir))
+
+    return router
+
+
+__all__ = ["build_repo_router"]

codex_autorunner/surfaces/web/routes/agents.py

@@ -0,0 +1,138 @@
+"""
+Agent harness support routes (models + event streaming).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import StreamingResponse
+
+from ....agents.codex.harness import CodexHarness
+from ....agents.opencode.harness import OpenCodeHarness
+from ....agents.opencode.supervisor import OpenCodeSupervisorError
+from ....agents.types import ModelCatalog
+from .shared import SSE_HEADERS
+
+
+def _available_agents(request: Request) -> tuple[list[dict[str, str]], str]:
+    agents: list[dict[str, str]] = []
+    default_agent: Optional[str] = None
+
+    if getattr(request.app.state, "app_server_supervisor", None) is not None:
+        agents.append({"id": "codex", "name": "Codex", "protocol_version": "2.0"})
+        default_agent = "codex"
+
+    if getattr(request.app.state, "opencode_supervisor", None) is not None:
+        supervisor = getattr(request.app.state, "opencode_supervisor", None)
+        version = None
+        if supervisor and hasattr(supervisor, "_handles"):
+            handles = supervisor._handles
+            if handles:
+                first_handle = next(iter(handles.values()), None)
+                if first_handle:
+                    version = getattr(first_handle, "version", None)
+        agent_data = {"id": "opencode", "name": "OpenCode"}
+        if version:
+            agent_data["version"] = str(version)
+        agents.append(agent_data)
+        if default_agent is None:
+            default_agent = "opencode"
+
+    if not agents:
+        agents = [{"id": "codex", "name": "Codex", "protocol_version": "2.0"}]
+        default_agent = "codex"
+
+    return agents, default_agent or "codex"
+
+
+def _serialize_model_catalog(catalog: ModelCatalog) -> dict[str, Any]:
+    return {
+        "default_model": catalog.default_model,
+        "models": [
+            {
+                "id": model.id,
+                "display_name": model.display_name,
+                "supports_reasoning": model.supports_reasoning,
+                "reasoning_options": list(model.reasoning_options),
+            }
+            for model in catalog.models
+        ],
+    }
+
+
+def build_agents_routes() -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/api/agents")
+    def list_agents(request: Request) -> dict[str, Any]:
+        agents, default_agent = _available_agents(request)
+        return {"agents": agents, "default": default_agent}
+
+    @router.get("/api/agents/{agent}/models")
+    async def list_agent_models(agent: str, request: Request):
+        agent_id = (agent or "").strip().lower()
+        engine = request.app.state.engine
+        if agent_id == "codex":
+            supervisor = request.app.state.app_server_supervisor
+            events = request.app.state.app_server_events
+            if supervisor is None:
+                raise HTTPException(status_code=404, detail="Codex harness unavailable")
+            codex_harness = CodexHarness(supervisor, events)
+            catalog = await codex_harness.model_catalog(engine.repo_root)
+            return _serialize_model_catalog(catalog)
+        if agent_id == "opencode":
+            supervisor = getattr(request.app.state, "opencode_supervisor", None)
+            if supervisor is None:
+                raise HTTPException(
+                    status_code=404, detail="OpenCode harness unavailable"
+                )
+            try:
+                opencode_harness = OpenCodeHarness(supervisor)
+                catalog = await opencode_harness.model_catalog(engine.repo_root)
+                return _serialize_model_catalog(catalog)
+            except OpenCodeSupervisorError as exc:
+                raise HTTPException(status_code=502, detail=str(exc)) from exc
+            except Exception as exc:
+                raise HTTPException(status_code=502, detail=str(exc)) from exc
+        raise HTTPException(status_code=404, detail="Unknown agent")
+
+    @router.get("/api/agents/{agent}/turns/{turn_id}/events")
+    async def stream_agent_turn_events(
+        agent: str, turn_id: str, request: Request, thread_id: Optional[str] = None
+    ):
+        agent_id = (agent or "").strip().lower()
+        if agent_id == "codex":
+            events = getattr(request.app.state, "app_server_events", None)
+            if events is None:
+                raise HTTPException(status_code=404, detail="Codex events unavailable")
+            if not thread_id:
+                raise HTTPException(status_code=400, detail="thread_id is required")
+            return StreamingResponse(
+                events.stream(thread_id, turn_id),
+                media_type="text/event-stream",
+                headers=SSE_HEADERS,
+            )
+        if agent_id == "opencode":
+            if not thread_id:
+                raise HTTPException(status_code=400, detail="thread_id is required")
+            supervisor = getattr(request.app.state, "opencode_supervisor", None)
+            if supervisor is None:
+                raise HTTPException(
+                    status_code=404, detail="OpenCode events unavailable"
+                )
+            harness = OpenCodeHarness(supervisor)
+            return StreamingResponse(
+                harness.stream_events(
+                    request.app.state.engine.repo_root, thread_id, turn_id
+                ),
+                media_type="text/event-stream",
+                headers=SSE_HEADERS,
+            )
+        raise HTTPException(status_code=404, detail="Unknown agent")
+
+    return router
+
+
+__all__ = ["build_agents_routes"]