codex-autorunner 0.1.2__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,
         )
 
@@ -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/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"

codex_autorunner/routes/__init__.py

@@ -1,16 +1,17 @@
 """
 Modular API routes for the codex-autorunner server.
 
-This package splits the monolithic api_routes.py into focused modules:
-- base: Index, state streaming, and general endpoints
+This package splits monolithic api_routes.py into focused modules:
+- base: Index, WebSocket terminal, and general endpoints
 - agents: Agent harness models and event streaming
 - app_server: App-server thread registry endpoints
-- docs: Document management (read/write) and chat
-- github: GitHub integration endpoints
+- workspace: Optional workspace docs (active_context/decisions/spec)
+- flows: Flow runtime management (start/stop/resume/status/events/artifacts)
+- messages: Inbox/message wrappers over ticket_flow dispatch + reply histories
 - repos: Run control (start/stop/resume/reset)
-- runs: Run telemetry and artifacts
 - sessions: Terminal session registry endpoints
 - settings: Session settings for autorunner overrides
+- file_chat: Unified file chat (tickets + workspace docs)
 - voice: Voice transcription and config
 - terminal_images: Terminal image uploads
 """
@@ -20,26 +21,29 @@ from pathlib import Path
 from fastapi import APIRouter
 
 from .agents import build_agents_routes
+from .analytics import build_analytics_routes
 from .app_server import build_app_server_routes
-from .base import build_base_routes
-from .docs import build_docs_routes
-from .github import build_github_routes
+from .base import build_base_routes, build_frontend_routes
+from .file_chat import build_file_chat_routes
+from .flows import build_flow_routes
+from .messages import build_messages_routes
 from .repos import build_repos_routes
 from .review import build_review_routes
-from .runs import build_runs_routes
 from .sessions import build_sessions_routes
 from .settings import build_settings_routes
 from .system import build_system_routes
 from .terminal_images import build_terminal_image_routes
+from .usage import build_usage_routes
 from .voice import build_voice_routes
+from .workspace import build_workspace_routes
 
 
 def build_repo_router(static_dir: Path) -> APIRouter:
     """
-    Build the complete API router by combining all route modules.
+    Build complete API router by combining all route modules.
 
     Args:
-        static_dir: Path to the static assets directory
+        static_dir: Path to static assets directory
 
     Returns:
         Combined APIRouter with all endpoints
@@ -48,18 +52,23 @@ def build_repo_router(static_dir: Path) -> APIRouter:
 
     # Include all route modules
     router.include_router(build_base_routes(static_dir))
+    router.include_router(build_analytics_routes())
     router.include_router(build_agents_routes())
     router.include_router(build_app_server_routes())
-    router.include_router(build_docs_routes())
-    router.include_router(build_github_routes())
+    router.include_router(build_workspace_routes())
+    router.include_router(build_flow_routes())
+    router.include_router(build_file_chat_routes())
+    router.include_router(build_messages_routes())
     router.include_router(build_repos_routes())
     router.include_router(build_review_routes())
-    router.include_router(build_runs_routes())
     router.include_router(build_sessions_routes())
     router.include_router(build_settings_routes())
     router.include_router(build_system_routes())
     router.include_router(build_terminal_image_routes())
+    router.include_router(build_usage_routes())
     router.include_router(build_voice_routes())
+    # Include frontend routes last to avoid shadowing API routes
+    router.include_router(build_frontend_routes(static_dir))
 
     return router