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

codex_autorunner/integrations/telegram/helpers.py

@@ -9,6 +9,7 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Callable, Iterable, Optional, Sequence
 
+from ...core.state_roots import resolve_global_state_root
 from ...core.utils import (
     RepoNotFoundError,
     canonicalize_path,
@@ -885,10 +886,13 @@ def _format_help_text(command_specs: dict[str, CommandSpec]) -> str:
         "new",
         "resume",
         "review",
+        "flow",
+        "reply",
         "pr",
         "agent",
         "model",
         "approvals",
+        "pma",
         "status",
         "diff",
         "mention",
@@ -917,6 +921,23 @@ def _format_help_text(command_specs: dict[str, CommandSpec]) -> str:
         lines.append("/review custom <instructions> (or /review custom to prompt)")
         lines.append("/review detached ...")
 
+    if "flow" in command_specs:
+        lines.append("")
+        lines.append("Flow:")
+        lines.append("/flow")
+        lines.append("/flow status [run_id]")
+        lines.append("/flow bootstrap [--force-new]")
+        lines.append("/flow issue <issue#|url>")
+        lines.append("/flow plan <text>")
+        lines.append("/flow resume [run_id]")
+        lines.append("/flow stop [run_id]")
+        lines.append("/flow recover [run_id]")
+        lines.append("/flow restart")
+        lines.append("/flow archive [run_id] [--force]")
+        lines.append("/flow reply <message>")
+        if "reply" in command_specs:
+            lines.append("/reply <message> (legacy)")
+
     lines.append("")
     lines.append("Other:")
     lines.append("Note: /resume is supported for the codex and opencode agents.")
@@ -2103,7 +2124,7 @@ def _telegram_lock_path(token: str) -> Path:
     if not isinstance(token, str) or not token:
         raise ValueError("token is required")
     digest = hashlib.sha256(token.encode("utf-8")).hexdigest()[:12]
-    return Path.home() / ".codex-autorunner" / "locks" / f"telegram_bot_{digest}.lock"
+    return resolve_global_state_root() / "locks" / f"telegram_bot_{digest}.lock"
 
 
 def _read_lock_payload(path: Path) -> Optional[dict[str, Any]]:

codex_autorunner/integrations/telegram/runtime.py

@@ -265,8 +265,11 @@ class TelegramRuntimeHelpers:
             text = f"{prefix}{text}"
         return self._prepare_message(text)
 
-    def _render_message(self, text: str) -> tuple[str, Optional[str]]:
-        parse_mode = self._config.parse_mode
+    def _render_message(
+        self, text: str, *, parse_mode: Optional[str] = None
+    ) -> tuple[str, Optional[str]]:
+        # Allow callers to override parse_mode (needed for ad-hoc Markdown/HTML sends)
+        parse_mode = self._config.parse_mode if parse_mode is None else parse_mode
         if not parse_mode:
             return text, None
         if parse_mode == "HTML":
@@ -275,8 +278,10 @@ class TelegramRuntimeHelpers:
             return _format_telegram_markdown(text, parse_mode), parse_mode
         return text, parse_mode
 
-    def _prepare_message(self, text: str) -> tuple[str, Optional[str]]:
-        rendered, parse_mode = self._render_message(text)
+    def _prepare_message(
+        self, text: str, *, parse_mode: Optional[str] = None
+    ) -> tuple[str, Optional[str]]:
+        rendered, parse_mode = self._render_message(text, parse_mode=parse_mode)
         # Avoid parse_mode when chunking to keep markup intact.
         if parse_mode and len(rendered) <= TELEGRAM_MAX_MESSAGE_LENGTH:
             return rendered, parse_mode

codex_autorunner/integrations/telegram/service.py

@@ -16,11 +16,17 @@ if TYPE_CHECKING:
     from .state import TelegramTopicRecord
 
 from ...agents.opencode.supervisor import OpenCodeSupervisor
+from ...core.app_server_threads import (
+    AppServerThreadRegistry,
+    default_app_server_threads_path,
+)
 from ...core.flows.models import FlowRunRecord
+from ...core.hub import HubSupervisor
 from ...core.locks import process_alive
 from ...core.logging_utils import log_event
 from ...core.request_context import reset_conversation_id, set_conversation_id
 from ...core.state import now_iso
+from ...core.state_roots import resolve_global_state_root
 from ...core.text_delta_coalescer import TextDeltaCoalescer
 from ...core.utils import build_opencode_supervisor
 from ...housekeeping import HousekeepingConfig, run_housekeeping_for_roots
@@ -47,7 +53,6 @@ from .config import (
 )
 from .constants import (
     DEFAULT_INTERRUPT_TIMEOUT_SECONDS,
-    DEFAULT_WORKSPACE_STATE_ROOT,
     QUEUED_PLACEHOLDER_TEXT,
     TurnKey,
 )
@@ -173,6 +178,31 @@ class TelegramBotService(
         self._logger = logger or logging.getLogger(__name__)
         self._hub_root = hub_root
         self._manifest_path = manifest_path
+        self._hub_supervisor = None
+        self._hub_thread_registry = None
+        if self._hub_root:
+            try:
+                self._hub_supervisor = HubSupervisor.from_path(self._hub_root)
+            except Exception as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.pma.hub_supervisor.unavailable",
+                    hub_root=str(self._hub_root),
+                    exc=exc,
+                )
+            try:
+                self._hub_thread_registry = AppServerThreadRegistry(
+                    default_app_server_threads_path(self._hub_root)
+                )
+            except Exception as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.pma.thread_registry.unavailable",
+                    hub_root=str(self._hub_root),
+                    exc=exc,
+                )
         self._update_repo_url = update_repo_url
         self._update_repo_ref = update_repo_ref
         self._update_skip_checks = update_skip_checks
