codex-autorunner 0.1.0__py3-none-any.whl

codex_autorunner/routes/sessions.py

@@ -0,0 +1,137 @@
+"""
+Terminal session registry routes.
+"""
+
+import time
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException, Request
+
+from ..core.state import persist_session_registry
+from ..web.schemas import (
+    SessionsResponse,
+    SessionStopRequest,
+    SessionStopResponse,
+)
+
+
+def _relative_repo_path(repo_path: str, repo_root: Path) -> str:
+    path = Path(repo_path)
+    if not path.is_absolute():
+        return repo_path
+    try:
+        rel = path.resolve().relative_to(repo_root)
+        return rel.as_posix() or "."
+    except Exception:
+        return path.name
+
+
+def _allow_abs_paths(request: Request, include_abs_paths: bool) -> bool:
+    if not include_abs_paths:
+        return False
+    return bool(getattr(request.app.state, "auth_token", None))
+
+
+def _session_payload(
+    session_id: str,
+    record,
+    terminal_sessions: dict,
+    repo_root: Path,
+    include_abs_paths: bool,
+) -> dict:
+    active = terminal_sessions.get(session_id)
+    alive = bool(active and active.pty.isalive())
+    payload = {
+        "session_id": session_id,
+        "repo_path": _relative_repo_path(record.repo_path, repo_root),
+        "created_at": record.created_at,
+        "last_seen_at": record.last_seen_at,
+        "status": record.status,
+        "alive": alive,
+    }
+    if include_abs_paths:
+        payload["abs_repo_path"] = record.repo_path
+    return payload
+
+
+def build_sessions_routes() -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/api/sessions", response_model=SessionsResponse)
+    def list_sessions(request: Request, include_abs_paths: bool = False):
+        terminal_sessions = request.app.state.terminal_sessions
+        session_registry = request.app.state.session_registry
+        repo_to_session = request.app.state.repo_to_session
+        repo_root = Path(request.app.state.engine.repo_root)
+        allow_abs = _allow_abs_paths(request, include_abs_paths)
+        sessions = [
+            _session_payload(
+                session_id, record, terminal_sessions, repo_root, allow_abs
+            )
+            for session_id, record in session_registry.items()
+        ]
+        repo_to_session_payload = {
+            _relative_repo_path(repo_path, repo_root): session_id
+            for repo_path, session_id in repo_to_session.items()
+        }
+        payload = {
+            "sessions": sessions,
+            "repo_to_session": repo_to_session_payload,
+        }
+        if allow_abs:
+            payload["abs_repo_to_session"] = dict(repo_to_session)
+        return {
+            **payload,
+        }
+
+    @router.post("/api/sessions/stop", response_model=SessionStopResponse)
+    async def stop_session(request: Request, payload: SessionStopRequest):
+        session_id = payload.session_id
+        repo_path = payload.repo_path
+        if not session_id and not repo_path:
+            raise HTTPException(
+                status_code=400, detail="Provide session_id or repo_path"
+            )
+
+        terminal_sessions = request.app.state.terminal_sessions
+        session_registry = request.app.state.session_registry
+        repo_to_session = request.app.state.repo_to_session
+        terminal_lock = request.app.state.terminal_lock
+        engine = request.app.state.engine
+
+        if repo_path and isinstance(repo_path, str):
+            repo_root = Path(request.app.state.engine.repo_root)
+            normalized_repo_path = repo_path.strip()
+            if normalized_repo_path:
+                candidate = Path(normalized_repo_path)
+                if not candidate.is_absolute():
+                    candidate = (repo_root / candidate).resolve()
+                normalized_repo_path = str(candidate)
+            session_id = repo_to_session.get(
+                normalized_repo_path
+            ) or repo_to_session.get(repo_path)
+        if not isinstance(session_id, str) or not session_id:
+            raise HTTPException(status_code=404, detail="Session not found")
+        if session_id not in session_registry and session_id not in terminal_sessions:
+            raise HTTPException(status_code=404, detail="Session not found")
+
+        async with terminal_lock:
+            session = terminal_sessions.get(session_id)
+            if session:
+                session.close()
+                await session.wait_closed()
+                terminal_sessions.pop(session_id, None)
+            session_registry.pop(session_id, None)
+            repo_to_session = {
+                repo: sid for repo, sid in repo_to_session.items() if sid != session_id
+            }
+            request.app.state.repo_to_session = repo_to_session
+            persist_session_registry(
+                engine.state_path, session_registry, repo_to_session
+            )
+            request.app.state.session_state_last_write = time.time()
+            request.app.state.session_state_dirty = False
+
+        return {"status": "stopped", "session_id": session_id}
+
+    return router

