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

codex_autorunner/routes/settings.py

@@ -1,169 +1,3 @@
-"""
-Session settings routes for autorunner overrides.
-"""
+"""Backward-compatible settings routes."""
 
-from typing import Optional
-
-from fastapi import APIRouter, HTTPException, Request
-
-from ..core.state import RunnerState, load_state, save_state, state_lock
-from ..web.schemas import SessionSettingsRequest, SessionSettingsResponse
-
-ALLOWED_APPROVAL_POLICIES = {"never", "unlessTrusted"}
-ALLOWED_SANDBOX_MODES = {"dangerFullAccess", "workspaceWrite"}
-
-
-def _normalize_optional_string(value: object, field: str) -> Optional[str]:
-    if value is None:
-        return None
-    if not isinstance(value, str):
-        raise HTTPException(status_code=400, detail=f"{field} must be a string")
-    cleaned = value.strip()
-    return cleaned or None
-
-
-def build_settings_routes() -> APIRouter:
-    router = APIRouter()
-
-    @router.get("/api/session/settings", response_model=SessionSettingsResponse)
-    def get_session_settings(request: Request):
-        state = load_state(request.app.state.engine.state_path)
-        return {
-            "autorunner_model_override": state.autorunner_model_override,
-            "autorunner_effort_override": state.autorunner_effort_override,
-            "autorunner_approval_policy": state.autorunner_approval_policy,
-            "autorunner_sandbox_mode": state.autorunner_sandbox_mode,
-            "autorunner_workspace_write_network": state.autorunner_workspace_write_network,
-            "runner_stop_after_runs": state.runner_stop_after_runs,
-        }
-
-    @router.post("/api/session/settings", response_model=SessionSettingsResponse)
-    def update_session_settings(request: Request, payload: SessionSettingsRequest):
-        updates = payload.model_dump(exclude_unset=True)
-        engine = request.app.state.engine
-        manager = request.app.state.manager
-        registry = request.app.state.app_server_threads
-        with state_lock(engine.state_path):
-            state = load_state(engine.state_path)
-            model_override = (
-                _normalize_optional_string(
-                    updates.get("autorunner_model_override"),
-                    "autorunner_model_override",
-                )
-                if "autorunner_model_override" in updates
-                else state.autorunner_model_override
-            )
-            effort_override = (
-                _normalize_optional_string(
-                    updates.get("autorunner_effort_override"),
-                    "autorunner_effort_override",
-                )
-                if "autorunner_effort_override" in updates
-                else state.autorunner_effort_override
-            )
-            approval_policy = (
-                _normalize_optional_string(
-                    updates.get("autorunner_approval_policy"),
-                    "autorunner_approval_policy",
-                )
-                if "autorunner_approval_policy" in updates
-                else state.autorunner_approval_policy
-            )
-            if approval_policy and approval_policy not in ALLOWED_APPROVAL_POLICIES:
-                raise HTTPException(
-                    status_code=400,
-                    detail="approval policy must be never or unlessTrusted",
-                )
-            sandbox_mode = (
-                _normalize_optional_string(
-                    updates.get("autorunner_sandbox_mode"),
-                    "autorunner_sandbox_mode",
-                )
-                if "autorunner_sandbox_mode" in updates
-                else state.autorunner_sandbox_mode
-            )
-            if sandbox_mode and sandbox_mode not in ALLOWED_SANDBOX_MODES:
-                raise HTTPException(
-                    status_code=400,
-                    detail="sandbox mode must be dangerFullAccess or workspaceWrite",
-                )
-            workspace_write_network = (
-                updates.get("autorunner_workspace_write_network")
-                if "autorunner_workspace_write_network" in updates
-                else state.autorunner_workspace_write_network
-            )
-            if (
-                "autorunner_workspace_write_network" in updates
-                and workspace_write_network is not None
-                and not isinstance(workspace_write_network, bool)
-            ):
-                raise HTTPException(
-                    status_code=400,
-                    detail="autorunner_workspace_write_network must be a boolean",
-                )
-            runner_stop_after_runs = (
-                updates.get("runner_stop_after_runs")
-                if "runner_stop_after_runs" in updates
-                else state.runner_stop_after_runs
-            )
-            if (
-                "runner_stop_after_runs" in updates
-                and runner_stop_after_runs is not None
-                and (
-                    not isinstance(runner_stop_after_runs, int)
-                    or isinstance(runner_stop_after_runs, bool)
-                    or runner_stop_after_runs <= 0
-                )
-            ):
-                raise HTTPException(
-                    status_code=400,
-                    detail="runner_stop_after_runs must be a positive integer",
-                )
-
-            thread_reset_required = any(
-                (
-                    model_override != state.autorunner_model_override,
-                    effort_override != state.autorunner_effort_override,
-                    approval_policy != state.autorunner_approval_policy,
-                    sandbox_mode != state.autorunner_sandbox_mode,
-                    workspace_write_network != state.autorunner_workspace_write_network,
-                    runner_stop_after_runs != state.runner_stop_after_runs,
-                )
-            )
-            if thread_reset_required and manager.running:
-                raise HTTPException(
-                    status_code=409,
-                    detail="Cannot change autorunner settings while a run is active",
-                )
-
-            new_state = RunnerState(
-                last_run_id=state.last_run_id,
-                status=state.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,
-                autorunner_agent_override=state.autorunner_agent_override,
-                autorunner_model_override=model_override,
-                autorunner_effort_override=effort_override,
-                autorunner_approval_policy=approval_policy,
-                autorunner_sandbox_mode=sandbox_mode,
-                autorunner_workspace_write_network=workspace_write_network,
-                runner_stop_after_runs=runner_stop_after_runs,
-                runner_pid=state.runner_pid,
-                sessions=state.sessions,
-                repo_to_session=state.repo_to_session,
-            )
-            save_state(engine.state_path, new_state)
-            if thread_reset_required:
-                registry.reset_thread("autorunner")
-
-        return {
-            "autorunner_model_override": model_override,
-            "autorunner_effort_override": effort_override,
-            "autorunner_approval_policy": approval_policy,
-            "autorunner_sandbox_mode": sandbox_mode,
-            "autorunner_workspace_write_network": workspace_write_network,
-            "runner_stop_after_runs": runner_stop_after_runs,
-        }
-
-    return router
+from ..surfaces.web.routes.settings import *  # noqa: F401,F403

codex_autorunner/routes/shared.py

@@ -1,276 +1,3 @@
-"""
-Shared utilities for route modules.
-"""
+"""Backward-compatible shared route utilities."""
 
-import asyncio
-import json
-import time
-from pathlib import Path
-from typing import Optional
-
-from ..codex_cli import apply_codex_options, extract_flag_value, supports_reasoning
-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 resolve_opencode_binary
-
-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
+from ..surfaces.web.routes.shared import *  # noqa: F401,F403

codex_autorunner/routes/system.py

@@ -1,191 +1,7 @@
-import asyncio
-import logging
-from pathlib import Path
-from typing import Optional
+"""Backward-compatible system routes."""
 
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import JSONResponse
+import sys
 
-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
-from ..web.static_refresh import refresh_static_assets
+from ..surfaces.web.routes import system as _system
 
-_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"
-        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
+sys.modules[__name__] = _system

codex_autorunner/routes/usage.py

@@ -0,0 +1,3 @@
+"""Backward-compatible usage routes."""
+
+from ..surfaces.web.routes.usage import *  # noqa: F401,F403