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

codex_autorunner/integrations/telegram/doctor.py

@@ -0,0 +1,47 @@
+"""Telegram integration doctor checks."""
+
+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
+
+
+def telegram_doctor_checks(
+    config: Union[HubConfig, RepoConfig, Dict[str, Any]],
+) -> list[DoctorCheck]:
+    """Run Telegram-specific doctor checks.
+
+    Returns a list of DoctorCheck objects for Telegram integration.
+    Works with HubConfig, RepoConfig, or raw dict.
+    """
+    checks: list[DoctorCheck] = []
+    telegram_cfg = None
+
+    if isinstance(config, dict):
+        telegram_cfg = config.get("telegram_bot")
+    elif isinstance(config.raw, dict):
+        telegram_cfg = config.raw.get("telegram_bot")
+
+    if isinstance(telegram_cfg, dict) and telegram_cfg.get("enabled") is True:
+        missing_telegram = missing_optional_dependencies((("httpx", "httpx"),))
+        if missing_telegram:
+            deps_list = ", ".join(missing_telegram)
+            checks.append(
+                DoctorCheck(
+                    check_id="telegram.dependencies",
+                    status="error",
+                    message=f"Telegram is enabled but missing optional deps: {deps_list}",
+                    fix="Install with `pip install codex-autorunner[telegram]`.",
+                )
+            )
+        else:
+            checks.append(
+                DoctorCheck(
+                    check_id="telegram.dependencies",
+                    status="ok",
+                    message="Telegram dependencies are installed.",
+                )
+            )
+
+    return checks

codex_autorunner/integrations/telegram/handlers/approvals.py

@@ -22,7 +22,7 @@ from ..types import PendingApproval
 
 class TelegramApprovalHandlers:
     async def _restore_pending_approvals(self) -> None:
-        state = self._store.load()
+        state = await self._store.load()
         if not state.pending_approvals:
             return
         grouped: dict[tuple[int, int | None], list[PendingApprovalRecord]] = {}
@@ -35,7 +35,7 @@ class TelegramApprovalHandlers:
                 age = _approval_age_seconds(record.created_at)
                 age_label = f"{age}s" if isinstance(age, int) else "unknown age"
                 items.append(f"{record.request_id} ({age_label})")
-                self._store.clear_pending_approval(record.request_id)
+                await self._store.clear_pending_approval(record.request_id)
             message = (
                 "Cleared stale approval requests from a previous session. "
                 "Re-run the request or use /interrupt if the turn is still active.\n"
@@ -83,7 +83,7 @@ class TelegramApprovalHandlers:
             created_at=created_at,
             topic_key=ctx.topic_key,
         )
-        self._store.upsert_pending_approval(approval_record)
+        await self._store.upsert_pending_approval(approval_record)
         log_event(
             self._logger,
             logging.INFO,
@@ -102,7 +102,7 @@ class TelegramApprovalHandlers:
                 "telegram.approval.callback_too_long",
                 request_id=request_id,
             )
-            self._store.clear_pending_approval(request_id)
+            await self._store.clear_pending_approval(request_id)
             return "cancel"
         payload_text, parse_mode = self._prepare_outgoing_text(
             prompt,
@@ -132,7 +132,7 @@ class TelegramApprovalHandlers:
                 thread_id=ctx.thread_id,
                 exc=exc,
             )