codex_autorunner/routes/shared.py

@@ -0,0 +1,137 @@
+"""
+Shared utilities for route modules.
+"""
+
+import asyncio
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+from ..codex_cli import extract_flag_value
+from ..core.locks import process_alive, read_lock_info
+from ..core.state import load_state
+
+BYPASS_FLAGS = {
+    "--yolo",
+    "--dangerously-bypass-approvals-and-sandbox",
+}
+
+
+def _extract_bypass_flag(args: list[str]) -> tuple[str, list[str]]:
+    chosen = None
+    for arg in args:
+        if arg in BYPASS_FLAGS:
+            chosen = arg
+            break
+    filtered = [arg for arg in args if arg not in BYPASS_FLAGS]
+    return chosen or "--yolo", filtered
+
+
+def build_codex_terminal_cmd(engine, *, resume_mode: bool) -> list[str]:
+    """
+    Build the subprocess argv for launching the Codex interactive CLI inside a PTY.
+    """
+    bypass_flag, terminal_args = _extract_bypass_flag(
+        list(engine.config.codex_terminal_args)
+    )
+    if resume_mode:
+        return [
+            engine.config.codex_binary,
+            bypass_flag,
+            "resume",
+            *terminal_args,
+        ]
+
+    cmd = [
+        engine.config.codex_binary,
+        bypass_flag,
+        *terminal_args,
+    ]
+    return cmd
+
+
+def resolve_runner_status(engine, state) -> tuple[str, Optional[int], bool]:
+    pid = state.runner_pid
+    alive_pid = pid if pid and process_alive(pid) else None
+    if alive_pid is None:
+        info = read_lock_info(engine.lock_path)
+        if info.pid and process_alive(info.pid):
+            alive_pid = info.pid
+    running = alive_pid is not None
+    status = state.status
+    if status == "running" and not running:
+        status = "idle"
+    runner_pid = alive_pid if running else None
+    return status, runner_pid, running
+
+
+async def log_stream(log_path: Path, heartbeat_interval: float = 15.0):
+    """SSE stream generator for log file tailing."""
+    if not log_path.exists():
+        yield "data: log file not found\n\n"
+        return
+    last_emit_at = time.monotonic()
+    with log_path.open("r", encoding="utf-8") as f:
+        f.seek(0, 2)
+        while True:
+            line = f.readline()
+            if line:
+                yield f"data: {line.rstrip()}\n\n"
+                last_emit_at = time.monotonic()
+            else:
+                now = time.monotonic()
+                if now - last_emit_at >= heartbeat_interval:
+                    yield ": ping\n\n"
+                    last_emit_at = now
+                await asyncio.sleep(0.5)
+
+
+async def state_stream(engine, manager, logger=None, heartbeat_interval: float = 15.0):
+    """SSE stream generator for state updates."""
+    last_payload = None
+    last_error_log_at = 0.0
+    last_emit_at = time.monotonic()
+    terminal_idle_timeout_seconds = engine.config.terminal_idle_timeout_seconds
+    codex_model = engine.config.codex_model or extract_flag_value(
+        engine.config.codex_args, "--model"
+    )
+    while True:
+        emitted = False
+        try:
+            state = await asyncio.to_thread(load_state, engine.state_path)
+            outstanding, done = await asyncio.to_thread(engine.docs.todos)
+            status, runner_pid, running = resolve_runner_status(engine, state)
+            payload = {
+                "last_run_id": state.last_run_id,
+                "status": status,
+                "last_exit_code": state.last_exit_code,
+                "last_run_started_at": state.last_run_started_at,
+                "last_run_finished_at": state.last_run_finished_at,
+                "outstanding_count": len(outstanding),
+                "done_count": len(done),
+                "running": running,
+                "runner_pid": runner_pid,
+                "terminal_idle_timeout_seconds": terminal_idle_timeout_seconds,
+                "codex_model": codex_model or "auto",
+            }
+            if payload != last_payload:
+                yield f"data: {json.dumps(payload)}\n\n"
+                last_payload = payload
+                last_emit_at = time.monotonic()
+                emitted = True
+        except Exception:
+            # Don't spam logs, but don't swallow silently either.
+            now = time.time()
+            if logger is not None and (now - last_error_log_at) > 60:
+                last_error_log_at = now
+                try:
+                    logger.warning("state stream error", exc_info=True)
+                except Exception:
+                    pass
+        if not emitted:
+            now = time.monotonic()
+            if now - last_emit_at >= heartbeat_interval:
+                yield ": ping\n\n"
+                last_emit_at = now
+        await asyncio.sleep(1.0)

