codex-autorunner 0.1.0__py3-none-any.whl

codex_autorunner/integrations/telegram/constants.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+DEFAULT_PAGE_SIZE = 10
+TELEGRAM_MAX_MESSAGE_LENGTH = 4096
+TELEGRAM_CALLBACK_DATA_LIMIT = 64
+THREAD_LIST_PAGE_LIMIT = 100
+THREAD_LIST_MAX_PAGES = 5
+DEFAULT_MODEL_LIST_LIMIT = 25
+DEFAULT_MCP_LIST_LIMIT = 50
+DEFAULT_SKILLS_LIST_LIMIT = 50
+MAX_TOPIC_THREAD_HISTORY = 50
+RESUME_BUTTON_PREVIEW_LIMIT = 60
+RESUME_PREVIEW_USER_LIMIT = 1000
+RESUME_PREVIEW_ASSISTANT_LIMIT = 1000
+RESUME_PREVIEW_SCAN_LINES = 200
+RESUME_MISSING_IDS_LOG_LIMIT = 10
+RESUME_REFRESH_LIMIT = 10
+TOKEN_USAGE_CACHE_LIMIT = 256
+TOKEN_USAGE_TURN_CACHE_LIMIT = 512
+DEFAULT_INTERRUPT_TIMEOUT_SECONDS = 30.0
+DEFAULT_WORKSPACE_STATE_ROOT = "~/.codex-autorunner/workspaces"
+APP_SERVER_START_BACKOFF_INITIAL_SECONDS = 1.0
+APP_SERVER_START_BACKOFF_MAX_SECONDS = 30.0
+CACHE_CLEANUP_INTERVAL_SECONDS = 300.0
+COALESCE_BUFFER_TTL_SECONDS = 60.0
+MODEL_PENDING_TTL_SECONDS = 1800.0
+PENDING_APPROVAL_TTL_SECONDS = 600.0
+REASONING_BUFFER_TTL_SECONDS = 900.0
+SELECTION_STATE_TTL_SECONDS = 1800.0
+TURN_PREVIEW_TTL_SECONDS = 900.0
+OVERSIZE_WARNING_TTL_SECONDS = 3600.0
+UPDATE_ID_PERSIST_INTERVAL_SECONDS = 60.0
+OUTBOX_RETRY_INTERVAL_SECONDS = 10.0
+OUTBOX_IMMEDIATE_RETRY_DELAYS = (0.5, 2.0, 5.0)
+OUTBOX_MAX_ATTEMPTS = 8
+VOICE_RETRY_INTERVAL_SECONDS = 5.0
+VOICE_RETRY_INITIAL_SECONDS = 2.0
+VOICE_RETRY_MAX_SECONDS = 300.0
+VOICE_RETRY_JITTER_RATIO = 0.2
+VOICE_MAX_ATTEMPTS = 20
+VOICE_RETRY_AFTER_BUFFER_SECONDS = 1.0
+WHISPER_TRANSCRIPT_DISCLAIMER = (
+    "Note: transcribed from user voice. If confusing or possibly inaccurate and you "
+    "cannot infer the intention please clarify before proceeding."
+)
+DEFAULT_UPDATE_REPO_URL = "https://github.com/Git-on-my-level/codex-autorunner.git"
+DEFAULT_UPDATE_REPO_REF = "main"
+RESUME_PICKER_PROMPT = (
+    "Select a thread to resume (buttons below or reply with number/id)."
+)
+BIND_PICKER_PROMPT = "Select a repo to bind (buttons below or reply with number/id)."
+MODEL_PICKER_PROMPT = "Select a model (buttons below)."
+EFFORT_PICKER_PROMPT = "Select a reasoning effort for {model}."
+UPDATE_PICKER_PROMPT = "Select update target (buttons below)."
+REVIEW_COMMIT_PICKER_PROMPT = (
+    "Select a commit to review (buttons below or reply with number)."
+)
+REVIEW_COMMIT_BUTTON_LABEL_LIMIT = 80
+UPDATE_TARGET_OPTIONS = (
+    ("both", "Both (web + Telegram)"),
+    ("web", "Web only"),
+    ("telegram", "Telegram only"),
+)
+TRACE_MESSAGE_TOKENS = (
+    "failed",
+    "error",
+    "denied",
+    "unknown",
+    "not bound",
+    "not found",
+    "invalid",
+    "unsupported",
+    "disabled",
+    "missing",
+    "mismatch",
+    "different workspace",
+    "no previous",
+    "no resumable",
+    "no workspace-tagged",
+    "not applicable",
+    "selection expired",
+    "timed out",
+    "timeout",
+    "aborted",
+    "canceled",
+    "cancelled",
+)
+PLACEHOLDER_TEXT = "Working..."
+STREAM_PREVIEW_PREFIX = ""
+THINKING_PREVIEW_MAX_LEN = 80
+THINKING_PREVIEW_MIN_EDIT_INTERVAL_SECONDS = 1.0
+COMMAND_DISABLED_TEMPLATE = "'/{name}' is disabled while a task is in progress."
+MAX_MENTION_BYTES = 200_000
+VALID_REASONING_EFFORTS = {"none", "minimal", "low", "medium", "high", "xhigh"}
+CONTEXT_BASELINE_TOKENS = 12000
+APPROVAL_POLICY_VALUES = {"untrusted", "on-failure", "on-request", "never"}
+APPROVAL_PRESETS = {
+    "read-only": ("on-request", "readOnly"),
+    "auto": ("on-request", "workspaceWrite"),
+    "full-access": ("never", "dangerFullAccess"),
+}
+SHELL_OUTPUT_TRUNCATION_SUFFIX = "\n...(truncated)"
+SHELL_MESSAGE_BUFFER_CHARS = 200
+COMPACT_SUMMARY_PROMPT = (
+    "Summarize the conversation so far into a concise context block I can paste into "
+    "a new thread. Include goals, constraints, decisions, and current state."
+)
+INIT_PROMPT = "\n".join(
+    [
+        "Generate a file named AGENTS.md that serves as a contributor guide for this repository.",
+        "Your goal is to produce a clear, concise, and well-structured document with descriptive headings and actionable explanations for each section.",
+        "Follow the outline below, but adapt as needed - add sections if relevant, and omit those that do not apply to this project.",
+        "",
+        "Document Requirements",
+        "",
+        '- Title the document "Repository Guidelines".',
+        "- Use Markdown headings (#, ##, etc.) for structure.",
+        "- Keep the document concise. 200-400 words is optimal.",
+        "- Keep explanations short, direct, and specific to this repository.",
+        "- Provide examples where helpful (commands, directory paths, naming patterns).",
+        "- Maintain a professional, instructional tone.",
+        "",
+        "Recommended Sections",
+        "",
+        "Project Structure & Module Organization",
+        "",
+        "- Outline the project structure, including where the source code, tests, and assets are located.",
+        "",
+        "Build, Test, and Development Commands",
+        "",
+        "- List key commands for building, testing, and running locally (e.g., npm test, make build).",
+        "- Briefly explain what each command does.",
+        "",
+        "Coding Style & Naming Conventions",
+        "",
+        "- Specify indentation rules, language-specific style preferences, and naming patterns.",
+        "- Include any formatting or linting tools used.",
+        "",
+        "Testing Guidelines",
+        "",
+        "- Identify testing frameworks and coverage requirements.",
+        "- State test naming conventions and how to run tests.",
+        "",
+        "Commit & Pull Request Guidelines",
+        "",
+        "- Summarize commit message conventions found in the project's Git history.",
+        "- Outline pull request requirements (descriptions, linked issues, screenshots, etc.).",
+        "",
+        "(Optional) Add other sections if relevant, such as Security & Configuration Tips, Architecture Overview, or Agent-Specific Instructions.",
+    ]
+)
+
+
+TurnKey = tuple[str, str]

