codex-autorunner 0.1.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

codex_autorunner/surfaces/web/routes/shared.py

@@ -0,0 +1,280 @@
+"""
+Shared utilities for route modules.
+"""
+
+import asyncio
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+from ....core.locks import (
+    DEFAULT_RUNNER_CMD_HINTS,
+    assess_lock,
+    process_is_active,
+    read_lock_info,
+)
+from ....core.state import load_state
+from ....core.utils import (
+    apply_codex_options,
+    extract_flag_value,
+    resolve_opencode_binary,
+    supports_reasoning,
+)
+
+BYPASS_FLAGS = {
+    "--yolo",
+    "--dangerously-bypass-approvals-and-sandbox",
+}
+
+SSE_HEADERS = {
+    "Cache-Control": "no-cache",
+    "X-Accel-Buffering": "no",
+    "Connection": "keep-alive",
+    "Content-Encoding": "identity",
+}
+
+
+async def _interruptible_sleep(
+    seconds: float, shutdown_event: Optional[asyncio.Event]
+) -> bool:
+    """Sleep that can be interrupted by shutdown_event. Returns True if interrupted."""
+    if shutdown_event is None:
+        await asyncio.sleep(seconds)
+        return False
+    try:
+        await asyncio.wait_for(shutdown_event.wait(), timeout=seconds)
+        return True  # Event was set
+    except asyncio.TimeoutError:
+        return False  # Normal timeout, continue
+
+
+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,
+    model: Optional[str] = None,
+    reasoning: Optional[str] = None,
+) -> 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:
+        cmd = [
+            engine.config.codex_binary,
+            bypass_flag,
+            "resume",
+            *terminal_args,
+        ]
+        return apply_codex_options(
+            cmd,
+            model=model,
+            reasoning=reasoning,
+            supports_reasoning=supports_reasoning(engine.config.codex_binary),
+        )
+
+    cmd = [
+        engine.config.codex_binary,
+        bypass_flag,
+        *terminal_args,
+    ]
+    return apply_codex_options(
+        cmd,
+        model=model,
+        reasoning=reasoning,
+        supports_reasoning=supports_reasoning(engine.config.codex_binary),
+    )
+
+
+def build_opencode_terminal_cmd(binary: str, model: Optional[str] = None) -> list[str]:
+    resolved = resolve_opencode_binary(binary)
+    cmd = [resolved or binary]
+    if model:
+        cmd.extend(["--model", model])
+    return cmd
+
+
+def resolve_runner_status(engine, state) -> tuple[str, Optional[int], bool]:
+    pid = state.runner_pid
+    alive_pid = pid if pid and process_is_active(pid) else None
+    if alive_pid is None:
+        info = read_lock_info(engine.lock_path)
+        if info.pid and process_is_active(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
+
+
+def resolve_lock_payload(engine) -> dict[str, object]:
+    assessment = assess_lock(
+        engine.lock_path,
+        expected_cmd_substrings=DEFAULT_RUNNER_CMD_HINTS,
+    )
+    return {
+        "lock_present": engine.lock_path.exists(),
+        "lock_pid": assessment.pid,
+        "lock_freeable": assessment.freeable,
+        "lock_freeable_reason": assessment.reason,
+    }
+
+
+async def log_stream(
+    log_path: Path,
+    heartbeat_interval: float = 15.0,
+    shutdown_event: Optional[asyncio.Event] = None,
+    max_seconds: float = 60.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()
+    start_time = time.monotonic()
+    with log_path.open("r", encoding="utf-8") as f:
+        f.seek(0, 2)
+        while True:
+            if shutdown_event is not None and shutdown_event.is_set():
+                return
+            if time.monotonic() - start_time > max_seconds:
+                yield "event: timeout\ndata: Stream timeout exceeded\n\n"
+                return
+            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
+                if await _interruptible_sleep(0.5, shutdown_event):
+                    return
+
+
+async def jsonl_event_stream(
+    path: Path,
+    *,
+    event_name: str = "message",
+    heartbeat_interval: float = 15.0,
+    shutdown_event: Optional[asyncio.Event] = None,
+):
+    """SSE stream generator for JSONL event files."""
+    last_emit_at = time.monotonic()
+    position = 0
+    while True:
+        if shutdown_event is not None and shutdown_event.is_set():
+            return
+        if not path.exists():
+            now = time.monotonic()
+            if now - last_emit_at >= heartbeat_interval:
+                yield ": ping\n\n"
+                last_emit_at = now
+            if await _interruptible_sleep(1.0, shutdown_event):
+                return
+            continue
+        try:
+            with path.open("r", encoding="utf-8") as handle:
+                handle.seek(position)
+                while True:
+                    if shutdown_event is not None and shutdown_event.is_set():
+                        return
+                    line = handle.readline()
+                    if line:
+                        position = handle.tell()
+                        payload = line.strip()
+                        if payload:
+                            yield f"event: {event_name}\ndata: {payload}\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
+                        if await _interruptible_sleep(0.5, shutdown_event):
+                            return
+        except OSError:
+            if await _interruptible_sleep(1.0, shutdown_event):
+                return
+
+
+async def state_stream(
+    engine,
+    manager,
+    logger=None,
+    heartbeat_interval: float = 15.0,
+    shutdown_event: Optional[asyncio.Event] = None,
+    max_seconds: float = 60.0,
+):
+    """SSE stream generator for state updates."""
+    last_payload = None
+    last_error_log_at = 0.0
+    last_emit_at = time.monotonic()
+    start_time = 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:
+        if shutdown_event is not None and shutdown_event.is_set():
+            return
+        if time.monotonic() - start_time > max_seconds:
+            yield "event: timeout\ndata: Stream timeout exceeded\n\n"
+            return
+        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)
+            lock_payload = resolve_lock_payload(engine)
+            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,
+                **lock_payload,
+                "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
+        if await _interruptible_sleep(1.0, shutdown_event):
+            return

codex_autorunner/surfaces/web/routes/system.py

@@ -0,0 +1,196 @@
+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 ....core.update_paths import resolve_update_paths
+from ..schemas import (
+    SystemHealthResponse,
+    SystemUpdateCheckResponse,
+    SystemUpdateRequest,
+    SystemUpdateResponse,
+    SystemUpdateStatusResponse,
+)
+from ..static_assets import missing_static_assets
+from ..static_refresh import refresh_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:
+            if refresh_static_assets(request.app):
+                static_dir = getattr(
+                    getattr(request.app, "state", None), "static_dir", None
+                )
+                if isinstance(static_dir, Path):
+                    missing = await asyncio.to_thread(missing_static_assets, static_dir)
+                else:
+                    missing = ["index.html"]
+            if not missing:
+                return {
+                    "status": "ok",
+                    "mode": mode,
+                    "base_path": base_path,
+                    "asset_version": asset_version,
+                }
+            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"
+        skip_checks = False
+        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
+            skip_checks = bool(getattr(config, "update_skip_checks", False))
+        elif config is not None:
+            skip_checks = bool(getattr(config, "update_skip_checks", False))
+
+        update_dir = resolve_update_paths(config=config).cache_dir
+
+        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,
+                skip_checks=skip_checks,
+            )
+            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/surfaces/web/routes/usage.py