codex_autorunner/routes/system.py

@@ -0,0 +1,175 @@
+import asyncio
+import logging
+from pathlib import Path
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+
+from ..core import update as update_core
+from ..core.config import HubConfig
+from ..core.update import (
+    UpdateInProgressError,
+    _normalize_update_ref,
+    _normalize_update_target,
+    _read_update_status,
+    _spawn_update_process,
+    _system_update_check,
+)
+from ..web.schemas import (
+    SystemHealthResponse,
+    SystemUpdateCheckResponse,
+    SystemUpdateRequest,
+    SystemUpdateResponse,
+    SystemUpdateStatusResponse,
+)
+from ..web.static_assets import missing_static_assets
+
+_pid_is_running = update_core._pid_is_running
+_system_update_worker = update_core._system_update_worker
+_update_lock_active = update_core._update_lock_active
+_update_lock_path = update_core._update_lock_path
+_update_status_path = update_core._update_status_path
+shutil = update_core.shutil
+subprocess = update_core.subprocess
+
+
+def build_system_routes() -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/health", response_model=SystemHealthResponse)
+    async def system_health(request: Request):
+        try:
+            config = request.app.state.config
+        except AttributeError:
+            config = None
+        mode = "hub" if isinstance(config, HubConfig) else "repo"
+        base_path = getattr(request.app.state, "base_path", "")
+        asset_version = getattr(request.app.state, "asset_version", None)
+        static_dir = getattr(getattr(request.app, "state", None), "static_dir", None)
+        if not isinstance(static_dir, Path):
+            return JSONResponse(
+                {
+                    "status": "error",
+                    "detail": "Static UI assets missing; reinstall package",
+                    "mode": mode,
+                    "base_path": base_path,
+                },
+                status_code=500,
+            )
+        missing = await asyncio.to_thread(missing_static_assets, static_dir)
+        if missing:
+            return JSONResponse(
+                {
+                    "status": "error",
+                    "detail": "Static UI assets missing; reinstall package",
+                    "missing": missing,
+                    "mode": mode,
+                    "base_path": base_path,
+                },
+                status_code=500,
+            )
+        return {
+            "status": "ok",
+            "mode": mode,
+            "base_path": base_path,
+            "asset_version": asset_version,
+        }
+
+    @router.get("/system/update/check", response_model=SystemUpdateCheckResponse)
+    async def system_update_check(request: Request):
+        """
+        Check if an update is available by comparing local git state vs remote.
+        If local git state is unavailable, report that an update may be available.
+        """
+        try:
+            config = request.app.state.config
+        except AttributeError:
+            config = None
+
+        repo_url = "https://github.com/Git-on-my-level/codex-autorunner.git"
+        repo_ref = "main"
+        if config and isinstance(config, HubConfig):
+            configured_url = getattr(config, "update_repo_url", None)
+            if configured_url:
+                repo_url = configured_url
+            configured_ref = getattr(config, "update_repo_ref", None)
+            if configured_ref:
+                repo_ref = configured_ref
+
+        try:
+            return await asyncio.to_thread(
+                _system_update_check, repo_url=repo_url, repo_ref=repo_ref
+            )
+        except Exception as e:
+            logger = getattr(getattr(request.app, "state", None), "logger", None)
+            if logger:
+                logger.error("Update check error: %s", e, exc_info=True)
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
+    @router.post("/system/update", response_model=SystemUpdateResponse)
+    async def system_update(
+        request: Request, payload: Optional[SystemUpdateRequest] = None
+    ):
+        """
+        Pull latest code and refresh the running service.
+        This will restart the server if successful.
+        """
+        try:
+            config = request.app.state.config
+        except AttributeError:
+            config = None
+
+        # Determine URL
+        repo_url = "https://github.com/Git-on-my-level/codex-autorunner.git"
+        repo_ref = "main"
+        if config and isinstance(config, HubConfig):
+            configured_url = getattr(config, "update_repo_url", None)
+            if configured_url:
+                repo_url = configured_url
+            configured_ref = getattr(config, "update_repo_ref", None)
+            if configured_ref:
+                repo_ref = configured_ref
+
+        home_dot_car = Path.home() / ".codex-autorunner"
+        update_dir = home_dot_car / "update_cache"
+
+        try:
+            target_raw = payload.target if payload else None
+            if target_raw is None:
+                target_raw = request.query_params.get("target")
+            update_target = _normalize_update_target(target_raw)
+            logger = getattr(getattr(request.app, "state", None), "logger", None)
+            if logger is None:
+                logger = logging.getLogger("codex_autorunner.system_update")
+            await asyncio.to_thread(
+                _spawn_update_process,
+                repo_url=repo_url,
+                repo_ref=_normalize_update_ref(repo_ref),
+                update_dir=update_dir,
+                logger=logger,
+                update_target=update_target,
+            )
+            return {
+                "status": "ok",
+                "message": f"Update started ({update_target}). Service will restart shortly.",
+                "target": update_target,
+            }
+        except UpdateInProgressError as exc:
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        except Exception as e:
+            logger = getattr(getattr(request.app, "state", None), "logger", None)
+            if logger:
+                logger.error("Update error: %s", e, exc_info=True)
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
+    @router.get("/system/update/status", response_model=SystemUpdateStatusResponse)
+    async def system_update_status():
+        status = await asyncio.to_thread(_read_update_status)
+        if status is None:
+            return {"status": "unknown", "message": "No update status recorded."}
+        return status
+
+    return router