codex_autorunner/integrations/telegram/dispatch.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Optional
+
+from ...core.logging_utils import log_event
+from .adapter import TelegramUpdate, allowlist_allows
+
+
+@dataclass(frozen=True)
+class DispatchContext:
+    chat_id: Optional[int]
+    user_id: Optional[int]
+    thread_id: Optional[int]
+    message_id: Optional[int]
+    is_topic: Optional[bool]
+    is_edited: Optional[bool]
+    topic_key: Optional[str]
+
+
+DispatchRoute = Callable[[Any, TelegramUpdate, DispatchContext], Awaitable[None]]
+
+
+def _build_context(handlers: Any, update: TelegramUpdate) -> DispatchContext:
+    chat_id = None
+    user_id = None
+    thread_id = None
+    message_id = None
+    is_topic = None
+    is_edited = None
+    key = None
+    if update.message:
+        chat_id = update.message.chat_id
+        user_id = update.message.from_user_id
+        thread_id = update.message.thread_id
+        message_id = update.message.message_id
+        is_topic = update.message.is_topic_message
+        is_edited = update.message.is_edited
+        key = handlers._resolve_topic_key(chat_id, thread_id)
+    elif update.callback:
+        chat_id = update.callback.chat_id
+        user_id = update.callback.from_user_id
+        thread_id = update.callback.thread_id
+        message_id = update.callback.message_id
+        if chat_id is not None:
+            key = handlers._resolve_topic_key(chat_id, thread_id)
+    return DispatchContext(
+        chat_id=chat_id,
+        user_id=user_id,
+        thread_id=thread_id,
+        message_id=message_id,
+        is_topic=is_topic,
+        is_edited=is_edited,
+        topic_key=key,
+    )
+
+
+def _log_denied(handlers: Any, update: TelegramUpdate) -> None:
+    chat_id = None
+    user_id = None
+    thread_id = None
+    if update.message:
+        chat_id = update.message.chat_id
+        user_id = update.message.from_user_id
+        thread_id = update.message.thread_id
+    elif update.callback:
+        chat_id = update.callback.chat_id
+        user_id = update.callback.from_user_id
+        thread_id = update.callback.thread_id
+    log_event(
+        handlers._logger,
+        logging.INFO,
+        "telegram.allowlist.denied",
+        chat_id=chat_id,
+        user_id=user_id,
+        thread_id=thread_id,
+    )
+
+
+async def _dispatch_callback(
+    handlers: Any, update: TelegramUpdate, context: DispatchContext
+) -> None:
+    callback = update.callback
+    if callback is None:
+        return
+    if context.topic_key:
+        handlers._enqueue_topic_work(
+            context.topic_key,
+            lambda: handlers._handle_callback(callback),
+            force_queue=True,
+        )
+        return
+    await handlers._handle_callback(callback)
+
+
+async def _dispatch_message(
+    handlers: Any, update: TelegramUpdate, context: DispatchContext
+) -> None:
+    message = update.message
+    if message is None:
+        return
+    if context.topic_key:
+        if handlers._should_bypass_topic_queue(message):
+            await handlers._handle_message(message)
+            return
+        handlers._enqueue_topic_work(
+            context.topic_key,
+            lambda: handlers._handle_message(message),
+            force_queue=True,
+        )
+        return
+    await handlers._handle_message(message)
+
+
+_ROUTES: tuple[tuple[str, DispatchRoute], ...] = (
+    ("callback", _dispatch_callback),
+    ("message", _dispatch_message),
+)
+
+
+async def dispatch_update(handlers: Any, update: TelegramUpdate) -> None:
+    context = _build_context(handlers, update)
+    log_event(
+        handlers._logger,
+        logging.INFO,
+        "telegram.update.received",
+        update_id=update.update_id,
+        chat_id=context.chat_id,
+        user_id=context.user_id,
+        thread_id=context.thread_id,
+        message_id=context.message_id,
+        is_topic=context.is_topic,
+        is_edited=context.is_edited,
+        has_message=bool(update.message),
+        has_callback=bool(update.callback),
+    )
+    if (
+        update.update_id is not None
+        and context.topic_key
+        and not handlers._should_process_update(context.topic_key, update.update_id)
+    ):
+        log_event(
+            handlers._logger,
+            logging.INFO,
+            "telegram.update.duplicate",
+            update_id=update.update_id,
+            chat_id=context.chat_id,
+            thread_id=context.thread_id,
+            message_id=context.message_id,
+        )
+        return
+    if not allowlist_allows(update, handlers._allowlist):
+        _log_denied(handlers, update)
+        return
+    for name, route in _ROUTES:
+        if name == "callback" and update.callback:
+            await route(handlers, update, context)
+            return
+        if name == "message" and update.message:
+            await route(handlers, update, context)
+            return