@@ -182,7 +212,7 @@ class TelegramBotService(
             config.state_file, default_approval_mode=config.defaults.approval_mode
         )
         self._router = TopicRouter(self._store)
-        self._app_server_state_root = Path(DEFAULT_WORKSPACE_STATE_ROOT).expanduser()
+        self._app_server_state_root = resolve_global_state_root() / "workspaces"
         self._app_server_supervisor = WorkspaceAppServerSupervisor(
             config.app_server_command,
             state_root=self._app_server_state_root,
@@ -247,9 +277,16 @@ class TelegramBotService(
             store=self._store,
             pause_targets=self._ticket_flow_pause_targets,
             send_message_with_outbox=self._send_message_with_outbox,
+            send_document=self._send_document,
+            pause_config=self._config.pause_dispatch_notifications,
+            default_notification_chat_id=self._config.default_notification_chat_id,
+            hub_root=hub_root,
+            manifest_path=manifest_path,
+            config_root=self._config.root,
         )
         self._resume_options: dict[str, SelectionState] = {}
         self._bind_options: dict[str, SelectionState] = {}
+        self._flow_run_options: dict[str, SelectionState] = {}
         self._update_options: dict[str, SelectionState] = {}
         self._update_confirm_options: dict[str, bool] = {}
         self._review_commit_options: dict[str, ReviewCommitSelectionState] = {}
@@ -886,6 +923,8 @@ class TelegramBotService(
                 self._resume_options.pop(key, None)
             elif cache_name == "bind_options":
                 self._bind_options.pop(key, None)
+            elif cache_name == "flow_run_options":
+                self._flow_run_options.pop(key, None)
             elif cache_name == "agent_options":
                 self._agent_options.pop(key, None)
             elif cache_name == "update_options":
@@ -938,6 +977,9 @@ class TelegramBotService(
             self._evict_expired_cache_entries(
                 "bind_options", self._config.cache.selection_state_ttl_seconds
             )
+            self._evict_expired_cache_entries(
+                "flow_run_options", self._config.cache.selection_state_ttl_seconds
+            )
             self._evict_expired_cache_entries(
                 "agent_options", self._config.cache.selection_state_ttl_seconds
             )
@@ -1027,7 +1069,7 @@ class TelegramBotService(
 
     def _load_ticket_flow_pause(
         self, workspace_root: Path
-    ) -> Optional[tuple[str, str, str]]:
+    ) -> Optional[tuple[str, str, str, Optional[Path]]]:
         return self._ticket_flow_bridge._load_ticket_flow_pause(workspace_root)
 
     def _latest_dispatch_seq(self, history_dir: Path) -> Optional[str]:
@@ -1036,13 +1078,6 @@ class TelegramBotService(
     def _format_ticket_flow_pause_reason(self, record: "FlowRunRecord") -> str:
         return self._ticket_flow_bridge._format_ticket_flow_pause_reason(record)
 
-    def _format_ticket_flow_pause_message(
-        self, run_id: str, seq: str, content: str
-    ) -> str:
-        return self._ticket_flow_bridge._format_ticket_flow_pause_message(
-            run_id, seq, content
-        )
-
     def _get_paused_ticket_flow(
         self, workspace_root: Path, preferred_run_id: Optional[str] = None
     ) -> Optional[tuple[str, FlowRunRecord]]:

codex_autorunner/integrations/telegram/state.py

@@ -190,6 +190,11 @@ class TelegramTopicRecord:
     repo_id: Optional[str] = None
     workspace_path: Optional[str] = None
     workspace_id: Optional[str] = None
+    pma_enabled: bool = False
+    pma_prev_repo_id: Optional[str] = None
+    pma_prev_workspace_path: Optional[str] = None
+    pma_prev_workspace_id: Optional[str] = None
+    pma_prev_active_thread_id: Optional[str] = None
     active_thread_id: Optional[str] = None
     thread_ids: list[str] = dataclasses.field(default_factory=list)
     thread_summaries: dict[str, ThreadSummary] = dataclasses.field(default_factory=dict)
@@ -220,6 +225,29 @@ class TelegramTopicRecord:
         workspace_id = payload.get("workspace_id") or payload.get("workspaceId")
         if not isinstance(workspace_id, str):
             workspace_id = None
+        pma_enabled = payload.get("pma_enabled") or payload.get("pmaEnabled")
+        if not isinstance(pma_enabled, bool):
+            pma_enabled = False
+        pma_prev_repo_id = payload.get("pma_prev_repo_id") or payload.get(
+            "pmaPrevRepoId"
+        )
+        if not isinstance(pma_prev_repo_id, str):
+            pma_prev_repo_id = None
+        pma_prev_workspace_path = payload.get("pma_prev_workspace_path") or payload.get(
+            "pmaPrevWorkspacePath"
+        )
+        if not isinstance(pma_prev_workspace_path, str):
+            pma_prev_workspace_path = None
+        pma_prev_workspace_id = payload.get("pma_prev_workspace_id") or payload.get(
+            "pmaPrevWorkspaceId"
+        )
+        if not isinstance(pma_prev_workspace_id, str):
+            pma_prev_workspace_id = None
+        pma_prev_active_thread_id = payload.get(
+            "pma_prev_active_thread_id"
+        ) or payload.get("pmaPrevActiveThreadId")
+        if not isinstance(pma_prev_active_thread_id, str):
+            pma_prev_active_thread_id = None
         active_thread_id = payload.get("active_thread_id") or payload.get(
             "activeThreadId"
         )
@@ -301,6 +329,11 @@ class TelegramTopicRecord:
             repo_id=repo_id,
             workspace_path=workspace_path,
             workspace_id=workspace_id,
+            pma_enabled=pma_enabled,
+            pma_prev_repo_id=pma_prev_repo_id,
+            pma_prev_workspace_path=pma_prev_workspace_path,
+            pma_prev_workspace_id=pma_prev_workspace_id,
+            pma_prev_active_thread_id=pma_prev_active_thread_id,
             active_thread_id=active_thread_id,
             thread_ids=thread_ids,
             thread_summaries=thread_summaries,
@@ -324,6 +357,11 @@ class TelegramTopicRecord:
             "repo_id": self.repo_id,
             "workspace_path": self.workspace_path,
             "workspace_id": self.workspace_id,
+            "pma_enabled": self.pma_enabled,
+            "pma_prev_repo_id": self.pma_prev_repo_id,
+            "pma_prev_workspace_path": self.pma_prev_workspace_path,
+            "pma_prev_workspace_id": self.pma_prev_workspace_id,
+            "pma_prev_active_thread_id": self.pma_prev_active_thread_id,
             "active_thread_id": self.active_thread_id,
             "thread_ids": list(self.thread_ids),
             "thread_summaries": {