codex_autorunner/routes/terminal_images.py

@@ -0,0 +1,107 @@
+"""
+Terminal image upload routes.
+"""
+
+import secrets
+import time
+from pathlib import Path
+from typing import Optional
+
+from fastapi import APIRouter, File, HTTPException, Request, UploadFile
+
+MAX_IMAGE_BYTES = 10 * 1024 * 1024
+ALLOWED_CONTENT_TYPES = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/heic": ".heic",
+    "image/heif": ".heif",
+}
+ALLOWED_EXTS = set(ALLOWED_CONTENT_TYPES.values())
+
+
+def _choose_image_extension(
+    filename: Optional[str], content_type: Optional[str]
+) -> str:
+    if filename:
+        suffix = Path(filename).suffix.lower()
+        if suffix in ALLOWED_EXTS:
+            return suffix
+    if content_type:
+        mapped = ALLOWED_CONTENT_TYPES.get(content_type.lower())
+        if mapped:
+            return mapped
+    return ".img"
+
+
+def build_terminal_image_routes() -> APIRouter:
+    router = APIRouter()
+
+    def _allow_abs_paths(request: Request, include_abs_paths: bool) -> bool:
+        if not include_abs_paths:
+            return False
+        return bool(getattr(request.app.state, "auth_token", None))
+
+    @router.post("/api/terminal/image")
+    async def upload_terminal_image(
+        request: Request,
+        file: UploadFile = File(...),
+        include_abs_paths: bool = False,
+    ):
+        if not file:
+            raise HTTPException(status_code=400, detail="missing image")
+
+        content_type = (file.content_type or "").lower()
+        content_type = content_type.split(";", 1)[0].strip()
+        filename = file.filename or ""
+        suffix = Path(filename).suffix.lower()
+        looks_like_image = False
+        if content_type.startswith("image/"):
+            looks_like_image = True
+        elif suffix in ALLOWED_EXTS:
+            looks_like_image = True
+        if not looks_like_image:
+            raise HTTPException(status_code=400, detail="unsupported content type")
+
+        try:
+            data = await file.read()
+        except Exception as exc:
+            raise HTTPException(
+                status_code=400, detail="unable to read upload"
+            ) from exc
+
+        if not data:
+            raise HTTPException(status_code=400, detail="empty upload")
+        if len(data) > MAX_IMAGE_BYTES:
+            raise HTTPException(status_code=413, detail="image too large")
+
+        engine = request.app.state.engine
+        repo_root = Path(engine.repo_root)
+        images_dir = repo_root / ".codex-autorunner" / "uploads" / "terminal-images"
+        images_dir.mkdir(parents=True, exist_ok=True)
+
+        ext = _choose_image_extension(filename, content_type)
+        token = secrets.token_hex(6)
+        name = f"terminal-{int(time.time())}-{token}{ext}"
+        path = images_dir / name
+        try:
+            path.write_bytes(data)
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail="failed to save image") from exc
+
+        rel_path = path.relative_to(repo_root).as_posix()
+        payload = {
+            "status": "ok",
+            "path": rel_path,
+            "filename": name,
+        }
+        if _allow_abs_paths(request, include_abs_paths):
+            payload["abs_path"] = str(path)
+        return payload
+
+    return router
+
+
+__all__ = ["build_terminal_image_routes"]

codex_autorunner/routes/voice.py

