feat: add Codex account switcher with auto-rotation

Add a full-featured Codex account switching mechanism that monitors
usage limits and automatically rotates the active auth.json when
the current account approaches its rate limit (>= 90%).

Backend (backend/codex_switcher.py):
- Read account pool from <DATA_ROOT>/codex (codex-*.json files)
- Detect active account by matching current auth.json tokens
- Fetch usage via https://chatgpt.com/backend-api/wham/usage
- Auto-refresh expiring access tokens via OpenAI OAuth endpoint
- Background scheduler with configurable interval
- Atomic file writes with cross-platform path resolution (CODEX_HOME)

Integration (backend/ui_facade.py, backend/rpc_server.py, backend/dto.py):
- New DTOs: CodexAccountRow, CodexSwitcherStatusDTO
- New RPC methods: codex_switcher.refresh, codex_switcher.switch_now,
  codex_switcher.pick_first_ready
- New settings: CODEX_SWITCHER_ENABLED, CODEX_SWITCHER_INTERVAL_MINUTES

UI (ui/src/menus/, ui/src/screens/MainScreen.ts):
- "Свитч аккаунтов" menu section with account table
- Manual refresh, manual switch, pick-first-ready actions
- Auto-switch toggle and interval configuration via settings

Tests:
- 10 Python tests covering auto-switch, token refresh, 401 retry,
  pick-first-ready, missing refresh_token, threshold logic
- 11 UI tests covering menu options, table rendering, hints,
  picker states, parent navigation

Screenshots updated to reflect new UI section.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: izzzzzi

backend/codex_switcher.py

@@ -90,10 +90,37 @@ def from_account(
         )
 
 
+@dataclass
+class CodexAccountRow:
+    email: str
+    is_active: bool
+    primary_used_percent: float | None
+    primary_resets_at: str | None
+    secondary_used_percent: float | None
+    secondary_resets_at: str | None
+    usage_status: str
+    token_status: str
+    last_checked_at: str | None
+    last_error: str | None
+    near_limit: bool
+
+
+@dataclass
+class CodexSwitcherStatusDTO:
+    enabled: bool
+    interval_minutes: int
+    last_run_at: str | None
+    last_switch_at: str | None
+    active_email: str | None
+    last_error: str | None
+
+
 @dataclass
 class AppStateDTO:
     admins: list[AdminRow]
     workers: list[WorkerRow]
+    codex_accounts: list[CodexAccountRow] | None = None
+    codex_switcher_status: CodexSwitcherStatusDTO | None = None
 
     def to_dict(self) -> dict:
         return asdict(self)

backend/dto.py

@@ -59,6 +59,8 @@ def _run_job(self, title: str, fn):
         ("BOOMLIFY_TIME", "Время жизни ящика"),
         ("SLOT_MAIL_PROVIDER", "Провайдер почты для слотов"),
         ("MAIL_PROVIDER", "Провайдер почты для админов"),
+        ("CODEX_SWITCHER_ENABLED", "Автосвитч Codex"),
+        ("CODEX_SWITCHER_INTERVAL_MINUTES", "Интервал проверки Codex (мин)"),
     ]
 
     @staticmethod
@@ -69,16 +71,30 @@ def _get_settings(self) -> dict[str, Any]:
         items = []
         for key, label in self._SETTINGS_KEYS:
             value = os.environ.get(key, "")
-            masked = ""
-            if value:
-                masked = value[:4] + "***" + value[-4:] if len(value) > 12 else "***"
+            masked = self._mask_setting_value(key, value)
             items.append({"key": key, "label": label, "masked": masked})
         return {"items": items, "path": str(self._settings_path())}
 
+    @staticmethod
+    def _mask_setting_value(key: str, value: str) -> str:
+        if not value:
+            return ""
+        if "KEY" in key:
+            return value[:4] + "***" + value[-4:] if len(value) > 12 else "***"
+        return value
+
     def _set_setting(self, key: str, value: str) -> None:
         allowed = {k for k, _ in self._SETTINGS_KEYS}
         if key not in allowed:
             raise RPCError(-32602, "Unknown setting", {"key": key})