codex_autorunner/integrations/telegram/handlers/approvals.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from ....core.logging_utils import log_event
+from ....core.state import now_iso
+from ...app_server.client import ApprovalDecision
+from ..adapter import ApprovalCallback, TelegramCallbackQuery, build_approval_keyboard
+from ..config import DEFAULT_APPROVAL_TIMEOUT_SECONDS
+from ..helpers import (
+    _approval_age_seconds,
+    _coerce_id,
+    _extract_turn_thread_id,
+    _format_approval_decision,
+    _format_approval_prompt,
+)
+from ..state import PendingApprovalRecord
+from ..types import PendingApproval
+
+
+class TelegramApprovalHandlers:
+    async def _restore_pending_approvals(self) -> None:
+        state = self._store.load()
+        if not state.pending_approvals:
+            return
+        grouped: dict[tuple[int, int | None], list[PendingApprovalRecord]] = {}
+        for record in state.pending_approvals.values():
+            key = (record.chat_id, record.thread_id)
+            grouped.setdefault(key, []).append(record)
+        for (chat_id, thread_id), records in grouped.items():
+            items = []
+            for record in records:
+                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)
+            message = (
+                "Cleared stale approval requests from a previous session. "
+                "Re-run the request or use /interrupt if the turn is still active.\n"
+                f"Requests: {', '.join(items)}"
+            )
+            try:
+                await self._send_message(
+                    chat_id,
+                    message,
+                    thread_id=thread_id,
+                )
+            except Exception:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.approval.restore_failed",
+                    chat_id=chat_id,
+                    thread_id=thread_id,
+                )
+
+    async def _handle_approval_request(
+        self, message: dict[str, Any]
+    ) -> ApprovalDecision:
+        req_id = message.get("id")
+        params = (
+            message.get("params") if isinstance(message.get("params"), dict) else {}
+        )
+        turn_id = _coerce_id(params.get("turnId")) if isinstance(params, dict) else None
+        if not req_id or not turn_id:
+            return "cancel"
+        codex_thread_id = _extract_turn_thread_id(params)
+        ctx = self._resolve_turn_context(turn_id, thread_id=codex_thread_id)
+        if ctx is None:
+            return "cancel"
+        request_id = str(req_id)
+        prompt = _format_approval_prompt(message)
+        created_at = now_iso()
+        approval_record = PendingApprovalRecord(
+            request_id=request_id,
+            turn_id=str(turn_id),
+            chat_id=ctx.chat_id,
+            thread_id=ctx.thread_id,
+            message_id=None,
+            prompt=prompt,
+            created_at=created_at,
+            topic_key=ctx.topic_key,
+        )
+        self._store.upsert_pending_approval(approval_record)
+        log_event(
+            self._logger,
+            logging.INFO,
+            "telegram.approval.requested",
+            request_id=request_id,
+            turn_id=turn_id,
+            chat_id=ctx.chat_id,
+            thread_id=ctx.thread_id,
+        )
+        try:
+            keyboard = build_approval_keyboard(request_id, include_session=False)
+        except ValueError:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.approval.callback_too_long",
+                request_id=request_id,
+            )
+            self._store.clear_pending_approval(request_id)
+            return "cancel"
+        payload_text, parse_mode = self._prepare_outgoing_text(
+            prompt,
+            chat_id=ctx.chat_id,
+            thread_id=ctx.thread_id,
+            reply_to=ctx.reply_to_message_id,
+            topic_key=ctx.topic_key,
+            codex_thread_id=codex_thread_id,
+        )
+        try:
+            response = await self._bot.send_message(
+                ctx.chat_id,
+                payload_text,
+                message_thread_id=ctx.thread_id,
+                reply_to_message_id=ctx.reply_to_message_id,
+                reply_markup=keyboard,
+                parse_mode=parse_mode,
+            )
+        except Exception as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.approval.send_failed",
+                request_id=request_id,
+                turn_id=turn_id,
+                chat_id=ctx.chat_id,
+                thread_id=ctx.thread_id,
+                exc=exc,
+            )
+            self._store.clear_pending_approval(request_id)
+            try:
+                await self._send_message(
+                    ctx.chat_id,
+                    "Approval prompt failed to send; canceling approval. "
+                    "Please retry or use /interrupt.",
+                    thread_id=ctx.thread_id,
+                    reply_to=ctx.reply_to_message_id,
+                )
+            except Exception:
+                pass
+            return "cancel"
+        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)
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[ApprovalDecision] = loop.create_future()
+        pending = PendingApproval(
+            request_id=request_id,
+            turn_id=str(turn_id),
+            codex_thread_id=codex_thread_id,
+            chat_id=ctx.chat_id,
+            thread_id=ctx.thread_id,
+            topic_key=ctx.topic_key,
+            message_id=message_id if isinstance(message_id, int) else None,
+            created_at=created_at,
+            future=future,
+        )
+        self._pending_approvals[request_id] = pending
+        self._touch_cache_timestamp("pending_approvals", request_id)
+        runtime = self._router.runtime_for(ctx.topic_key)
+        runtime.pending_request_id = request_id
+        try:
+            return await asyncio.wait_for(
+                future, timeout=DEFAULT_APPROVAL_TIMEOUT_SECONDS
+            )
+        except asyncio.TimeoutError:
+            self._pending_approvals.pop(request_id, None)
+            self._store.clear_pending_approval(request_id)
+            runtime.pending_request_id = None
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.approval.timeout",
+                request_id=request_id,
+                turn_id=turn_id,
+                chat_id=ctx.chat_id,
+                thread_id=ctx.thread_id,
+                timeout_seconds=DEFAULT_APPROVAL_TIMEOUT_SECONDS,
+            )
+            if pending.message_id is not None:
+                await self._edit_message_text(
+                    pending.chat_id,
+                    pending.message_id,
+                    "Approval timed out.",
+                    reply_markup={"inline_keyboard": []},
+                )
+            return "cancel"
+        except asyncio.CancelledError:
+            self._pending_approvals.pop(request_id, None)
+            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)
+        pending = self._pending_approvals.pop(parsed.request_id, None)
+        if pending is None:
+            await self._answer_callback(callback, "Approval already handled")
+            return
+        if not pending.future.done():
+            pending.future.set_result(parsed.decision)
+        ctx = self._resolve_turn_context(
+            pending.turn_id, thread_id=pending.codex_thread_id
+        )
+        if ctx:
+            runtime_key = ctx.topic_key
+        elif pending.topic_key:
+            runtime_key = pending.topic_key
+        else:
+            runtime_key = self._resolve_topic_key(pending.chat_id, pending.thread_id)
+        runtime = self._router.runtime_for(runtime_key)
+        runtime.pending_request_id = None
+        log_event(
+            self._logger,
+            logging.INFO,
+            "telegram.approval.decision",
+            request_id=parsed.request_id,
+            decision=parsed.decision,
+            chat_id=callback.chat_id,
+            thread_id=callback.thread_id,
+            message_id=callback.message_id,
+        )
+        await self._answer_callback(callback, f"Decision: {parsed.decision}")
+        if pending.message_id is not None:
+            try:
+                await self._edit_message_text(
+                    pending.chat_id,
+                    pending.message_id,
+                    _format_approval_decision(parsed.decision),
+                    reply_markup={"inline_keyboard": []},
+                )
+            except Exception:
+                return