@@ -0,0 +1,128 @@
+"""
+Voice transcription and configuration routes.
+"""
+
+import asyncio
+from typing import Optional
+
+from fastapi import APIRouter, File, HTTPException, Request, UploadFile
+
+from ..voice import VoiceService, VoiceServiceError
+
+
+def build_voice_routes() -> APIRouter:
+    """Build routes for voice transcription and config."""
+    router = APIRouter()
+
+    @router.get("/api/voice/config")
+    def get_voice_config(request: Request):
+        voice_service: Optional[VoiceService] = request.app.state.voice_service
+        voice_config = request.app.state.voice_config
+        missing_reason = getattr(request.app.state, "voice_missing_reason", None)
+        if missing_reason:
+            return {
+                "enabled": False,
+                "provider": voice_config.provider,
+                "latency_mode": voice_config.latency_mode,
+                "chunk_ms": voice_config.chunk_ms,
+                "sample_rate": voice_config.sample_rate,
+                "warn_on_remote_api": voice_config.warn_on_remote_api,
+                "has_api_key": False,
+                "api_key_env": (
+                    voice_config.providers.get(
+                        voice_config.provider or "openai_whisper", {}
+                    )
+                    or {}
+                ).get("api_key_env", "OPENAI_API_KEY"),
+                "push_to_talk": {
+                    "max_ms": voice_config.push_to_talk.max_ms,
+                    "silence_auto_stop_ms": voice_config.push_to_talk.silence_auto_stop_ms,
+                    "min_hold_ms": voice_config.push_to_talk.min_hold_ms,
+                },
+                "missing_extra": missing_reason,
+            }
+        if voice_service is None:
+            # Degrade gracefully: still return config to the UI even if service init failed.
+            try:
+                return VoiceService(
+                    voice_config, logger=request.app.state.logger
+                ).config_payload()
+            except Exception:
+                return {
+                    "enabled": False,
+                    "provider": voice_config.provider,
+                    "latency_mode": voice_config.latency_mode,
+                    "chunk_ms": voice_config.chunk_ms,
+                    "sample_rate": voice_config.sample_rate,
+                    "warn_on_remote_api": voice_config.warn_on_remote_api,
+                    "has_api_key": False,
+                    "api_key_env": (
+                        voice_config.providers.get(
+                            voice_config.provider or "openai_whisper", {}
+                        )
+                        or {}
+                    ).get("api_key_env", "OPENAI_API_KEY"),
+                    "push_to_talk": {
+                        "max_ms": voice_config.push_to_talk.max_ms,
+                        "silence_auto_stop_ms": voice_config.push_to_talk.silence_auto_stop_ms,
+                        "min_hold_ms": voice_config.push_to_talk.min_hold_ms,
+                    },
+                }
+        return voice_service.config_payload()
+
+    @router.post("/api/voice/transcribe")
+    async def transcribe_voice(
+        request: Request,
+        file: Optional[UploadFile] = File(None),
+        language: Optional[str] = None,
+    ):
+        voice_service: Optional[VoiceService] = request.app.state.voice_service
+        voice_config = request.app.state.voice_config
+        missing_reason = getattr(request.app.state, "voice_missing_reason", None)
+        if missing_reason:
+            raise HTTPException(status_code=503, detail=missing_reason)
+        if not voice_service or not voice_config.enabled:
+            raise HTTPException(status_code=400, detail="Voice is disabled")
+
+        filename: Optional[str] = None
+        content_type: Optional[str] = None
+        if file is not None:
+            filename = file.filename
+            content_type = file.content_type
+            try:
+                audio_bytes = await file.read()
+            except Exception as exc:
+                raise HTTPException(
+                    status_code=400, detail="Unable to read audio upload"
+                ) from exc
+        else:
+            audio_bytes = await request.body()
+        try:
+            result = await asyncio.to_thread(
+                voice_service.transcribe,
+                audio_bytes,
+                client="web",
+                user_agent=request.headers.get("user-agent"),
+                language=language,
+                filename=filename,
+                content_type=content_type,
+            )
+        except VoiceServiceError as exc:
+            if exc.reason == "unauthorized":
+                status = 401
+            elif exc.reason == "forbidden":
+                status = 403
+            elif exc.reason == "audio_too_large":
+                status = 413
+            elif exc.reason == "rate_limited":
+                status = 429
+            else:
+                status = (
+                    400
+                    if exc.reason in ("disabled", "empty_audio", "invalid_audio")
+                    else 502
+                )
+            raise HTTPException(status_code=status, detail=exc.detail) from exc
+        return {"status": "ok", **result}
+
+    return router