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

codex_autorunner/integrations/telegram/config.py

@@ -62,6 +62,7 @@ DEFAULT_MESSAGE_OVERFLOW = "document"
 MESSAGE_OVERFLOW_OPTIONS = {"document", "split", "trim"}
 DEFAULT_METRICS_MODE = "separate"
 METRICS_MODE_OPTIONS = {"separate", "append_to_response", "append_to_progress"}
+DEFAULT_PAUSE_DISPATCH_MAX_FILE_BYTES = 50 * 1024 * 1024
 
 PARSE_MODE_ALIASES = {
     "html": "HTML",
@@ -160,6 +161,14 @@ class TelegramBotProgressStreamConfig:
     min_edit_interval_seconds: float
 
 
+@dataclass(frozen=True)
+class PauseDispatchNotifications:
+    enabled: bool
+    send_attachments: bool
+    max_file_size_bytes: int
+    chunk_long_messages: bool
+
+
 @dataclass(frozen=True)
 class TelegramMediaCandidate:
     kind: str
@@ -209,6 +218,8 @@ class TelegramBotConfig:
     coalesce_window_seconds: float
     agent_binaries: dict[str, str]
     ticket_flow_auto_resume: bool
+    pause_dispatch_notifications: PauseDispatchNotifications
+    default_notification_chat_id: Optional[int]
 
     @classmethod
     def from_raw(
@@ -506,6 +517,39 @@ class TelegramBotConfig:
         )
         ticket_flow_auto_resume = bool(ticket_flow_raw.get("auto_resume", False))
 
+        pause_raw_value = cfg.get("pause_dispatch_notifications")
+        pause_raw: dict[str, Any] = (
+            pause_raw_value if isinstance(pause_raw_value, dict) else {}
+        )
+        pause_enabled = bool(pause_raw.get("enabled", enabled))
+        pause_send_attachments = bool(pause_raw.get("send_attachments", True))
+        pause_max_file_size_bytes = int(
+            pause_raw.get("max_file_size_bytes", DEFAULT_PAUSE_DISPATCH_MAX_FILE_BYTES)
+        )
+        if pause_max_file_size_bytes <= 0:
+            pause_max_file_size_bytes = DEFAULT_PAUSE_DISPATCH_MAX_FILE_BYTES
+        pause_chunk_long_messages = bool(pause_raw.get("chunk_long_messages", True))
+        pause_dispatch_notifications = PauseDispatchNotifications(
+            enabled=pause_enabled,
+            send_attachments=pause_send_attachments,
+            max_file_size_bytes=pause_max_file_size_bytes,
+            chunk_long_messages=pause_chunk_long_messages,
+        )
+
+        default_notification_chat_raw = cfg.get("default_notification_chat_id")
+        default_notification_chat_id: Optional[int] = None
+        env_chat_candidates = _parse_int_list(env.get(chat_id_env))
+        if default_notification_chat_raw is not None:
+            try:
+                default_notification_chat_id = int(default_notification_chat_raw)
+            except (TypeError, ValueError):
+                default_notification_chat_id = None
+        if default_notification_chat_id is None:
+            if env_chat_candidates:
+                default_notification_chat_id = env_chat_candidates[0]
+            elif allowed_chat_ids:
+                default_notification_chat_id = min(allowed_chat_ids)
+
         agent_binaries = dict(agent_binaries or {})
         command_reg_raw_value = cfg.get("command_registration")
         command_reg_raw: dict[str, Any] = (
@@ -666,6 +710,8 @@ class TelegramBotConfig:
             coalesce_window_seconds=coalesce_window_seconds,
             agent_binaries=agent_binaries,
             ticket_flow_auto_resume=ticket_flow_auto_resume,
+            pause_dispatch_notifications=pause_dispatch_notifications,
+            default_notification_chat_id=default_notification_chat_id,
         )
 
     def validate(self) -> None:

codex_autorunner/integrations/telegram/constants.py

@@ -24,7 +24,6 @@ DEFAULT_AGENT_TURN_TIMEOUT_SECONDS = {
     "codex": 28800.0,
     "opencode": 28800.0,
 }
-DEFAULT_WORKSPACE_STATE_ROOT = "~/.codex-autorunner/workspaces"
 DEFAULT_AGENT = "codex"
 APP_SERVER_START_BACKOFF_INITIAL_SECONDS = 1.0
 APP_SERVER_START_BACKOFF_MAX_SECONDS = 30.0
@@ -66,6 +65,7 @@ UPDATE_PICKER_PROMPT = "Select update target (buttons below)."
 REVIEW_COMMIT_PICKER_PROMPT = (
     "Select a commit to review (buttons below or reply with number)."
 )
+FLOW_RUNS_PICKER_PROMPT = "Select a ticket flow run (buttons below)."
 REVIEW_COMMIT_BUTTON_LABEL_LIMIT = 80
 UPDATE_TARGET_OPTIONS = (
     ("both", "Both (web + Telegram)"),

codex_autorunner/integrations/telegram/doctor.py

@@ -1,47 +1,269 @@
 """Telegram integration doctor checks."""
 
+import logging
+import os
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
 from typing import Any, Dict, Union
 
 from ...core.config import HubConfig, RepoConfig
-from ...core.engine import DoctorCheck
 from ...core.optional_dependencies import missing_optional_dependencies
+from ...core.runtime import DoctorCheck
+
+logger = logging.getLogger(__name__)
+
+STUCK_TURN_THRESHOLD_MINUTES = 30
+STATE_FILE_CHECK = ".codex-autorunner/telegram_state.sqlite3"
 
 
 def telegram_doctor_checks(
     config: Union[HubConfig, RepoConfig, Dict[str, Any]],
+    repo_root: Union[Path, None] = None,
 ) -> list[DoctorCheck]:
     """Run Telegram-specific doctor checks.
 
     Returns a list of DoctorCheck objects for Telegram integration.
     Works with HubConfig, RepoConfig, or raw dict.
+
+    Args:
+        config: HubConfig, RepoConfig, or raw dict
+        repo_root: Optional repo root path for state file checks
     """
     checks: list[DoctorCheck] = []
     telegram_cfg = None
 
     if isinstance(config, dict):
         telegram_cfg = config.get("telegram_bot")
+        if not telegram_cfg:
+            telegram_cfg = config.get("notifications", {}).get("telegram", {})
     elif isinstance(config.raw, dict):
         telegram_cfg = config.raw.get("telegram_bot")
+        if not telegram_cfg:
+            telegram_cfg = config.raw.get("notifications", {}).get("telegram", {})
 
-    if isinstance(telegram_cfg, dict) and telegram_cfg.get("enabled") is True:
+    enabled = isinstance(telegram_cfg, dict) and telegram_cfg.get("enabled") is True
+
+    if enabled:
         missing_telegram = missing_optional_dependencies((("httpx", "httpx"),))
         if missing_telegram:
             deps_list = ", ".join(missing_telegram)
             checks.append(
                 DoctorCheck(
-                    check_id="telegram.dependencies",
-                    status="error",
+                    name="Telegram dependencies",
+                    passed=False,
                     message=f"Telegram is enabled but missing optional deps: {deps_list}",
+                    check_id="telegram.dependencies",
                     fix="Install with `pip install codex-autorunner[telegram]`.",
                 )
             )
+            return checks
         else:
             checks.append(
                 DoctorCheck(
-                    check_id="telegram.dependencies",
-                    status="ok",
+                    name="Telegram dependencies",
+                    passed=True,
                     message="Telegram dependencies are installed.",
+                    check_id="telegram.dependencies",
+                    severity="info",
                 )
             )
 
+        bot_token_env = telegram_cfg.get("bot_token_env", "CAR_TELEGRAM_BOT_TOKEN")
+        chat_id_env = telegram_cfg.get("chat_id_env", "CAR_TELEGRAM_CHAT_ID")
+
+        bot_token = os.environ.get(bot_token_env)
+        chat_id = os.environ.get(chat_id_env)
+
+        if not bot_token:
+            checks.append(
+                DoctorCheck(
+                    name="Telegram bot token",
+                    passed=False,
+                    message=f"Telegram bot token not found in environment: {bot_token_env}",
+                    check_id="telegram.bot_token",
+                    fix=f"Set {bot_token_env} environment variable or disable Telegram.",
+                )
+            )
+        else:
+            checks.append(
+                DoctorCheck(
+                    name="Telegram bot token",
+                    passed=True,
+                    message=f"Bot token configured (env: {bot_token_env}).",
+                    check_id="telegram.bot_token",
+                    severity="info",
+                )
+            )
+
+        if not chat_id:
+            checks.append(
+                DoctorCheck(
+                    name="Telegram chat ID",
+                    passed=False,
+                    message=f"Telegram chat_id not found in environment: {chat_id_env}",
+                    check_id="telegram.chat_id",
+                    fix=f"Set {chat_id_env} environment variable for notifications.",
+                    severity="warning",
+                )
+            )
+        else:
+            checks.append(
+                DoctorCheck(
+                    name="Telegram chat ID",
+                    passed=True,
+                    message=f"Chat ID configured (env: {chat_id_env}).",
+                    check_id="telegram.chat_id",
+                    severity="info",
+                )
+            )
+
+        allowed_chats = telegram_cfg.get("allowed_chat_ids", [])
+        allowed_users = telegram_cfg.get("allowed_user_ids", [])
+        if not allowed_chats and not allowed_users:
+            checks.append(
+                DoctorCheck(
+                    name="Telegram access control",
+                    passed=False,
+                    message="No allowed_chat_ids or allowed_user_ids configured",
+                    check_id="telegram.access_control",
+                    fix="Configure allowed_chat_ids or allowed_user_ids in telegram_bot config.",
+                    severity="warning",
+                )
+            )
+        else:
+            checks.append(
+                DoctorCheck(
+                    name="Telegram access control",
+                    passed=True,
+                    message=f"Access control configured: {len(allowed_chats)} chats, {len(allowed_users)} users.",
+                    check_id="telegram.access_control",
+                    severity="info",
+                )
+            )
+
+        state_file_path = None
+        if repo_root:
+            state_file_path = repo_root / STATE_FILE_CHECK
+            if not state_file_path.exists():
+                checks.append(
+                    DoctorCheck(
+                        name="Telegram state file",
+                        passed=False,
+                        message=f"Telegram state file not found: {state_file_path}",
+                        check_id="telegram.state_file",
+                        severity="warning",
+                        fix="Run a Telegram command to initialize the state file.",
+                    )
+                )
+            else:
+                checks.append(
+                    DoctorCheck(
+                        name="Telegram state file",
+                        passed=True,
+                        message=f"State file exists: {state_file_path}",
+                        check_id="telegram.state_file",
+                        severity="info",
+                    )
+                )
+
+                _check_stuck_turns(checks, state_file_path)
+
+        mode = telegram_cfg.get("mode", "polling")
+        if mode not in ("polling", "webhook"):
+            checks.append(
+                DoctorCheck(
+                    name="Telegram mode",
+                    passed=False,
+                    message=f"Invalid Telegram mode: {mode}",
+                    check_id="telegram.mode",
+                    fix="Set mode to 'polling' or 'webhook' in telegram_bot config.",
+                )
+            )
+        else:
+            checks.append(
+                DoctorCheck(
+                    name="Telegram mode",
+                    passed=True,
+                    message=f"Telegram mode: {mode}",
+                    check_id="telegram.mode",
+                    severity="info",
+                )
+            )
+    else:
+        checks.append(
+            DoctorCheck(
+                name="Telegram enabled",
+                passed=True,
+                message="Telegram integration is disabled.",
+                check_id="telegram.enabled",
+                severity="info",
+                fix="Set telegram_bot.enabled=true in config to enable.",
+            )
+        )
+
     return checks
+
+
+def _check_stuck_turns(checks: list[DoctorCheck], state_file_path: Path) -> None:
+    """Check for stuck turns in Telegram state."""
+    try:
+        from ...core.sqlite_utils import connect_sqlite
+
+        conn = connect_sqlite(state_file_path)
+        cursor = conn.cursor()
+
+        cursor.execute("PRAGMA table_info(turns)")
+        columns = {row[1] for row in cursor.fetchall()}
+
+        if "status" not in columns:
+            return
+
+        threshold = datetime.now(timezone.utc) - timedelta(
+            minutes=STUCK_TURN_THRESHOLD_MINUTES
+        )
+        cursor.execute(
+            """
+            SELECT topic_key, status, updated_at
+            FROM turns
+            WHERE status = 'running' AND updated_at < ?
+            ORDER BY updated_at ASC
+            LIMIT 5
+            """,
+            (threshold.isoformat(),),
+        )
+
+        stuck_turns = cursor.fetchall()
+        conn.close()
+
+        if stuck_turns:
+            topics = ", ".join([turn[0] for turn in stuck_turns])
+            checks.append(
+                DoctorCheck(
+                    name="Telegram stuck turns",
+                    passed=False,
+                    message=f"Found {len(stuck_turns)} stuck turns (inactive > {STUCK_TURN_THRESHOLD_MINUTES}m): {topics}",
+                    check_id="telegram.stuck_turns",
+                    fix="Review logs and consider restarting the bot or clearing stuck turns.",
+                )
+            )
+        else:
+            checks.append(
+                DoctorCheck(
+                    name="Telegram stuck turns",
+                    passed=True,
+                    message="No stuck turns detected.",
+                    check_id="telegram.stuck_turns",
+                    severity="info",
+                )
+            )
+    except Exception as exc:
+        logger.debug("Failed to check for stuck turns: %s", exc)
+        checks.append(
+            DoctorCheck(
+                name="Telegram stuck turns",
+                passed=True,
+                message=f"Could not check for stuck turns: {exc}",
+                check_id="telegram.stuck_turns",
+                severity="warning",
+            )
+        )

codex_autorunner/integrations/telegram/handlers/callbacks.py

@@ -9,6 +9,8 @@ from ..adapter import (
     CancelCallback,
     CompactCallback,
     EffortCallback,
+    FlowCallback,
+    FlowRunCallback,
     ModelCallback,
     PageCallback,
     QuestionCancelCallback,
@@ -91,3 +93,8 @@ async def handle_callback(handlers: Any, callback: TelegramCallbackQuery) -> Non
     elif isinstance(parsed, PageCallback):
         if key:
             await handlers._handle_selection_page(key, parsed, callback)
+    elif isinstance(parsed, FlowCallback):
+        await handlers._handle_flow_callback(callback, parsed)
+    elif isinstance(parsed, FlowRunCallback):
+        if key:
+            await handlers._handle_flow_run_callback(key, callback, parsed)