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

codex_autorunner/core/config.py

@@ -95,6 +95,9 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
         "prev_run_max_chars": 6000,
         "template": ".codex-autorunner/prompt.txt",
     },
+    "ui": {
+        "editor": "vi",
+    },
     "security": {
         "redact_run_logs": True,
     },
@@ -128,6 +131,9 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
             },
         },
     },
+    "autorunner": {
+        "reuse_session": False,
+    },
     "ticket_flow": {
         "approval_mode": "yolo",
         # Keep ticket_flow deterministic by default; surfaces can tighten this.
@@ -192,6 +198,11 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
     "opencode": {
         "session_stall_timeout_seconds": 60,
     },
+    "usage": {
+        "cache_scope": "global",
+        "global_cache_root": None,
+        "repo_cache_path": ".codex-autorunner/usage/usage_series_cache.json",
+    },
     "server": {
         "host": "127.0.0.1",
         "port": 4173,
@@ -205,6 +216,7 @@ DEFAULT_REPO_CONFIG: Dict[str, Any] = {
         "enabled": "auto",
         "events": ["run_finished", "run_error", "tui_idle"],
         "tui_idle_seconds": 60,
+        "timeout_seconds": 5.0,
         "discord": {
             "webhook_url_env": "CAR_DISCORD_WEBHOOK_URL",
         },
@@ -419,7 +431,9 @@ REPO_DEFAULT_KEYS = {
     "docs",
     "codex",
     "prompt",
+    "ui",
     "runner",
+    "autorunner",
     "ticket_flow",
     "git",
     "github",
@@ -430,6 +444,7 @@ REPO_DEFAULT_KEYS = {
     "server_log",
     "review",
     "opencode",
+    "usage",
 }
 DEFAULT_REPO_DEFAULTS = {
     key: json.loads(json.dumps(DEFAULT_REPO_CONFIG[key])) for key in REPO_DEFAULT_KEYS
@@ -444,6 +459,7 @@ REPO_SHARED_KEYS = {
     "static_assets",
     "housekeeping",
     "update",
+    "usage",
 }
 
 DEFAULT_HUB_CONFIG: Dict[str, Any] = {
@@ -603,6 +619,11 @@ DEFAULT_HUB_CONFIG: Dict[str, Any] = {
     "opencode": {
         "session_stall_timeout_seconds": 60,
     },
+    "usage": {
+        "cache_scope": "global",
+        "global_cache_root": None,
+        "repo_cache_path": ".codex-autorunner/usage/usage_series_cache.json",
+    },
     "server": {
         "host": "127.0.0.1",
         "port": 4173,
@@ -791,6 +812,13 @@ class OpenCodeConfig:
     session_stall_timeout_seconds: Optional[float]
 
 
+@dataclasses.dataclass
+class UsageConfig:
+    cache_scope: str
+    global_cache_root: Path
+    repo_cache_path: Path
+
+
 @dataclasses.dataclass(frozen=True)
 class AgentConfig:
     binary: str
@@ -819,12 +847,14 @@ class RepoConfig:
     runner_stop_after_runs: Optional[int]
     runner_max_wallclock_seconds: Optional[int]
     runner_no_progress_threshold: int
+    autorunner_reuse_session: bool
     ticket_flow: Dict[str, Any]
     git_auto_commit: bool
     git_commit_message_template: str
     update_skip_checks: bool
     app_server: AppServerConfig
     opencode: OpenCodeConfig
+    usage: UsageConfig
     server_host: str
     server_port: int
     server_base_path: str
@@ -875,6 +905,7 @@ class HubConfig:
     update_skip_checks: bool
     app_server: AppServerConfig
     opencode: OpenCodeConfig
+    usage: UsageConfig
     server_host: str
     server_port: int
     server_base_path: str
@@ -1243,6 +1274,40 @@ def _parse_opencode_config(
     return OpenCodeConfig(session_stall_timeout_seconds=stall_timeout_seconds)
 
 
+def _parse_usage_config(
+    cfg: Optional[Dict[str, Any]],
+    root: Path,
+    defaults: Optional[Dict[str, Any]],
+) -> UsageConfig:
+    cfg = cfg if isinstance(cfg, dict) else {}
+    defaults = defaults if isinstance(defaults, dict) else {}
+    cache_scope = str(cfg.get("cache_scope", defaults.get("cache_scope", "global")))
+    cache_scope = cache_scope.lower().strip() or "global"
+    global_cache_raw = cfg.get("global_cache_root", defaults.get("global_cache_root"))
+    if global_cache_raw is None:
+        global_cache_raw = os.environ.get("CODEX_HOME", "~/.codex")
+    global_cache_root = resolve_config_path(
+        global_cache_raw,
+        root,
+        allow_absolute=True,
+        allow_home=True,
+        scope="usage.global_cache_root",
+    )
+    repo_cache_raw = cfg.get("repo_cache_path", defaults.get("repo_cache_path"))
+    if repo_cache_raw is None:
+        repo_cache_raw = ".codex-autorunner/usage/usage_series_cache.json"
+    repo_cache_path = resolve_config_path(
+        repo_cache_raw,
+        root,
+        scope="usage.repo_cache_path",
+    )
+    return UsageConfig(
+        cache_scope=cache_scope,
+        global_cache_root=global_cache_root,
+        repo_cache_path=repo_cache_path,
+    )
+
+
 def _parse_agents_config(
     cfg: Optional[Dict[str, Any]], defaults: Dict[str, Any]
 ) -> Dict[str, AgentConfig]:
@@ -1378,6 +1443,54 @@ def resolve_env_for_root(
     return env
 
 
+VOICE_ENV_OVERRIDES = (
+    "CODEX_AUTORUNNER_VOICE_ENABLED",
+    "CODEX_AUTORUNNER_VOICE_PROVIDER",
+    "CODEX_AUTORUNNER_VOICE_LATENCY",
+    "CODEX_AUTORUNNER_VOICE_CHUNK_MS",
+    "CODEX_AUTORUNNER_VOICE_SAMPLE_RATE",
+    "CODEX_AUTORUNNER_VOICE_WARN_REMOTE",
+    "CODEX_AUTORUNNER_VOICE_MAX_MS",
+    "CODEX_AUTORUNNER_VOICE_SILENCE_MS",
+    "CODEX_AUTORUNNER_VOICE_MIN_HOLD_MS",
+)
+
+TELEGRAM_ENV_OVERRIDES = (
+    "CAR_OPENCODE_COMMAND",
+    "CAR_TELEGRAM_APP_SERVER_COMMAND",
+)
+
+
+def collect_env_overrides(
+    *,
+    env: Optional[Mapping[str, str]] = None,
+    include_telegram: bool = False,
+) -> list[str]:
+    source = env if env is not None else os.environ
+    overrides: list[str] = []
+
+    def _has_value(key: str) -> bool:
+        value = source.get(key)
+        if value is None:
+            return False
+        return str(value).strip() != ""
+
+    if source.get("CODEX_AUTORUNNER_SKIP_UPDATE_CHECKS") == "1":
+        overrides.append("CODEX_AUTORUNNER_SKIP_UPDATE_CHECKS")
+    if _has_value("CODEX_DISABLE_APP_SERVER_AUTORESTART_FOR_TESTS"):
+        overrides.append("CODEX_DISABLE_APP_SERVER_AUTORESTART_FOR_TESTS")
+    if _has_value("CAR_GLOBAL_STATE_ROOT"):
+        overrides.append("CAR_GLOBAL_STATE_ROOT")
+    for key in VOICE_ENV_OVERRIDES:
+        if _has_value(key):
+            overrides.append(key)
+    if include_telegram:
+        for key in TELEGRAM_ENV_OVERRIDES:
+            if _has_value(key):
+                overrides.append(key)
+    return overrides
+
+
 def load_hub_config_data(config_path: Path) -> Dict[str, Any]:
     """Load, merge, and return a raw hub config dict for the given config path."""
     load_dotenv_for_root(config_path.parent.parent.resolve())
@@ -1417,7 +1530,7 @@ def load_hub_config(start: Path) -> HubConfig:
     """Load the nearest hub config walking upward from the provided path."""
     config_path = _resolve_hub_config_path(start)
     merged = load_hub_config_data(config_path)
-    _validate_hub_config(merged)
+    _validate_hub_config(merged, root=config_path.parent.parent.resolve())
     return _build_hub_config(config_path, merged)
 
 
@@ -1463,7 +1576,7 @@ def load_repo_config(start: Path, hub_path: Optional[Path] = None) -> RepoConfig
     repo_root = _resolve_repo_root(start)
     hub_config_path = _resolve_hub_path_for_repo(repo_root, hub_path)
     hub_config = load_hub_config_data(hub_config_path)
-    _validate_hub_config(hub_config)
+    _validate_hub_config(hub_config, root=hub_config_path.parent.parent.resolve())
     hub = _build_hub_config(hub_config_path, hub_config)
     return derive_repo_config(hub, repo_root)
 
@@ -1507,6 +1620,14 @@ def _build_repo_config(config_path: Path, cfg: Dict[str, Any]) -> RepoConfig:
         Dict[str, Any], update_cfg if isinstance(update_cfg, dict) else {}
     )
     update_skip_checks = bool(update_cfg.get("skip_checks", False))
+    autorunner_cfg = cfg.get("autorunner")
+    autorunner_cfg = cast(
+        Dict[str, Any], autorunner_cfg if isinstance(autorunner_cfg, dict) else {}
+    )
+    reuse_session_value = autorunner_cfg.get("reuse_session")
+    autorunner_reuse_session = (
+        bool(reuse_session_value) if reuse_session_value is not None else False
+    )
     return RepoConfig(
         raw=cfg,
         root=root,
@@ -1525,6 +1646,7 @@ def _build_repo_config(config_path: Path, cfg: Dict[str, Any]) -> RepoConfig:
         runner_stop_after_runs=cfg["runner"].get("stop_after_runs"),
         runner_max_wallclock_seconds=cfg["runner"].get("max_wallclock_seconds"),
         runner_no_progress_threshold=int(cfg["runner"].get("no_progress_threshold", 3)),
+        autorunner_reuse_session=autorunner_reuse_session,
         git_auto_commit=bool(cfg["git"].get("auto_commit", False)),
         git_commit_message_template=str(cfg["git"].get("commit_message_template")),
         update_skip_checks=update_skip_checks,
@@ -1537,6 +1659,9 @@ def _build_repo_config(config_path: Path, cfg: Dict[str, Any]) -> RepoConfig:
         opencode=_parse_opencode_config(
             cfg.get("opencode"), root, DEFAULT_REPO_CONFIG.get("opencode")
         ),
+        usage=_parse_usage_config(
+            cfg.get("usage"), root, DEFAULT_REPO_CONFIG.get("usage")
+        ),
         security=security_cfg,
         server_host=str(cfg["server"].get("host")),
         server_port=int(cfg["server"].get("port")),
@@ -1638,6 +1763,9 @@ def _build_hub_config(config_path: Path, cfg: Dict[str, Any]) -> HubConfig:
         opencode=_parse_opencode_config(
             cfg.get("opencode"), root, DEFAULT_HUB_CONFIG.get("opencode")
         ),
+        usage=_parse_usage_config(
+            cfg.get("usage"), root, DEFAULT_HUB_CONFIG.get("usage")
+        ),
         server_host=str(cfg["server"]["host"]),
         server_port=int(cfg["server"]["port"]),
         server_base_path=_normalize_base_path(cfg["server"].get("base_path", "")),
@@ -1854,6 +1982,47 @@ def _validate_update_config(cfg: Dict[str, Any]) -> None:
             raise ConfigError("update.skip_checks must be boolean or null")
 
 
+def _validate_usage_config(cfg: Dict[str, Any], *, root: Path) -> None:
+    usage_cfg = cfg.get("usage")
+    if usage_cfg is None:
+        return
+    if not isinstance(usage_cfg, dict):
+        raise ConfigError("usage section must be a mapping if provided")
+    cache_scope = usage_cfg.get("cache_scope")
+    if cache_scope is not None and not isinstance(cache_scope, str):
+        raise ConfigError("usage.cache_scope must be a string if provided")
+    if isinstance(cache_scope, str):
+        scope_val = cache_scope.strip().lower()
+        if scope_val and scope_val not in {"global", "repo"}:
+            raise ConfigError("usage.cache_scope must be 'global' or 'repo'")
+    global_cache_root = usage_cfg.get("global_cache_root")
+    if global_cache_root is not None:
+        if not isinstance(global_cache_root, str):
+            raise ConfigError("usage.global_cache_root must be a string or null")
+        try:
+            resolve_config_path(
+                global_cache_root,
+                root,
+                allow_absolute=True,
+                allow_home=True,
+                scope="usage.global_cache_root",
+            )
+        except ConfigPathError as exc:
+            raise ConfigError(str(exc)) from exc
+    repo_cache_path = usage_cfg.get("repo_cache_path")
+    if repo_cache_path is not None:
+        if not isinstance(repo_cache_path, str):
+            raise ConfigError("usage.repo_cache_path must be a string or null")
+        try:
+            resolve_config_path(
+                repo_cache_path,
+                root,
+                scope="usage.repo_cache_path",
+            )
+        except ConfigPathError as exc:
+            raise ConfigError(str(exc)) from exc
+
+
 def _validate_agents_config(cfg: Dict[str, Any]) -> None:
     agents_cfg = cfg.get("agents")
     if agents_cfg is None:
@@ -1943,6 +2112,13 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
         val = runner.get(k)
         if val is not None and not isinstance(val, int):
             raise ConfigError(f"runner.{k} must be an integer or null")
+    autorunner_cfg = cfg.get("autorunner")
+    if autorunner_cfg is not None and not isinstance(autorunner_cfg, dict):
+        raise ConfigError("autorunner section must be a mapping if provided")
+    if isinstance(autorunner_cfg, dict):
+        reuse_session = autorunner_cfg.get("reuse_session")
+        if reuse_session is not None and not isinstance(reuse_session, bool):
+            raise ConfigError("autorunner.reuse_session must be boolean or null")
     ticket_flow_cfg = cfg.get("ticket_flow")
     if ticket_flow_cfg is not None and not isinstance(ticket_flow_cfg, dict):
         raise ConfigError("ticket_flow section must be a mapping if provided")
@@ -1955,6 +2131,12 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
             ticket_flow_cfg.get("default_approval_decision"), str
         ):
             raise ConfigError("ticket_flow.default_approval_decision must be a string")
+    ui_cfg = cfg.get("ui")
+    if ui_cfg is not None and not isinstance(ui_cfg, dict):
+        raise ConfigError("ui section must be a mapping if provided")
+    if isinstance(ui_cfg, dict):
+        if "editor" in ui_cfg and not isinstance(ui_cfg.get("editor"), str):
+            raise ConfigError("ui.editor must be a string if provided")
     git = cfg.get("git")
     if not isinstance(git, dict):
         raise ConfigError("git section must be a mapping")
@@ -1998,6 +2180,7 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
     _validate_app_server_config(cfg)
     _validate_opencode_config(cfg)
     _validate_update_config(cfg)
+    _validate_usage_config(cfg, root=root)
     notifications_cfg = cfg.get("notifications")
     if notifications_cfg is not None:
         if not isinstance(notifications_cfg, dict):
@@ -2029,6 +2212,16 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
                 raise ConfigError(
                     "notifications.tui_idle_seconds must be >= 0 if provided"
                 )
+        timeout_seconds = notifications_cfg.get("timeout_seconds")
+        if timeout_seconds is not None:
+            if not isinstance(timeout_seconds, (int, float)):
+                raise ConfigError(
+                    "notifications.timeout_seconds must be a number if provided"
+                )
+            if timeout_seconds <= 0:
+                raise ConfigError(
+                    "notifications.timeout_seconds must be > 0 if provided"
+                )
         discord_cfg = notifications_cfg.get("discord")
         if discord_cfg is not None and not isinstance(discord_cfg, dict):
             raise ConfigError("notifications.discord must be a mapping if provided")
@@ -2134,7 +2327,7 @@ def _validate_repo_config(cfg: Dict[str, Any], *, root: Path) -> None:
     _validate_telegram_bot_config(cfg)
 
 
-def _validate_hub_config(cfg: Dict[str, Any]) -> None:
+def _validate_hub_config(cfg: Dict[str, Any], *, root: Path) -> None:
     _validate_version(cfg)
     if cfg.get("mode") != "hub":
         raise ConfigError("Hub config must set mode: hub")
@@ -2143,6 +2336,7 @@ def _validate_hub_config(cfg: Dict[str, Any]) -> None:
     _validate_agents_config(cfg)
     _validate_opencode_config(cfg)
     _validate_update_config(cfg)
+    _validate_usage_config(cfg, root=root)
     repo_defaults = cfg.get("repo_defaults")
     if repo_defaults is not None:
         if not isinstance(repo_defaults, dict):

codex_autorunner/core/drafts.py

@@ -2,12 +2,18 @@ from __future__ import annotations
 
 import hashlib
 import json
+import logging
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
 
 from .utils import atomic_write
 
 FILE_CHAT_STATE_NAME = "file_chat_state.json"
+FILE_CHAT_STATE_CORRUPT_SUFFIX = ".corrupt"
+FILE_CHAT_STATE_NOTICE_SUFFIX = ".corrupt.json"
+
+logger = logging.getLogger(__name__)
 
 
 def state_path(repo_root: Path) -> Path:
@@ -23,12 +29,19 @@ def load_state(repo_root: Path) -> Dict[str, Any]:
     if not path.exists():
         return {"drafts": {}}
     try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-        if isinstance(data, dict):
-            return data
+        raw = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        logger.warning("Failed to read file chat state at %s: %s", path, exc)
         return {"drafts": {}}
-    except Exception:
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        _handle_corrupt_state(path, str(exc))
+        return {"drafts": {}}
+    if not isinstance(data, dict):
+        _handle_corrupt_state(path, f"Expected JSON object, got {type(data).__name__}")
         return {"drafts": {}}
+    return data
 
 
 def save_state(repo_root: Path, state: Dict[str, Any]) -> None:
@@ -80,3 +93,44 @@ def invalidate_drafts_for_path(repo_root: Path, rel_path: str) -> list[str]:
     if removed_keys:
         save_drafts(repo_root, drafts)
     return removed_keys
+
+
+def _stamp() -> str:
+    return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
+
+def _notice_path(path: Path) -> Path:
+    return path.with_name(f"{path.name}{FILE_CHAT_STATE_NOTICE_SUFFIX}")
+
+
+def _handle_corrupt_state(path: Path, detail: str) -> None:
+    stamp = _stamp()
+    backup_path = path.with_name(f"{path.name}{FILE_CHAT_STATE_CORRUPT_SUFFIX}.{stamp}")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        path.replace(backup_path)
+        backup_value = str(backup_path)
+    except OSError:
+        backup_value = ""
+    notice = {
+        "status": "corrupt",
+        "message": "Draft state reset due to corrupted file_chat_state.json.",
+        "detail": detail,
+        "detected_at": stamp,
+        "backup_path": backup_value,
+    }
+    notice_path = _notice_path(path)
+    try:
+        atomic_write(notice_path, json.dumps(notice, indent=2) + "\n")
+    except Exception:
+        logger.warning("Failed to write draft corruption notice at %s", notice_path)
+    try:
+        atomic_write(path, json.dumps({"drafts": {}}, indent=2) + "\n")
+    except Exception:
+        logger.warning("Failed to reset draft state at %s", path)
+    logger.warning(
+        "Corrupted file chat state detected; backup=%s notice=%s detail=%s",
+        backup_value or "unavailable",
+        notice_path,
+        detail,
+    )