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

codex_autorunner/integrations/telegram/handlers/commands_runtime.py

@@ -20,6 +20,7 @@ from ....agents.opencode.supervisor import OpenCodeSupervisorError
 from ....core.logging_utils import log_event
 from ....core.state import now_iso
 from ....core.update import _normalize_update_target, _spawn_update_process
+from ....core.update_paths import resolve_update_paths
 from ....core.utils import canonicalize_path
 from ...app_server.client import _normalize_sandbox_policy
 from ..adapter import (
@@ -869,7 +870,7 @@ class TelegramCommandHandlers(
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
         self._model_options.pop(key, None)
         self._model_pending.pop(key, None)
-        record = await self._router.get_topic(key)
+        record = await self._router.ensure_topic(message.chat_id, message.thread_id)
         agent = self._effective_agent(record)
         supports_effort = self._agent_supports_effort(agent)
         list_params = {
@@ -877,10 +878,17 @@ class TelegramCommandHandlers(
             "limit": DEFAULT_MODEL_LIST_LIMIT,
             "agent": agent,
         }
-        try:
-            client = await self._client_for_workspace(
-                record.workspace_path if record else None
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if workspace_path is None:
+            await self._send_message(
+                message.chat_id,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
             )
+            return
+        try:
+            client = await self._client_for_workspace(workspace_path)
         except AppServerUnavailableError as exc:
             log_event(
                 self._logger,
@@ -900,16 +908,20 @@ class TelegramCommandHandlers(
         if client is None:
             await self._send_message(
                 message.chat_id,
-                "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
                 thread_id=message.thread_id,
                 reply_to=message.message_id,
             )
             return
         argv = self._parse_command_args(args)
         if not argv:
+            record_for_models = self._record_with_workspace_path(record, workspace_path)
             try:
                 result = await self._fetch_model_list(
-                    record, agent=agent, client=client, list_params=list_params
+                    record_for_models,
+                    agent=agent,
+                    client=client,
+                    list_params=list_params,
                 )
             except OpenCodeSupervisorError as exc:
                 log_event(
@@ -992,9 +1004,13 @@ class TelegramCommandHandlers(
             )
             return
         if argv[0].lower() in ("list", "ls"):
+            record_for_models = self._record_with_workspace_path(record, workspace_path)
             try:
                 result = await self._fetch_model_list(
-                    record, agent=agent, client=client, list_params=list_params
+                    record_for_models,
+                    agent=agent,
+                    client=client,
+                    list_params=list_params,
                 )
             except OpenCodeSupervisorError as exc:
                 log_event(
@@ -1107,6 +1123,101 @@ class TelegramCommandHandlers(
             reply_to=message.message_id,
         )
 
+    async def _handle_pma(
+        self, message: TelegramMessage, args: str, _runtime: Any
+    ) -> None:
+        if not self._hub_root:
+            await self._send_message(
+                message.chat_id,
+                "PMA unavailable; hub root not configured.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        supervisor = getattr(self, "_hub_supervisor", None)
+        if supervisor and hasattr(supervisor, "hub_config"):
+            pma_config = supervisor.hub_config.pma
+            if not pma_config.enabled:
+                await self._send_message(
+                    message.chat_id,
+                    "PMA is disabled in hub config. Set pma.enabled: true to enable.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+        argv = self._parse_command_args(args)
+        action = argv[0].lower() if argv else ""
+        key = await self._resolve_topic_key(message.chat_id, message.thread_id)
+        record = await self._router.get_topic(key)
+        current = bool(record and record.pma_enabled)
+        if action in ("status", "show"):
+            enabled = current
+        elif action in ("on", "enable", "true"):
+            enabled = True
+        elif action in ("off", "disable", "false"):
+            enabled = False
+        elif action:
+            await self._send_message(
+                message.chat_id,
+                "Usage: /pma [on|off|status]",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        else:
+            enabled = not current
+
+        if record is None:
+            await self._router.ensure_topic(message.chat_id, message.thread_id)
+
+        def apply_pma(record: TelegramTopicRecord) -> None:
+            record.pma_enabled = enabled
+            if enabled:
+                # Save previous binding before entering PMA mode.
+                record.pma_prev_repo_id = record.repo_id
+                record.pma_prev_workspace_path = record.workspace_path
+                record.pma_prev_workspace_id = record.workspace_id
+                record.pma_prev_active_thread_id = record.active_thread_id
+                # Mutual exclusion: PMA mode implies Hub context, so unbind specific repo.
+                record.workspace_path = None
+                record.repo_id = None
+                record.workspace_id = None
+                record.active_thread_id = None
+            else:
+                # Restore previous binding when exiting PMA mode.
+                if record.pma_prev_repo_id or record.pma_prev_workspace_path:
+                    record.repo_id = record.pma_prev_repo_id
+                    record.workspace_path = record.pma_prev_workspace_path
+                    record.workspace_id = record.pma_prev_workspace_id
+                    record.active_thread_id = record.pma_prev_active_thread_id
+                    # Clear saved previous binding after restore.
+                    record.pma_prev_repo_id = None
+                    record.pma_prev_workspace_path = None
+                    record.pma_prev_workspace_id = None
+                    record.pma_prev_active_thread_id = None
+
+        await self._router.update_topic(
+            message.chat_id,
+            message.thread_id,
+            apply_pma,
+        )
+        status = "enabled" if enabled else "disabled"
+        if enabled:
+            hint = "Use /pma off to exit. Previous repo binding saved."
+        else:
+            previous = (record and record.pma_prev_workspace_path) or None
+            if previous:
+                hint = f"Back to repo mode. Restored {previous}."
+            else:
+                hint = "Back to repo mode."
+        await self._send_message(
+            message.chat_id,
+            f"PMA mode {status}. {hint}",
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+
     async def _opencode_review_arguments(target: dict[str, Any]) -> str:
         target_type = target.get("type")
         if target_type == "uncommittedChanges":
@@ -1833,10 +1944,14 @@ class TelegramCommandHandlers(
     async def _apply_compact_summary(
         self, message: TelegramMessage, record: "TelegramTopicRecord", summary_text: str
     ) -> tuple[bool, str | None]:
-        if not record.workspace_path:
-            return (False, "Topic not bound. Use /bind <repo_id> or /bind <path>.")
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if not workspace_path:
+            return (
+                False,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+            )
         try:
-            client = await self._client_for_workspace(record.workspace_path)
+            client = await self._client_for_workspace(workspace_path)
         except AppServerUnavailableError as exc:
             log_event(
                 self._logger,
@@ -1848,7 +1963,10 @@ class TelegramCommandHandlers(
             )
             return False, "App server unavailable; try again or check logs."
         if client is None:
-            return (False, "Topic not bound. Use /bind <repo_id> or /bind <path>.")
+            return (
+                False,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+            )
         log_event(
             self._logger,
             logging.INFO,
@@ -1856,11 +1974,11 @@ class TelegramCommandHandlers(
             chat_id=message.chat_id,
             thread_id=message.thread_id,
             summary_len=len(summary_text),
-            workspace_path=record.workspace_path,
+            workspace_path=workspace_path,
         )
         try:
             agent = self._effective_agent(record)
-            thread = await client.thread_start(record.workspace_path, agent=agent)
+            thread = await client.thread_start(workspace_path, agent=agent)
         except Exception as exc:
             log_event(
                 self._logger,
@@ -1872,7 +1990,7 @@ class TelegramCommandHandlers(
             )
             return False, "Failed to start a new thread."
         if not await self._require_thread_workspace(
-            message, record.workspace_path, thread, action="thread_start"
+            message, workspace_path, thread, action="thread_start"
         ):
             return False, "Failed to start a new thread."
         new_thread_id = _extract_thread_id(thread)
@@ -1910,7 +2028,7 @@ class TelegramCommandHandlers(
     ) -> None:
         argv = self._parse_command_args(args)
         if argv and argv[0].lower() in ("soft", "summary", "summarize"):
-            record = await self._require_bound_record(message)
+            record = await self._require_bound_record(message, allow_pma=True)
             if not record:
                 return
             await self._handle_normal_message(
@@ -1918,33 +2036,51 @@ class TelegramCommandHandlers(
             )
             return
         auto_apply = bool(argv and argv[0].lower() == "apply")
-        record = await self._require_bound_record(message)
+        record = await self._require_bound_record(message, allow_pma=True)
         if not record:
             return
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
-        if not record.active_thread_id:
-            await self._send_message(
-                message.chat_id,
-                "No active thread to compact. Use /new to start one.",
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        conflict_key = await self._find_thread_conflict(
-            record.active_thread_id, key=key
-        )
-        if conflict_key:
-            await self._router.set_active_thread(
-                message.chat_id, message.thread_id, None
-            )
-            await self._handle_thread_conflict(
-                message, record.active_thread_id, conflict_key
+        pma_enabled = bool(record.pma_enabled)
+        if pma_enabled:
+            registry = getattr(self, "_hub_thread_registry", None)
+            pma_key = self._pma_registry_key(record, message)
+            pma_thread_id = (
+                registry.get_thread_id(pma_key)
+                if registry is not None and pma_key
+                else None
+            )
+            if not pma_thread_id:
+                await self._send_message(
+                    message.chat_id,
+                    "No active PMA thread to compact. Send a message or use /new to start one.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+        else:
+            if not record.active_thread_id:
+                await self._send_message(
+                    message.chat_id,
+                    "No active thread to compact. Use /new to start one.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            conflict_key = await self._find_thread_conflict(
+                record.active_thread_id, key=key
             )
-            return
-        verified = await self._verify_active_thread(message, record)
-        if not verified:
-            return
-        record = verified
+            if conflict_key:
+                await self._router.set_active_thread(
+                    message.chat_id, message.thread_id, None
+                )
+                await self._handle_thread_conflict(
+                    message, record.active_thread_id, conflict_key
+                )
+                return
+            verified = await self._verify_active_thread(message, record)
+            if not verified:
+                return
+            record = verified
         outcome = await self._run_turn_and_collect_result(
             message,
             runtime,
@@ -2066,9 +2202,13 @@ Compact canceled.""",
         )
         self._compact_pending.pop(key, None)
         record = await self._router.get_topic(key)
-        if record is None or not record.workspace_path:
+        if record is None:
             await self._answer_callback(callback, "Selection expired")
             return
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if workspace_path is None:
+            await self._answer_callback(callback, error or "Selection expired")
+            return
         if callback.chat_id is None:
             return
         await self._answer_callback(callback, "Applying summary...")
@@ -2277,7 +2417,7 @@ Summary applied.""",
         repo_ref = (self._update_repo_ref or DEFAULT_UPDATE_REPO_REF).strip()
         if not repo_ref:
             repo_ref = DEFAULT_UPDATE_REPO_REF
-        update_dir = Path.home() / ".codex-autorunner" / "update_cache"
+        update_dir = resolve_update_paths().cache_dir
         notify_reply_to = reply_to
         if notify_reply_to is None and callback is not None:
             notify_reply_to = callback.message_id
@@ -2383,7 +2523,7 @@ Summary applied.""",
         )
 
     def _update_status_path(self) -> Path:
-        return Path.home() / ".codex-autorunner" / "update_status.json"
+        return resolve_update_paths().status_path
 
     def _read_update_status(self) -> Optional[dict[str, Any]]:
         path = self._update_status_path()
@@ -2467,7 +2607,7 @@ Summary applied.""",
             )
 
     def _compact_status_path(self) -> Path:
-        return Path.home() / ".codex-autorunner" / "compact_status.json"
+        return resolve_update_paths().compact_status_path
 
     def _read_compact_status(self) -> Optional[dict[str, Any]]:
         path = self._compact_status_path()
@@ -2633,14 +2773,23 @@ Summary applied.""",
     async def _handle_logout(
         self, message: TelegramMessage, _args: str, _runtime: Any
     ) -> None:
-        record = await self._require_bound_record(message)
+        record = await self._require_bound_record(message, allow_pma=True)
         if not record:
             return
-        client = await self._client_for_workspace(record.workspace_path)
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if workspace_path is None:
+            await self._send_message(
+                message.chat_id,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        client = await self._client_for_workspace(workspace_path)
         if client is None:
             await self._send_message(
                 message.chat_id,
-                "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
                 thread_id=message.thread_id,
                 reply_to=message.message_id,
             )
@@ -2686,14 +2835,23 @@ Summary applied.""",
                 reply_to=message.message_id,
             )
             return
-        record = await self._require_bound_record(message)
+        record = await self._require_bound_record(message, allow_pma=True)
         if not record:
             return
-        client = await self._client_for_workspace(record.workspace_path)
+        workspace_path, error = self._resolve_workspace_path(record, allow_pma=True)
+        if workspace_path is None:
+            await self._send_message(
+                message.chat_id,
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        client = await self._client_for_workspace(workspace_path)
         if client is None:
             await self._send_message(
                 message.chat_id,
-                "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                error or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
                 thread_id=message.thread_id,
                 reply_to=message.message_id,
             )

codex_autorunner/integrations/telegram/handlers/commands_spec.py

@@ -16,6 +16,12 @@ class CommandSpec:
 
 def build_command_specs(handlers: Any) -> dict[str, CommandSpec]:
     return {
+        "repos": CommandSpec(
+            "repos",
+            "list available repositories in the hub",
+            handlers._handle_repos,
+            allow_during_turn=True,
+        ),
         "bind": CommandSpec(
             "bind",
             "bind this topic to a workspace",
@@ -23,9 +29,14 @@ def build_command_specs(handlers: Any) -> dict[str, CommandSpec]:
         ),
         "new": CommandSpec(
             "new",
-            "start a new session",
+            "start a new PMA session",
             lambda message, _args, _runtime: handlers._handle_new(message),
         ),
+        "reset": CommandSpec(
+            "reset",
+            "reset PMA thread state (clear volatile state)",
+            lambda message, _args, _runtime: handlers._handle_reset(message),
+        ),
         "resume": CommandSpec(
             "resume",
             "list or resume a previous session",
@@ -38,13 +49,13 @@ def build_command_specs(handlers: Any) -> dict[str, CommandSpec]:
         ),
         "flow": CommandSpec(
             "flow",
-            "start/resume ticket flow runs",
+            "ticket flow controls (status, runs, bootstrap, resume, stop, archive, reply)",
             lambda message, args, _runtime: handlers._handle_flow(message, args),
             allow_during_turn=True,
         ),
         "reply": CommandSpec(
             "reply",
-            "reply to a paused ticket flow dispatch",
+            "reply to a paused ticket flow dispatch (prefer /flow reply)",
             lambda message, args, _runtime: handlers._handle_reply(message, args),
             allow_during_turn=True,
         ),
@@ -63,6 +74,12 @@ def build_command_specs(handlers: Any) -> dict[str, CommandSpec]:
             "set approval and sandbox policy",
             handlers._handle_approvals,
         ),
+        "pma": CommandSpec(
+            "pma",
+            "toggle PMA mode for this topic",
+            handlers._handle_pma,
+            allow_during_turn=True,
+        ),
         "status": CommandSpec(
             "status",
             "show current binding and thread status",

codex_autorunner/integrations/telegram/handlers/messages.py

@@ -75,6 +75,21 @@ def _message_text_candidate(message: TelegramMessage) -> tuple[str, str, Any]:
     return raw_text, text_candidate, entities
 
 
+def _record_with_media_workspace(
+    handlers: Any, record: Any
+) -> tuple[Any, Optional[str]]:
+    """Ensure media handlers have a workspace path, including PMA topics."""
+    if record is None:
+        return None, None
+    pma_enabled = bool(getattr(record, "pma_enabled", False))
+    if not pma_enabled:
+        return record, None
+    hub_root = getattr(handlers, "_hub_root", None)
+    if hub_root is None:
+        return None, "PMA unavailable; hub root not configured."
+    return dataclasses.replace(record, workspace_path=str(hub_root)), None
+
+
 async def _clear_pending_options(
     handlers: Any, key: str, message: TelegramMessage
 ) -> None:
@@ -263,6 +278,7 @@ async def handle_message_inner(
     if text and text.startswith("!") and not has_media:
         handlers._resume_options.pop(key, None)
         handlers._bind_options.pop(key, None)
+        handlers._flow_run_options.pop(key, None)
         handlers._agent_options.pop(key, None)
         handlers._model_options.pop(key, None)
         handlers._model_pending.pop(key, None)
@@ -351,7 +367,8 @@ async def handle_message_inner(
     record = await handlers._router.get_topic(key)
     paused = None
     workspace_root: Optional[Path] = None
-    if record and record.workspace_path:
+    pma_enabled = bool(record and getattr(record, "pma_enabled", False))
+    if not pma_enabled and record and record.workspace_path:
         workspace_root = canonicalize_path(Path(record.workspace_path))
         preferred_run_id = handlers._ticket_flow_pause_targets.get(
             str(workspace_root), None
@@ -800,6 +817,15 @@ async def handle_media_message(
         return
     key = await handlers._resolve_topic_key(message.chat_id, message.thread_id)
     record = await handlers._router.get_topic(key)
+    record, pma_error = _record_with_media_workspace(handlers, record)
+    if pma_error:
+        await handlers._send_message(
+            message.chat_id,
+            pma_error,
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+        return
     if record is None or not record.workspace_path:
         await handlers._send_message(
             message.chat_id,

codex_autorunner/integrations/telegram/handlers/selections.py

@@ -7,6 +7,8 @@ from ..adapter import (
     AgentCallback,
     CancelCallback,
     EffortCallback,
+    FlowCallback,
+    FlowRunCallback,
     ModelCallback,
     PageCallback,
     ReviewCommitCallback,
@@ -18,6 +20,7 @@ from ..adapter import (
     build_agent_keyboard,
     build_bind_keyboard,
     build_effort_keyboard,
+    build_flow_runs_keyboard,
     build_model_keyboard,
     build_resume_keyboard,
     build_review_commit_keyboard,
@@ -29,6 +32,7 @@ from ..constants import (
     BIND_PICKER_PROMPT,
     DEFAULT_PAGE_SIZE,
     EFFORT_PICKER_PROMPT,
+    FLOW_RUNS_PICKER_PROMPT,
     MODEL_PICKER_PROMPT,
     RESUME_BUTTON_PREVIEW_LIMIT,
     RESUME_PICKER_PROMPT,
@@ -393,6 +397,21 @@ class TelegramSelectionHandlers:
             delivery=state.delivery,
         )
 
+    async def _handle_flow_run_callback(
+        self,
+        key: str,
+        callback: TelegramCallbackQuery,
+        parsed: FlowRunCallback,
+    ) -> None:
+        state = self._flow_run_options.get(key)
+        if not state or not _selection_contains(state.items, parsed.run_id):
+            await self._answer_callback(callback, "Selection expired")
+            return
+        self._flow_run_options.pop(key, None)
+        await self._handle_flow_callback(
+            callback, FlowCallback(action="status", run_id=parsed.run_id)
+        )
+
     def _selection_prompt(self, base: str, state: SelectionState) -> str:
         total_pages = _page_count(len(state.items), DEFAULT_PAGE_SIZE)
         return _format_selection_prompt(base, state.page, total_pages)
@@ -486,6 +505,37 @@ class TelegramSelectionHandlers:
             include_cancel=True,
         )
 
+    def _build_flow_runs_keyboard(self, state: SelectionState) -> dict[str, Any]:
+        page_items = _page_slice(state.items, state.page, DEFAULT_PAGE_SIZE)
+        options = []
+        for idx, (item_id, label) in enumerate(page_items, 1):
+            button_label = label
+            if state.button_labels:
+                button_label = state.button_labels.get(item_id, label)
+            options.append(
+                (
+                    item_id,
+                    f"{idx}) {_compact_preview(button_label, RESUME_BUTTON_PREVIEW_LIMIT)}",
+                )
+            )
+        return build_flow_runs_keyboard(
+            options,
+            page_button=self._page_button("flow-runs", state),
+            include_cancel=True,
+        )
+
+    def _flow_runs_prompt(self, state: SelectionState) -> str:
+        total_pages = _page_count(len(state.items), DEFAULT_PAGE_SIZE)
+        page_items = _page_slice(state.items, state.page, DEFAULT_PAGE_SIZE)
+        lines = [FLOW_RUNS_PICKER_PROMPT]
+        for run_id, label in page_items:
+            if label:
+                lines.append(f"- {run_id} — {label}")
+            else:
+                lines.append(f"- {run_id}")
+        base = "\n".join(lines)
+        return _format_selection_prompt(base, state.page, total_pages)
+
     def _build_effort_keyboard(self, option: ModelOption) -> dict[str, Any]:
         options = []
         for effort in option.efforts:
@@ -566,6 +616,9 @@ class TelegramSelectionHandlers:
         elif parsed.kind == "review-custom":
             self._pending_review_custom.pop(key, None)
             text = "Custom review cancelled."
+        elif parsed.kind == "flow-runs":
+            self._flow_run_options.pop(key, None)
+            text = "Flow run selection cancelled."
         else:
             await self._answer_callback(callback, "Selection expired")
             return
@@ -605,6 +658,10 @@ class TelegramSelectionHandlers:
                 Callable[[SelectionState], dict[str, Any]],
                 self._build_review_commit_keyboard,
             )
+        elif parsed.kind == "flow-runs":
+            state = self._flow_run_options.get(key)
+            prompt_base = ""
+            build_keyboard = self._build_flow_runs_keyboard
         else:
             await self._answer_callback(callback, "Selection expired")
             return
@@ -617,7 +674,10 @@ class TelegramSelectionHandlers:
             return
         page = parsed.page % total_pages
         state.page = page
-        prompt = _format_selection_prompt(prompt_base, page, total_pages)
+        if parsed.kind == "flow-runs":
+            prompt = self._flow_runs_prompt(state)
+        else:
+            prompt = _format_selection_prompt(prompt_base, page, total_pages)
         keyboard = build_keyboard(state)
         await self._update_selection_message(key, callback, prompt, keyboard)
         await self._answer_callback(callback, f"Page {page + 1}/{total_pages}")