+        if key == "CODEX_SWITCHER_ENABLED" and value not in {"", "0", "1", "true", "false", "yes", "no", "on", "off"}:
+            raise RPCError(-32602, "Invalid setting", {"details": "CODEX_SWITCHER_ENABLED expects boolean-like value"})
+        if key == "CODEX_SWITCHER_INTERVAL_MINUTES":
+            try:
+                if int(value) <= 0:
+                    raise ValueError
+            except ValueError:
+                raise RPCError(-32602, "Invalid setting", {"details": "CODEX_SWITCHER_INTERVAL_MINUTES expects integer > 0"}) from None
 
         env_path = self._settings_path()
         env_path.parent.mkdir(parents=True, exist_ok=True)
@@ -226,6 +242,16 @@ def _handle_request(self, req: RPCRequest) -> dict[str, Any]:
             self._set_setting(key, value)
             return make_success_response(req.request_id, {"ok": True})
 
+        if m == "codex_switcher.refresh":
+            return make_success_response(req.request_id, self.facade.refresh_codex_switcher())
+
+        if m == "codex_switcher.switch_now":
+            email = self._as_str_param(p, "email")
+            return make_success_response(req.request_id, self.facade.switch_codex_account(email))
+
+        if m == "codex_switcher.pick_first_ready":
+            return make_success_response(req.request_id, self.facade.pick_first_codex_account())
+
         if m == "shutdown":
             self.jobs.wait_all(timeout=10)
             self.facade.shutdown()

backend/rpc_server.py

@@ -8,7 +8,8 @@
 
 from . import DATA_ROOT, PROJECT_ROOT
 from .account_store import AccountStore
-from .dto import AdminRow, AppStateDTO, WorkerRow
+from .codex_switcher import CodexSwitcherService
+from .dto import AdminRow, AppStateDTO, CodexAccountRow, CodexSwitcherStatusDTO, WorkerRow
 from .mail import Mailbox, create_provider_for_mailbox
 from .openai_web_auth import (
     close_browser as close_br,
@@ -31,9 +32,14 @@ def _has_profile_files(profile_dir: Path) -> bool:
 
 
 class UIFacade:
-    def __init__(self, store: AccountStore | None = None) -> None:
+    def __init__(
+        self,
+        store: AccountStore | None = None,
+        codex_switcher: CodexSwitcherService | None = None,
+    ) -> None:
         self.store = store or AccountStore()
         self.manager: SlotManager | None = None
+        self.codex_switcher = codex_switcher or CodexSwitcherService()
         self.bootstrap()
 
     def bootstrap(self) -> None:
@@ -47,8 +53,10 @@ def bootstrap(self) -> None:
 
         self.store.doctor()
         self.sync_codex_files()
+        self.codex_switcher.start()
 
     def shutdown(self) -> None:
+        self.codex_switcher.stop()
         self.sync_codex_files()
 
     def sync_codex_files(self) -> None:
@@ -66,6 +74,7 @@ def sync_codex_files(self) -> None:
                         dst.write_text(f.read_text())
 
     def get_state(self) -> dict[str, Any]:
+        codex_state = self.codex_switcher.get_state()
         raw_admins = self.store.list_admins()
         raw_workers = self.store.list_workers()
         admins = [
@@ -82,7 +91,31 @@ def get_state(self) -> dict[str, Any]:
             )
             for w in raw_workers
         ]
-        return AppStateDTO(admins=admins, workers=workers).to_dict()
+        codex_accounts = [CodexAccountRow(**item) for item in codex_state.get("items", [])]
+        status_raw = codex_state.get("status", {})
+        status = CodexSwitcherStatusDTO(
+            enabled=bool(status_raw.get("enabled")),
+            interval_minutes=int(status_raw.get("interval_minutes") or 15),
+            last_run_at=status_raw.get("last_run_at"),
+            last_switch_at=status_raw.get("last_switch_at"),
+            active_email=status_raw.get("active_email"),
+            last_error=status_raw.get("last_error"),
+        )
+        return AppStateDTO(
+            admins=admins,
+            workers=workers,
+            codex_accounts=codex_accounts,
+            codex_switcher_status=status,
+        ).to_dict()
+
+    def refresh_codex_switcher(self) -> dict[str, Any]:
+        return self.codex_switcher.refresh_now(auto_switch=False)
+
+    def switch_codex_account(self, email: str) -> dict[str, Any]:
+        return self.codex_switcher.switch_now(email)
+
+    def pick_first_codex_account(self) -> dict[str, Any]:
+        return self.codex_switcher.pick_first_ready()
 
     def add_admin(self, email: str, password: str) -> dict[str, Any]:
         admin = self.store.add_admin(email, password)