-            self._store.clear_pending_approval(request_id)
+            await self._store.clear_pending_approval(request_id)
             try:
                 await self._send_message(
                     ctx.chat_id,
@@ -147,7 +147,7 @@ class TelegramApprovalHandlers:
         message_id = response.get("message_id") if isinstance(response, dict) else None
         if isinstance(message_id, int):
             approval_record.message_id = message_id
-            self._store.upsert_pending_approval(approval_record)
+            await self._store.upsert_pending_approval(approval_record)
         loop = asyncio.get_running_loop()
         future: asyncio.Future[ApprovalDecision] = loop.create_future()
         pending = PendingApproval(
@@ -171,7 +171,7 @@ class TelegramApprovalHandlers:
             )
         except asyncio.TimeoutError:
             self._pending_approvals.pop(request_id, None)
-            self._store.clear_pending_approval(request_id)
+            await self._store.clear_pending_approval(request_id)
             runtime.pending_request_id = None
             log_event(
                 self._logger,
@@ -193,14 +193,14 @@ class TelegramApprovalHandlers:
             return "cancel"
         except asyncio.CancelledError:
             self._pending_approvals.pop(request_id, None)
-            self._store.clear_pending_approval(request_id)
+            await self._store.clear_pending_approval(request_id)
             runtime.pending_request_id = None
             raise
 
     async def _handle_approval_callback(
         self, callback: TelegramCallbackQuery, parsed: ApprovalCallback
     ) -> None:
-        self._store.clear_pending_approval(parsed.request_id)
+        await self._store.clear_pending_approval(parsed.request_id)
         pending = self._pending_approvals.pop(parsed.request_id, None)
         if pending is None:
             await self._answer_callback(callback, "Approval already handled")
@@ -215,7 +215,9 @@ class TelegramApprovalHandlers:
         elif pending.topic_key:
             runtime_key = pending.topic_key
         else:
-            runtime_key = self._resolve_topic_key(pending.chat_id, pending.thread_id)
+            runtime_key = await self._resolve_topic_key(
+                pending.chat_id, pending.thread_id
+            )
         runtime = self._router.runtime_for(runtime_key)
         runtime.pending_request_id = None
         log_event(

codex_autorunner/integrations/telegram/handlers/callbacks.py

@@ -11,6 +11,10 @@ from ..adapter import (
     EffortCallback,
     ModelCallback,
     PageCallback,
+    QuestionCancelCallback,
+    QuestionCustomCallback,
+    QuestionDoneCallback,
+    QuestionOptionCallback,
     ResumeCallback,
     ReviewCommitCallback,
     TelegramCallbackQuery,
@@ -30,9 +34,19 @@ async def handle_callback(handlers: Any, callback: TelegramCallbackQuery) -> Non
         return
     key = None
     if callback.chat_id is not None:
-        key = handlers._resolve_topic_key(callback.chat_id, callback.thread_id)
+        key = await handlers._resolve_topic_key(callback.chat_id, callback.thread_id)
     if isinstance(parsed, ApprovalCallback):
         await handlers._handle_approval_callback(callback, parsed)
+    elif isinstance(
+        parsed,
+        (
+            QuestionOptionCallback,
+            QuestionCancelCallback,
+            QuestionCustomCallback,
+            QuestionDoneCallback,
+        ),
+    ):
+        await handlers._handle_question_callback(callback, parsed)
     elif isinstance(parsed, ResumeCallback):
         if key:
             state = handlers._resume_options.get(key)

codex_autorunner/integrations/telegram/handlers/commands/__init__.py

@@ -0,0 +1,29 @@
+"""Command handler modules for Telegram integration.
+
+This package contains focused modules for handling different categories of Telegram commands.
+"""
+
+from ..commands_spec import CommandSpec, build_command_specs
+from .approvals import ApprovalsCommands
+from .execution import ExecutionCommands
+from .files import FilesCommands
+from .flows import FlowCommands
+from .formatting import FormattingHelpers
+from .github import GitHubCommands
+from .shared import SharedHelpers
+from .voice import VoiceCommands
+from .workspace import WorkspaceCommands
+
+__all__ = [
+    "SharedHelpers",
+    "WorkspaceCommands",
+    "GitHubCommands",
+    "FilesCommands",
+    "VoiceCommands",
+    "FlowCommands",
+    "ExecutionCommands",
+    "ApprovalsCommands",
+    "FormattingHelpers",
+    "CommandSpec",
+    "build_command_specs",
+]

codex_autorunner/integrations/telegram/handlers/commands/approvals.py

@@ -0,0 +1,173 @@
+import asyncio
+from typing import Any, Optional
+
+from ....app_server.client import CodexAppServerError
+from ...adapter import TelegramMessage
+from ...config import AppServerUnavailableError
+from ...constants import APPROVAL_POLICY_VALUES, APPROVAL_PRESETS
+from ...helpers import (
+    _clear_policy_overrides,
+    _extract_rate_limits,
+    _format_persist_note,
+    _format_sandbox_policy,
+    _normalize_approval_preset,
+    _set_policy_overrides,
+)
+from .shared import SharedHelpers
+
+
+class ApprovalsCommands(SharedHelpers):
+    async def _read_rate_limits(
+        self, workspace_path: Optional[str], *, agent: str
+    ) -> Optional[dict[str, Any]]:
+        if self._agent_rate_limit_source(agent) != "app_server":
+            return None
+        try:
+            client = await self._client_for_workspace(workspace_path)
+        except AppServerUnavailableError:
+            return None
+        if client is None:
+            return None
+        for method in ("account/rateLimits/read", "account/read"):
+            try:
+                result = await client.request(method, params=None, timeout=5.0)
+            except (CodexAppServerError, asyncio.TimeoutError):
+                continue
+            rate_limits = _extract_rate_limits(result)
+            if rate_limits:
+                return rate_limits
+        return None
+
+    async def _handle_approvals(
+        self, message: TelegramMessage, args: str, _runtime: Optional[Any] = None
+    ) -> None:
+        argv = self._parse_command_args(args)
+        record = await self._router.ensure_topic(message.chat_id, message.thread_id)
+        argv, persist = self._extract_persist_flag(argv)
+        if not argv:
+            await self._send_approval_status(message, record)
+            return
+        mode = argv[0].lower()
+        if mode in ("yolo", "off", "disable", "disabled"):
+            await self._set_approval_mode(message, "yolo", persist=persist)
+            return
+        if mode in ("safe", "on", "enable", "enabled"):
+            await self._set_approval_mode(message, "safe", persist=persist)
+            return
+        preset = _normalize_approval_preset(mode)
+        if mode == "preset" and len(argv) > 1:
+            preset = _normalize_approval_preset(argv[1])
+        if preset:
+            await self._apply_preset_policy(message, preset, persist=persist)
+            return
+        approval_policy = argv[0] if argv[0] in APPROVAL_POLICY_VALUES else None
+        if approval_policy:
+            sandbox_policy = argv[1] if len(argv) > 1 else None
+            await self._apply_direct_policy(
+                message, approval_policy, sandbox_policy, persist=persist
+            )
+            return
+        await self._send_approval_usage(message)
+
+    def _extract_persist_flag(self, argv: list[str]) -> tuple[list[str], bool]:
+        """Return argv without the persist flag and whether the flag was provided."""
+        if "--persist" not in argv:
+            return argv, False
+        return [arg for arg in argv if arg != "--persist"], True
+
+    async def _send_approval_status(
+        self, message: TelegramMessage, record: Any
+    ) -> None:
+        """Send the current approval mode and policy to the user."""
+        approval_policy, sandbox_policy = self._effective_policies(record)
+        await self._send_message(
+            message.chat_id,
+            "\n".join(
+                [
+                    f"Approval mode: {record.approval_mode}",
+                    f"Approval policy: {approval_policy or 'default'}",
+                    f"Sandbox policy: {_format_sandbox_policy(sandbox_policy)}",
+                    "Usage: /approvals yolo|safe|read-only|auto|full-access",
+                ]
+            ),
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+
+    async def _send_approval_usage(self, message: TelegramMessage) -> None:
+        """Send the usage hint for the /approvals command."""
+        await self._send_message(
+            message.chat_id,
+            "Usage: /approvals yolo|safe|read-only|auto|full-access",
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+
+    async def _set_approval_mode(
+        self, message: TelegramMessage, mode: str, *, persist: bool
+    ) -> None:
+        """Switch between safe and yolo modes and clear overrides."""
+        await self._router.set_approval_mode(message.chat_id, message.thread_id, mode)
+        await self._router.update_topic(
+            message.chat_id,
+            message.thread_id,
+            lambda record: _clear_policy_overrides(record),
+        )
+        await self._send_message(
+            message.chat_id,
+            _format_persist_note(f"Approval mode set to {mode}.", persist=persist),
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+
+    async def _apply_preset_policy(
+        self, message: TelegramMessage, preset: str, *, persist: bool
+    ) -> None:
+        """Apply an approval preset and persist if requested."""
+        approval_policy, sandbox_policy = APPROVAL_PRESETS[preset]
+        await self._router.update_topic(
+            message.chat_id,
+            message.thread_id,
+            lambda record: _set_policy_overrides(
+                record,
+                approval_policy=approval_policy,
+                sandbox_policy=sandbox_policy,
+            ),
+        )
+        await self._send_message(
+            message.chat_id,
+            _format_persist_note(
+                f"Approval policy set to {approval_policy} with sandbox {sandbox_policy}.",
+                persist=persist,
+            ),
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+
+    async def _apply_direct_policy(
+        self,
+        message: TelegramMessage,
+        approval_policy: str,
+        sandbox_policy: Optional[str],
+        *,
+        persist: bool,
+    ) -> None:
+        """Set explicit approval and sandbox policies."""
+        await self._router.update_topic(
+            message.chat_id,
+            message.thread_id,
+            lambda record: _set_policy_overrides(
+                record,
+                approval_policy=approval_policy,
+                sandbox_policy=sandbox_policy,
+            ),
+        )
+        await self._send_message(
+            message.chat_id,
+            _format_persist_note(
+                f"Approval policy set to {approval_policy} with sandbox {sandbox_policy or 'default'}.",
+                persist=persist,
+            ),
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )