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

codex_autorunner/integrations/telegram/ticket_flow_bridge.py

@@ -4,15 +4,20 @@ import asyncio
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Optional
+from typing import Awaitable, Callable, Optional
 
+from ...core.config import load_repo_config
 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.logging_utils import log_event
 from ...core.utils import canonicalize_path
 from ...flows.ticket_flow import build_ticket_flow_definition
+from ...manifest import load_manifest
 from ...tickets import AgentPool
+from .adapter import chunk_message
+from .constants import TELEGRAM_MAX_MESSAGE_LENGTH
 from .state import parse_topic_key
 
 
@@ -26,11 +31,24 @@ class TelegramTicketFlowBridge:
         store,
         pause_targets: dict[str, str],
         send_message_with_outbox,
+        send_document: Callable[..., Awaitable[bool]],
+        pause_config,
+        default_notification_chat_id: Optional[int],
+        hub_root: Optional[Path] = None,
+        manifest_path: Optional[Path] = None,
+        config_root: Optional[Path] = None,
     ) -> None:
         self._logger = logger
         self._store = store
         self._pause_targets = pause_targets
         self._send_message_with_outbox = send_message_with_outbox
+        self._send_document = send_document
+        self._pause_config = pause_config
+        self._default_notification_chat_id = default_notification_chat_id
+        self._hub_root = hub_root
+        self._manifest_path = manifest_path
+        self._config_root = config_root
+        self._last_default_notification: dict[Path, str] = {}
 
     @staticmethod
     def _select_ticket_flow_topic(
@@ -75,24 +93,32 @@ class TelegramTicketFlowBridge:
             try:
                 await self._scan_and_notify_pauses()
             except Exception as exc:
-                self._logger.warning("telegram.ticket_flow.watch_failed", exc_info=exc)
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.ticket_flow.watch_failed",
+                    exc=exc,
+                )
             await asyncio.sleep(interval)
 
     async def _scan_and_notify_pauses(self) -> None:
-        topics = await self._store.list_topics()
-        if not topics:
+        if not self._pause_config.enabled:
             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))
+        topics = await self._store.list_topics()
+        workspace_topics = self._get_all_workspaces(topics or {})
 
-        tasks = [
-            asyncio.create_task(self._notify_ticket_flow_pause(workspace_root, entries))
-            for workspace_root, entries in workspace_topics.items()
-        ]
+        tasks = []
+        for workspace_root, entries in workspace_topics.items():
+            if entries:
+                tasks.append(
+                    asyncio.create_task(
+                        self._notify_ticket_flow_pause(workspace_root, entries)
+                    )
+                )
+            else:
+                tasks.append(
+                    asyncio.create_task(self._notify_via_default_chat(workspace_root))
+                )
         if tasks:
             await asyncio.gather(*tasks, return_exceptions=True)
 
@@ -106,15 +132,17 @@ class TelegramTicketFlowBridge:
                 self._load_ticket_flow_pause, workspace_root
             )
         except Exception as exc:
-            self._logger.warning(
+            log_event(
+                self._logger,
+                logging.WARNING,
                 "telegram.ticket_flow.scan_failed",
-                exc_info=exc,
+                exc=exc,
                 workspace_root=str(workspace_root),
             )
             return
         if pause is None:
             return
-        run_id, seq, content = pause
+        run_id, seq, content, archived_dir = pause
         marker = f"{run_id}:{seq}"
         pending = [
             (key, record)
@@ -126,7 +154,6 @@ class TelegramTicketFlowBridge:
         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
@@ -148,17 +175,21 @@ class TelegramTicketFlowBridge:
             return
 
         try:
-            await self._send_message_with_outbox(
+            await self._send_full_dispatch(
                 chat_id,
-                message_text,
-                thread_id=thread_id,
-                reply_to=None,
+                thread_id,
+                run_id=run_id,
+                seq=seq,
+                content=content,
+                archived_dir=archived_dir,
             )
             self._pause_targets[str(workspace_root)] = run_id
         except Exception as exc:
-            self._logger.warning(
+            log_event(
+                self._logger,
+                logging.WARNING,
                 "telegram.ticket_flow.notify_failed",
-                exc_info=exc,
+                exc=exc,
                 topic_key=primary_key,
                 run_id=run_id,
                 seq=seq,
@@ -177,13 +208,42 @@ class TelegramTicketFlowBridge:
 
         return apply
 
+    def _get_all_workspaces(
+        self, topics: dict[str, object]
+    ) -> dict[Path, list[tuple[str, object]]]:
+        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))
+
+        # Include config root
+        if self._config_root:
+            workspace_topics.setdefault(self._config_root.resolve(), [])
+
+        # Include hub manifest worktrees (for web-originated flows)
+        if self._hub_root and self._manifest_path and self._manifest_path.exists():
+            try:
+                manifest = load_manifest(self._manifest_path, self._hub_root)
+                for repo in manifest.repos:
+                    path = canonicalize_path((self._hub_root / repo.path).resolve())
+                    workspace_topics.setdefault(path, [])
+            except Exception as exc:
+                self._logger.debug(
+                    "telegram.ticket_flow.manifest_load_failed", exc_info=exc
+                )
+
+        return workspace_topics
+
     def _load_ticket_flow_pause(
         self, workspace_root: Path
-    ) -> Optional[tuple[str, str, str]]:
+    ) -> Optional[tuple[str, str, str, Optional[Path]]]:
         db_path = workspace_root / ".codex-autorunner" / "flows.db"
         if not db_path.exists():
             return None
-        store = FlowStore(db_path)
+        config = load_repo_config(workspace_root)
+        store = FlowStore(db_path, durable=config.durable_writes)
         try:
             store.initialize()
             runs = store.list_flow_runs(
@@ -207,13 +267,13 @@ class TelegramTicketFlowBridge:
             seq = self._latest_dispatch_seq(history_dir)
             if not seq:
                 reason = self._format_ticket_flow_pause_reason(latest)
-                return latest.id, "paused", reason
+                return latest.id, "paused", reason, None
             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
+            return latest.id, seq, content, history_dir / seq
         finally:
             store.close()
 
@@ -241,24 +301,14 @@ class TelegramTicketFlowBridge:
         )
         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)
+        config = load_repo_config(workspace_root)
+        store = FlowStore(db_path, durable=config.durable_writes)
         try:
             store.initialize()
             if preferred_run_id:
@@ -283,21 +333,266 @@ class TelegramTicketFlowBridge:
             if updated:
                 _spawn_ticket_worker(workspace_root, updated.id, self._logger)
         except Exception as exc:
-            self._logger.warning(
+            log_event(
+                self._logger,
+                logging.WARNING,
                 "telegram.ticket_flow.auto_resume_failed",
                 exc=exc,
                 run_id=run_id,
                 workspace_root=str(workspace_root),
             )
 
+    async def _notify_via_default_chat(self, workspace_root: Path) -> None:
+        if not self._pause_config.enabled or self._default_notification_chat_id is None:
+            return
+        try:
+            pause = await asyncio.to_thread(
+                self._load_ticket_flow_pause, workspace_root
+            )
+        except Exception as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.ticket_flow.scan_failed",
+                exc=exc,
+                workspace_root=str(workspace_root),
+            )
+            return
+        if pause is None:
+            return
+        run_id, seq, content, archived_dir = pause
+        marker = f"{run_id}:{seq}"
+        previous = self._last_default_notification.get(workspace_root)
+        if previous == marker:
+            return
+        try:
+            await self._send_full_dispatch(
+                self._default_notification_chat_id,
+                None,
+                run_id=run_id,
+                seq=seq,
+                content=content,
+                archived_dir=archived_dir,
+            )
+            self._last_default_notification[workspace_root] = marker
+            self._pause_targets[str(workspace_root)] = run_id
+        except Exception as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.ticket_flow.notify_default_failed",
+                exc=exc,
+                chat_id=self._default_notification_chat_id,
+                run_id=run_id,
+                seq=seq,
+            )
+
+    async def _send_full_dispatch(
+        self,
+        chat_id: int,
+        thread_id: Optional[int],
+        *,
+        run_id: str,
+        seq: str,
+        content: str,
+        archived_dir: Optional[Path],
+    ) -> None:
+        await self._send_dispatch_text(
+            chat_id,
+            thread_id,
+            run_id=run_id,
+            seq=seq,
+            content=content,
+        )
+        if self._pause_config.send_attachments and archived_dir:
+            await self._send_dispatch_attachments(
+                chat_id,
+                thread_id,
+                run_id=run_id,
+                seq=seq,
+                archived_dir=archived_dir,
+            )
+
+    async def _send_dispatch_text(
+        self,
+        chat_id: int,
+        thread_id: Optional[int],
+        *,
+        run_id: str,
+        seq: str,
+        content: str,
+    ) -> None:
+        body = content.strip() or "(no dispatch message)"
+        header = f"Ticket flow paused (run {run_id}). Latest dispatch #{seq}:\n\n"
+        footer = "\n\nUse /flow resume to continue."
+        full_text = f"{header}{body}{footer}"
+
+        if self._pause_config.chunk_long_messages:
+            chunks = chunk_message(
+                full_text,
+                max_len=TELEGRAM_MAX_MESSAGE_LENGTH,
+                with_numbering=True,
+            )
+        else:
+            chunks = [full_text]
+
+        for idx, chunk in enumerate(chunks):
+            await self._send_message_with_outbox(
+                chat_id,
+                chunk,
+                thread_id=thread_id,
+                reply_to=None,
+            )
+            if idx == 0:
+                await asyncio.sleep(0)
+
+    async def _send_dispatch_attachments(
+        self,
+        chat_id: int,
+        thread_id: Optional[int],
+        *,
+        run_id: str,
+        seq: str,
+        archived_dir: Path,
+    ) -> None:
+        try:
+            items = sorted(
+                [
+                    child
+                    for child in archived_dir.iterdir()
+                    if child.is_file()
+                    and child.name != "DISPATCH.md"
+                    and not child.name.startswith(".")
+                ],
+                key=lambda p: p.name,
+            )
+        except OSError as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.ticket_flow.attachments_list_failed",
+                exc=exc,
+                run_id=run_id,
+                seq=seq,
+                dir=str(archived_dir),
+            )
+            return
+
+        for item in items:
+            await self._send_single_attachment(
+                chat_id,
+                thread_id,
+                run_id=run_id,
+                seq=seq,
+                path=item,
+            )
+
+    async def _send_single_attachment(
+        self,
+        chat_id: int,
+        thread_id: Optional[int],
+        *,
+        run_id: str,
+        seq: str,
+        path: Path,
+    ) -> None:
+        try:
+            size = path.stat().st_size
+        except OSError:
+            size = None
+        if size is not None and size > self._pause_config.max_file_size_bytes:
+            warning = (
+                f"Skipped attachment {path.name} "
+                f"({size} bytes > {self._pause_config.max_file_size_bytes} limit)."
+            )
+            await self._send_message_with_outbox(
+                chat_id,
+                warning,
+                thread_id=thread_id,
+                reply_to=None,
+            )
+            return
+        try:
+            data = path.read_bytes()
+        except OSError as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.ticket_flow.attachment_read_failed",
+                exc=exc,
+                file=str(path),
+                run_id=run_id,
+                seq=seq,
+            )
+            await self._send_message_with_outbox(
+                chat_id,
+                f"Failed to read attachment {path.name}.",
+                thread_id=thread_id,
+                reply_to=None,
+            )
+            return
+        caption = f"[run {run_id} dispatch #{seq}] {path.name}"
+        send_ok = False
+        try:
+            send_ok = await self._send_document(
+                chat_id,
+                data,
+                filename=path.name,
+                thread_id=thread_id,
+                reply_to=None,
+                caption=caption[:1024],
+            )
+            if not send_ok:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.ticket_flow.attachment_send_failed",
+                    file=str(path),
+                    run_id=run_id,
+                    seq=seq,
+                )
+        except Exception as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.ticket_flow.attachment_send_failed",
+                exc=exc,
+                file=str(path),
+                run_id=run_id,
+                seq=seq,
+            )
+        if not send_ok:
+            await self._send_message_with_outbox(
+                chat_id,
+                f"Failed to send attachment {path.name}.",
+                thread_id=thread_id,
+                reply_to=None,
+            )
+
 
 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
+    from ...agents.registry import validate_agent_id
+    from ...core.config import load_repo_config
+    from ...core.runtime import RuntimeContext
+    from ...integrations.agents import build_backend_orchestrator
+    from ...integrations.agents.wiring import (
+        build_agent_backend_factory,
+        build_app_server_supervisor_factory,
+    )
 
-    engine = Engine(repo_root)
+    config = load_repo_config(repo_root)
+    backend_orchestrator = build_backend_orchestrator(repo_root, config)
+    engine = RuntimeContext(
+        repo_root,
+        config=config,
+        backend_orchestrator=backend_orchestrator,
+        backend_factory=build_agent_backend_factory(repo_root, config),
+        app_server_supervisor_factory=build_app_server_supervisor_factory(config),
+        agent_id_validator=validate_agent_id,
+    )
     agent_pool = AgentPool(engine.config)
     definition = build_ticket_flow_definition(agent_pool=agent_pool)
     definition.validate()

codex_autorunner/integrations/telegram/transport.py

@@ -265,6 +265,7 @@ class TelegramMessageTransport:
         thread_id: Optional[int] = None,
         reply_to: Optional[int] = None,
         reply_markup: Optional[dict[str, Any]] = None,
+        parse_mode: Optional[str] = None,
     ) -> None:
         if _should_trace_message(text):
             text = _with_conversation_id(
@@ -279,9 +280,15 @@ class TelegramMessageTransport:
         )
         if prefix:
             text = f"{prefix}{text}"
-        parse_mode = self._config.parse_mode
-        if parse_mode:
-            rendered, used_mode = self._render_message(text)
+        effective_parse_mode = parse_mode or self._config.parse_mode
+        if effective_parse_mode:
+            try:
+                rendered, used_mode = self._render_message(
+                    text, parse_mode=effective_parse_mode
+                )
+            except TypeError:
+                # Back-compat for subclasses/tests that don't accept parse_mode kwarg
+                rendered, used_mode = self._render_message(text)  # type: ignore[misc]
             if used_mode and len(rendered) > TELEGRAM_MAX_MESSAGE_LENGTH:
                 overflow_mode = getattr(self._config, "message_overflow", "document")
                 if overflow_mode == "split" and used_mode in (
@@ -384,7 +391,7 @@ class TelegramMessageTransport:
         thread_id: Optional[int] = None,
         reply_to: Optional[int] = None,
         caption: Optional[str] = None,
-    ) -> None:
+    ) -> bool:
         try:
             await self._bot.send_document(
                 chat_id,
@@ -394,6 +401,7 @@ class TelegramMessageTransport:
                 reply_to_message_id=reply_to,
                 caption=caption,
             )
+            return True
         except Exception as exc:
             log_event(
                 self._logger,
@@ -404,6 +412,7 @@ class TelegramMessageTransport:
                 reply_to_message_id=reply_to,
                 exc=exc,
             )
+            return False
 
     async def _answer_callback(
         self, callback: Optional[TelegramCallbackQuery], text: str

codex_autorunner/integrations/templates/__init__.py

@@ -0,0 +1,27 @@
+"""Template integration helpers."""
+
+from .scan_agent import (
+    TemplateScanBackendError,
+    TemplateScanDecision,
+    TemplateScanError,
+    TemplateScanFormatError,
+    TemplateScanRejectedError,
+    build_template_scan_prompt,
+    format_template_scan_rejection,
+    parse_template_scan_output,
+    run_template_scan,
+    run_template_scan_with_orchestrator,
+)
+
+__all__ = [
+    "TemplateScanBackendError",
+    "TemplateScanDecision",
+    "TemplateScanError",
+    "TemplateScanFormatError",
+    "TemplateScanRejectedError",
+    "build_template_scan_prompt",
+    "format_template_scan_rejection",
+    "parse_template_scan_output",
+    "run_template_scan",
+    "run_template_scan_with_orchestrator",
+]