codex_autorunner/integrations/telegram/handlers/callbacks.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+from ..adapter import (
+    ApprovalCallback,
+    BindCallback,
+    CancelCallback,
+    CompactCallback,
+    EffortCallback,
+    ModelCallback,
+    PageCallback,
+    ResumeCallback,
+    ReviewCommitCallback,
+    TelegramCallbackQuery,
+    UpdateCallback,
+    UpdateConfirmCallback,
+    parse_callback_data,
+)
+
+
+def _selection_contains(items: Sequence[tuple[str, str]], value: str) -> bool:
+    return any(item_id == value for item_id, _ in items)
+
+
+async def handle_callback(handlers: Any, callback: TelegramCallbackQuery) -> None:
+    parsed = parse_callback_data(callback.data)
+    if parsed is None:
+        return
+    key = None
+    if callback.chat_id is not None:
+        key = handlers._resolve_topic_key(callback.chat_id, callback.thread_id)
+    if isinstance(parsed, ApprovalCallback):
+        await handlers._handle_approval_callback(callback, parsed)
+    elif isinstance(parsed, ResumeCallback):
+        if key:
+            state = handlers._resume_options.get(key)
+            if not state or not _selection_contains(state.items, parsed.thread_id):
+                await handlers._answer_callback(callback, "Selection expired")
+                return
+            await handlers._resume_thread_by_id(key, parsed.thread_id, callback)
+    elif isinstance(parsed, BindCallback):
+        if key:
+            state = handlers._bind_options.get(key)
+            if not state or not _selection_contains(state.items, parsed.repo_id):
+                await handlers._answer_callback(callback, "Selection expired")
+                return
+            await handlers._bind_topic_by_repo_id(key, parsed.repo_id, callback)
+    elif isinstance(parsed, ModelCallback):
+        if key:
+            await handlers._handle_model_callback(key, callback, parsed)
+    elif isinstance(parsed, EffortCallback):
+        if key:
+            await handlers._handle_effort_callback(key, callback, parsed)
+    elif isinstance(parsed, UpdateCallback):
+        if key:
+            await handlers._handle_update_callback(key, callback, parsed)
+    elif isinstance(parsed, UpdateConfirmCallback):
+        if key:
+            await handlers._handle_update_confirm_callback(key, callback, parsed)
+    elif isinstance(parsed, ReviewCommitCallback):
+        if key:
+            await handlers._handle_review_commit_callback(key, callback, parsed)
+    elif isinstance(parsed, CancelCallback):
+        if key:
+            await handlers._handle_selection_cancel(key, parsed, callback)
+    elif isinstance(parsed, CompactCallback):
+        if key:
+            await handlers._handle_compact_callback(key, callback, parsed)
+    elif isinstance(parsed, PageCallback):
+        if key:
+            await handlers._handle_selection_page(key, parsed, callback)