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

codex_autorunner/integrations/telegram/ticket_flow_bridge.py

@@ -0,0 +1,322 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from ...core.flows import FlowStore
+from ...core.flows.controller import FlowController
+from ...core.flows.models import FlowRunRecord, FlowRunStatus
+from ...core.flows.worker_process import spawn_flow_worker
+from ...core.utils import canonicalize_path
+from ...flows.ticket_flow import build_ticket_flow_definition
+from ...tickets import AgentPool
+from .state import parse_topic_key
+
+
+class TelegramTicketFlowBridge:
+    """Encapsulate ticket_flow pause/resume plumbing for Telegram service."""
+
+    def __init__(
+        self,
+        *,
+        logger: logging.Logger,
+        store,
+        pause_targets: dict[str, str],
+        send_message_with_outbox,
+    ) -> None:
+        self._logger = logger
+        self._store = store
+        self._pause_targets = pause_targets
+        self._send_message_with_outbox = send_message_with_outbox
+
+    @staticmethod
+    def _select_ticket_flow_topic(
+        entries: list[tuple[str, object]],
+    ) -> Optional[tuple[str, object]]:
+        if not entries:
+            return None
+
+        def score(entry: tuple[str, object]) -> tuple[int, float, str]:
+            key, record = entry
+            thread_id = None
+            try:
+                _chat_id, thread_id, _scope = parse_topic_key(key)
+            except Exception:
+                thread_id = None
+            active_raw = getattr(record, "active_thread_id", None)
+            try:
+                active_thread = int(active_raw) if active_raw is not None else None
+            except (TypeError, ValueError):
+                active_thread = None
+            active_match = (
+                int(thread_id) == active_thread if thread_id is not None else False
+            )
+            last_active_at = getattr(record, "last_active_at", None)
+            last_active = TelegramTicketFlowBridge._parse_last_active(last_active_at)
+            return (1 if active_match else 0, last_active, key)
+
+        return max(entries, key=score)
+
+    @staticmethod
+    def _parse_last_active(raw: Optional[str]) -> float:
+        if not isinstance(raw, str):
+            return float("-inf")
+        try:
+            return datetime.strptime(raw, "%Y-%m-%dT%H:%M:%SZ").timestamp()
+        except ValueError:
+            return float("-inf")
+
+    async def watch_ticket_flow_pauses(self, interval_seconds: float) -> None:
+        interval = max(interval_seconds, 1.0)
+        while True:
+            try:
+                await self._scan_and_notify_pauses()
+            except Exception as exc:
+                self._logger.warning("telegram.ticket_flow.watch_failed", exc_info=exc)
+            await asyncio.sleep(interval)
+
+    async def _scan_and_notify_pauses(self) -> None:
+        topics = await self._store.list_topics()
+        if not topics:
+            return
+        workspace_topics: dict[Path, list[tuple[str, object]]] = {}
+        for key, record in topics.items():
+            if not isinstance(record.workspace_path, str) or not record.workspace_path:
+                continue
+            workspace_root = canonicalize_path(Path(record.workspace_path))
+            workspace_topics.setdefault(workspace_root, []).append((key, record))
+
+        tasks = [
+            asyncio.create_task(self._notify_ticket_flow_pause(workspace_root, entries))
+            for workspace_root, entries in workspace_topics.items()
+        ]
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+    async def _notify_ticket_flow_pause(
+        self,
+        workspace_root: Path,
+        entries: list[tuple[str, object]],
+    ) -> None:
+        try:
+            pause = await asyncio.to_thread(
+                self._load_ticket_flow_pause, workspace_root
+            )
+        except Exception as exc:
+            self._logger.warning(
+                "telegram.ticket_flow.scan_failed",
+                exc_info=exc,
+                workspace_root=str(workspace_root),
+            )
+            return
+        if pause is None:
+            return
+        run_id, seq, content = pause
+        marker = f"{run_id}:{seq}"
+        pending = [
+            (key, record)
+            for key, record in entries
+            if getattr(record, "last_ticket_dispatch_seq", None) != marker
+        ]
+        if not pending:
+            return
+        primary = self._select_ticket_flow_topic(pending)
+        if not primary:
+            return
+        message_text = self._format_ticket_flow_pause_message(run_id, seq, content)
+        updates: list[tuple[str, Optional[str]]] = [
+            (key, getattr(record, "last_ticket_dispatch_seq", None))
+            for key, record in pending
+        ]
+        for key, _previous in updates:
+            await self._store.update_topic(
+                key, self._set_ticket_dispatch_marker(marker)
+            )
+
+        primary_key, _primary_record = primary
+        try:
+            chat_id, thread_id, _scope = parse_topic_key(primary_key)
+        except Exception as exc:
+            self._logger.debug("Failed to parse topic key: %s", exc)
+            for key, previous in updates:
+                await self._store.update_topic(
+                    key, self._set_ticket_dispatch_marker(previous)
+                )
+            return
+
+        try:
+            await self._send_message_with_outbox(
+                chat_id,
+                message_text,
+                thread_id=thread_id,
+                reply_to=None,
+            )
+            self._pause_targets[str(workspace_root)] = run_id
+        except Exception as exc:
+            self._logger.warning(
+                "telegram.ticket_flow.notify_failed",
+                exc_info=exc,
+                topic_key=primary_key,
+                run_id=run_id,
+                seq=seq,
+            )
+            for key, previous in updates:
+                await self._store.update_topic(
+                    key, self._set_ticket_dispatch_marker(previous)
+                )
+
+    @staticmethod
+    def _set_ticket_dispatch_marker(
+        value: Optional[str],
+    ):
+        def apply(topic) -> None:
+            topic.last_ticket_dispatch_seq = value
+
+        return apply
+
+    def _load_ticket_flow_pause(
+        self, workspace_root: Path
+    ) -> Optional[tuple[str, str, str]]:
+        db_path = workspace_root / ".codex-autorunner" / "flows.db"
+        if not db_path.exists():
+            return None
+        store = FlowStore(db_path)
+        try:
+            store.initialize()
+            runs = store.list_flow_runs(
+                flow_type="ticket_flow", status=FlowRunStatus.PAUSED
+            )
+            if not runs:
+                return None
+            latest = runs[0]
+            runs_dir_raw = latest.input_data.get("runs_dir")
+            runs_dir = (
+                Path(runs_dir_raw)
+                if isinstance(runs_dir_raw, str) and runs_dir_raw
+                else Path(".codex-autorunner/runs")
+            )
+            from ...tickets.outbox import resolve_outbox_paths
+
+            paths = resolve_outbox_paths(
+                workspace_root=workspace_root, runs_dir=runs_dir, run_id=latest.id
+            )
+            history_dir = paths.dispatch_history_dir
+            seq = self._latest_dispatch_seq(history_dir)
+            if not seq:
+                reason = self._format_ticket_flow_pause_reason(latest)
+                return latest.id, "paused", reason
+            message_path = history_dir / seq / "DISPATCH.md"
+            try:
+                content = message_path.read_text(encoding="utf-8")
+            except OSError:
+                return None
+            return latest.id, seq, content
+        finally:
+            store.close()
+
+    @staticmethod
+    def _latest_dispatch_seq(history_dir: Path) -> Optional[str]:
+        if not history_dir.exists() or not history_dir.is_dir():
+            return None
+        seqs = [
+            child.name
+            for child in history_dir.iterdir()
+            if child.is_dir()
+            and not child.name.startswith(".")
+            and child.name.isdigit()
+        ]
+        if not seqs:
+            return None
+        return max(seqs)
+
+    @staticmethod
+    def _format_ticket_flow_pause_reason(record: FlowRunRecord) -> str:
+        state = record.state or {}
+        engine = state.get("ticket_engine") or {}
+        reason = (
+            engine.get("reason") or record.error_message or "Paused without details."
+        )
+        return f"Reason: {reason}"
+
+    def _format_ticket_flow_pause_message(
+        self, run_id: str, seq: str, content: str
+    ) -> str:
+        from .helpers import _truncate_text
+
+        trimmed = _truncate_text(content.strip() or "(no dispatch message)", 3000)
+        return (
+            f"Ticket flow paused (run {run_id}). Latest dispatch #{seq}:\n\n"
+            f"{trimmed}\n\nUse /flow resume to continue."
+        )
+
+    def get_paused_ticket_flow(
+        self, workspace_root: Path, preferred_run_id: Optional[str] = None
+    ) -> Optional[tuple[str, FlowRunRecord]]:
+        db_path = workspace_root / ".codex-autorunner" / "flows.db"
+        if not db_path.exists():
+            return None
+        store = FlowStore(db_path)
+        try:
+            store.initialize()
+            if preferred_run_id:
+                preferred = store.get_flow_run(preferred_run_id)
+                if preferred and preferred.status == FlowRunStatus.PAUSED:
+                    return preferred.id, preferred
+            runs = store.list_flow_runs(
+                flow_type="ticket_flow", status=FlowRunStatus.PAUSED
+            )
+            if not runs:
+                return None
+            latest = runs[0]
+            return latest.id, latest
+        finally:
+            store.close()
+
+    async def auto_resume_run(self, workspace_root: Path, run_id: str) -> None:
+        """Best-effort resume + worker spawn; failures are logged only."""
+        try:
+            controller = _ticket_controller_for(workspace_root)
+            updated = await controller.resume_flow(run_id)
+            if updated:
+                _spawn_ticket_worker(workspace_root, updated.id, self._logger)
+        except Exception as exc:
+            self._logger.warning(
+                "telegram.ticket_flow.auto_resume_failed",
+                exc=exc,
+                run_id=run_id,
+                workspace_root=str(workspace_root),
+            )
+
+
+def _ticket_controller_for(repo_root: Path) -> FlowController:
+    repo_root = repo_root.resolve()
+    db_path = repo_root / ".codex-autorunner" / "flows.db"
+    artifacts_root = repo_root / ".codex-autorunner" / "flows"
+    from ...core.engine import Engine
+
+    engine = Engine(repo_root)
+    agent_pool = AgentPool(engine.config)
+    definition = build_ticket_flow_definition(agent_pool=agent_pool)
+    definition.validate()
+    controller = FlowController(
+        definition=definition, db_path=db_path, artifacts_root=artifacts_root
+    )
+    controller.initialize()
+    return controller
+
+
+def _spawn_ticket_worker(repo_root: Path, run_id: str, logger: logging.Logger) -> None:
+    try:
+        proc, out, err = spawn_flow_worker(repo_root, run_id)
+        out.close()
+        err.close()
+        logger.info("Started ticket_flow worker for %s (pid=%s)", run_id, proc.pid)
+    except Exception as exc:
+        logger.warning(
+            "ticket_flow.worker.spawn_failed",
+            exc_info=exc,
+            extra={"run_id": run_id},
+        )

codex_autorunner/integrations/telegram/transport.py

@@ -41,14 +41,33 @@ class TelegramMessageTransport:
         message_id: int,
         text: str,
         *,
+        message_thread_id: Optional[int] = None,
         reply_markup: Optional[dict[str, Any]] = None,
     ) -> bool:
         try:
             payload_text, parse_mode = self._prepare_message(text)
+            if len(payload_text) > TELEGRAM_MAX_MESSAGE_LENGTH:
+                trimmed = trim_markdown_message(
+                    payload_text,
+                    max_len=TELEGRAM_MAX_MESSAGE_LENGTH,
+                    render=(
+                        _format_telegram_html
+                        if parse_mode == "HTML"
+                        else (
+                            lambda v: (
+                                _format_telegram_markdown(v, parse_mode)
+                                if parse_mode in ("Markdown", "MarkdownV2")
+                                else v
+                            )
+                        )
+                    ),
+                )
+                payload_text = trimmed
             await self._bot.edit_message_text(
                 chat_id,
                 message_id,
                 payload_text,
+                message_thread_id=message_thread_id,
                 reply_markup=reply_markup,
                 parse_mode=parse_mode,
             )
@@ -56,11 +75,17 @@ class TelegramMessageTransport:
             return False
         return True
 
-    async def _delete_message(self, chat_id: int, message_id: Optional[int]) -> bool:
+    async def _delete_message(
+        self, chat_id: int, message_id: Optional[int], thread_id: Optional[int] = None
+    ) -> bool:
         if message_id is None:
             return False
         try:
-            return bool(await self._bot.delete_message(chat_id, message_id))
+            return bool(
+                await self._bot.delete_message(
+                    chat_id, message_id, message_thread_id=thread_id
+                )
+            )
         except Exception:
             return False
 
@@ -77,6 +102,7 @@ class TelegramMessageTransport:
             callback.chat_id,
             callback.message_id,
             text,
+            message_thread_id=callback.thread_id,
             reply_markup=reply_markup,
         )
 
@@ -283,7 +309,7 @@ class TelegramMessageTransport:
                             message_thread_id=thread_id,
                             reply_to_message_id=reply_to if idx == 0 else None,
                             reply_markup=reply_markup if idx == 0 else None,
-                            parse_mode="HTML",
+                            parse_mode=used_mode,
                         )
                     return
                 if overflow_mode == "trim":
@@ -385,7 +411,13 @@ class TelegramMessageTransport:
         if callback is None:
             return
         try:
-            await self._bot.answer_callback_query(callback.callback_id, text=text)
+            await self._bot.answer_callback_query(
+                callback.callback_id,
+                chat_id=callback.chat_id,
+                thread_id=callback.thread_id,
+                message_id=callback.message_id,
+                text=text,
+            )
         except Exception as exc:
             log_event(
                 self._logger,
@@ -393,6 +425,7 @@ class TelegramMessageTransport:
                 "telegram.answer_callback.failed",
                 chat_id=callback.chat_id,
                 thread_id=callback.thread_id,
+                message_id=callback.message_id,
                 callback_id=callback.callback_id,
                 exc=exc,
             )

codex_autorunner/integrations/telegram/trigger_mode.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from .adapter import TelegramMessage
+
+TriggerMode = Literal["all", "mentions"]
+
+
+def should_trigger_run(
+    message: TelegramMessage,
+    *,
+    text: str,
+    bot_username: Optional[str],
+) -> bool:
+    """Return True if this message should start a run in mentions-only mode.
+
+    This mirrors Takopi's "mentions" trigger mode semantics (subset):
+
+    - Always trigger in private chats.
+    - Trigger when the bot is explicitly mentioned: "@<bot_username>" anywhere in the text.
+    - Trigger when replying to a bot message (but ignore the common forum-topic
+      "implicit root reply" case where clients set reply_to_message_id == thread_id).
+    - Otherwise, do not trigger (commands and other explicit affordances are handled elsewhere).
+    """
+
+    if message.chat_type == "private":
+        return True
+
+    lowered = (text or "").lower()
+    if bot_username:
+        needle = f"@{bot_username}".lower()
+        if needle in lowered:
+            return True
+
+    implicit_topic_reply = (
+        message.thread_id is not None
+        and message.reply_to_message_id is not None
+        and message.reply_to_message_id == message.thread_id
+    )
+
+    if message.reply_to_is_bot and not implicit_topic_reply:
+        return True
+
+    if (
+        bot_username
+        and message.reply_to_username
+        and message.reply_to_username.lower() == bot_username.lower()
+        and not implicit_topic_reply
+    ):
+        return True
+
+    return False

codex_autorunner/integrations/telegram/types.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import asyncio
 import dataclasses
-from dataclasses import dataclass
-from typing import Optional
+from dataclasses import dataclass, field
+from typing import Optional, Union
 
 from ..app_server.client import ApprovalDecision
 from .helpers import ModelOption
@@ -22,6 +22,26 @@ class PendingApproval:
     future: asyncio.Future[ApprovalDecision]
 
 
+@dataclass
+class PendingQuestion:
+    request_id: str
+    turn_id: str
+    codex_thread_id: Optional[str]
+    chat_id: int
+    thread_id: Optional[int]
+    topic_key: Optional[str]
+    message_id: Optional[int]
+    created_at: str
+    question_index: int
+    prompt: str
+    options: list[str]
+    future: asyncio.Future[Union[list[int], str, None]]
+    multiple: bool = False
+    custom: bool = True
+    selected_indices: set[int] = field(default_factory=set)
+    awaiting_custom_input: bool = False
+
+
 @dataclass
 class TurnContext:
     topic_key: str

codex_autorunner/integrations/telegram/voice.py

@@ -65,7 +65,7 @@ class TelegramVoiceManager:
         self._lock = asyncio.Lock()
 
     async def restore(self) -> None:
-        records = self._store.list_pending_voice()
+        records = await self._store.list_pending_voice()
         if not records:
             return
         log_event(
@@ -80,7 +80,7 @@ class TelegramVoiceManager:
         while True:
             await asyncio.sleep(VOICE_RETRY_INTERVAL_SECONDS)
             try:
-                records = self._store.list_pending_voice()
+                records = await self._store.list_pending_voice()
                 if records:
                     await self._flush(records)
             except Exception as exc:
@@ -92,7 +92,7 @@ class TelegramVoiceManager:
                 )
 
     async def attempt(self, record_id: str) -> bool:
-        record = self._store.get_pending_voice(record_id)
+        record = await self._store.get_pending_voice(record_id)
         if record is None:
             return False
         if not self._ready_for_attempt(record):
@@ -101,7 +101,7 @@ class TelegramVoiceManager:
             return False
         inflight_id = record.record_id
         try:
-            current_record = self._store.get_pending_voice(record.record_id)
+            current_record = await self._store.get_pending_voice(record.record_id)
             if current_record is None:
                 return False
             if not self._ready_for_attempt(current_record):
@@ -114,7 +114,7 @@ class TelegramVoiceManager:
         finally:
             await self._clear_inflight(inflight_id)
         if done:
-            self._store.delete_pending_voice(record.record_id)
+            await self._store.delete_pending_voice(record.record_id)
         return done
 
     async def _flush(self, records: list[PendingVoiceRecord]) -> None:
@@ -155,7 +155,7 @@ class TelegramVoiceManager:
             await self._deliver_transcript(record, record.transcript_text)
             self._remove_voice_file(record)
             return True
-        path = self._resolve_voice_download_path(record)
+        path = await self._resolve_voice_download_path(record)
         if path is None:
             data, file_path, file_size = await self._download_file(record.file_id)
             if file_size and file_size > max_bytes:
@@ -180,11 +180,10 @@ class TelegramVoiceManager:
                 record.file_size = file_size
             else:
                 record.file_size = len(data)
-            self._store.update_pending_voice(record)
+            await self._store.update_pending_voice(record)
         data = path.read_bytes()
         try:
-            result = await asyncio.to_thread(
-                self._voice_service.transcribe,
+            result = await self._voice_service.transcribe_async(
                 data,
                 client="telegram",
                 filename=record.file_name or path.name,
@@ -236,7 +235,7 @@ class TelegramVoiceManager:
             text_len=len(transcript),
         )
         record.transcript_text = combined
-        self._store.update_pending_voice(record)
+        await self._store.update_pending_voice(record)
         await self._deliver_transcript(record, combined)
         self._remove_voice_file(record)
         return True
@@ -253,7 +252,7 @@ class TelegramVoiceManager:
         record.last_attempt_at = now_iso()
         delay = self._retry_delay(record.attempts, retry_after=retry_after)
         record.next_attempt_at = _format_future_time(delay)
-        self._store.update_pending_voice(record)
+        await self._store.update_pending_voice(record)
         log_event(
             self._logger,
             logging.WARNING,
@@ -273,7 +272,7 @@ class TelegramVoiceManager:
             )
             if progress_id is not None:
                 record.progress_message_id = progress_id
-                self._store.update_pending_voice(record)
+                await self._store.update_pending_voice(record)
         if record.attempts >= VOICE_MAX_ATTEMPTS:
             await self._give_up(
                 record,
@@ -295,7 +294,7 @@ class TelegramVoiceManager:
                 reply_to=record.message_id,
             )
         self._remove_voice_file(record)
-        self._store.delete_pending_voice(record.record_id)
+        await self._store.delete_pending_voice(record.record_id)
         log_event(
             self._logger,
             logging.WARNING,
@@ -337,7 +336,7 @@ class TelegramVoiceManager:
             delay += random.uniform(0, jitter)
         return delay
 
-    def _resolve_voice_download_path(
+    async def _resolve_voice_download_path(
         self, record: PendingVoiceRecord
     ) -> Optional[Path]:
         if not record.download_path:
@@ -346,7 +345,7 @@ class TelegramVoiceManager:
         if path.exists():
             return path
         record.download_path = None
-        self._store.update_pending_voice(record)
+        await self._store.update_pending_voice(record)
         return None
 
     def _persist_voice_payload(

codex_autorunner/manifest.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, List, Optional, cast
 import yaml
 
 MANIFEST_VERSION = 2
+MANIFEST_HEADER = "# GENERATED by CAR - DO NOT EDIT\n"
 _SAFE_REPO_ID_PATTERN = re.compile(r"^[A-Za-z0-9._-]+$")
 _SANITIZE_REPO_ID_PATTERN = re.compile(r"[^A-Za-z0-9._-]+")
 
@@ -194,4 +195,5 @@ def save_manifest(manifest_path: Path, manifest: Manifest, hub_root: Path) -> No
         "repos": [repo.to_dict(hub_root) for repo in manifest.repos],
     }
     with manifest_path.open("w", encoding="utf-8") as f:
+        f.write(MANIFEST_HEADER)
         yaml.safe_dump(payload, f, sort_keys=False)

codex_autorunner/plugin_api.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+"""Codex Autorunner plugin API metadata.
+
+This module is intentionally small and stable. External plugins SHOULD depend
+only on the public API in `codex_autorunner.api` + this version constant.
+
+Notes:
+- Backwards-incompatible changes to the plugin API MUST bump
+  `CAR_PLUGIN_API_VERSION`.
+"""
+
+CAR_PLUGIN_API_VERSION = 1
+
+# Entry point groups (Python packaging entry points).
+#
+# Plugins can publish new agent backends by defining an entry point:
+#
+#   [project.entry-points."codex_autorunner.agent_backends"]
+#   myagent = "my_package.my_module:AGENT_BACKEND"
+#
+CAR_AGENT_ENTRYPOINT_GROUP = "codex_autorunner.agent_backends"