@@ -0,0 +1,89 @@
+"""
+Usage routes: token usage summaries for repo/hub.
+
+Moved out of the legacy docs routes during the workspace + file chat cutover.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Request
+
+from ....core.usage import (
+    UsageError,
+    default_codex_home,
+    get_repo_usage_series_cached,
+    get_repo_usage_summary_cached,
+    parse_iso_datetime,
+)
+from ..schemas import RepoUsageResponse, UsageSeriesResponse
+
+
+def build_usage_routes() -> APIRouter:
+    router = APIRouter(prefix="/api", tags=["usage"])
+
+    @router.get("/usage", response_model=RepoUsageResponse)
+    def get_usage(
+        request: Request, since: Optional[str] = None, until: Optional[str] = None
+    ):
+        engine = request.app.state.engine
+        try:
+            since_dt = parse_iso_datetime(since)
+            until_dt = parse_iso_datetime(until)
+        except UsageError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        summary, status = get_repo_usage_summary_cached(
+            engine.repo_root,
+            default_codex_home(),
+            config=engine.config,
+            since=since_dt,
+            until=until_dt,
+        )
+        return {
+            "mode": "repo",
+            "repo": str(engine.repo_root),
+            "codex_home": str(default_codex_home()),
+            "since": since,
+            "until": until,
+            "status": status,
+            **summary.to_dict(),
+        }
+
+    @router.get("/usage/series", response_model=UsageSeriesResponse)
+    def get_usage_series(
+        request: Request,
+        since: Optional[str] = None,
+        until: Optional[str] = None,
+        bucket: str = "day",
+        segment: str = "none",
+    ):
+        engine = request.app.state.engine
+        try:
+            since_dt = parse_iso_datetime(since)
+            until_dt = parse_iso_datetime(until)
+        except UsageError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        try:
+            series, status = get_repo_usage_series_cached(
+                engine.repo_root,
+                default_codex_home(),
+                config=engine.config,
+                since=since_dt,
+                until=until_dt,
+                bucket=bucket,
+                segment=segment,
+            )
+        except UsageError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {
+            "mode": "repo",
+            "repo": str(engine.repo_root),
+            "codex_home": str(default_codex_home()),
+            "since": since,
+            "until": until,
+            "status": status,
+            **series,
+        }
+
+    return router

codex_autorunner/surfaces/web/routes/voice.py

@@ -0,0 +1,120 @@
+"""
+Voice transcription and configuration routes.
+"""
+
+import asyncio
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, File, HTTPException, Request, UploadFile
+
+from ....voice import VoiceService, VoiceServiceError
+
+logger = logging.getLogger("codex_autorunner.routes.voice")
+
+
+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,
+                "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 (ValueError, TypeError, OSError) as exc:
+                logger.debug("Failed to create VoiceService for config: %s", exc)
+                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,
+                    "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