codex-autorunner 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

codex_autorunner/integrations/telegram/handlers/commands/workspace.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
+import dataclasses
 import logging
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional, Sequence
 
 from .....agents.opencode.runtime import extract_session_id
+from .....core.app_server_threads import PMA_KEY, PMA_OPENCODE_KEY
+from .....core.flows import FlowStore
+from .....core.flows.models import FlowRunStatus
 from .....core.logging_utils import log_event
 from .....core.state import now_iso
 from .....core.utils import canonicalize_path, resolve_opencode_binary
@@ -108,6 +112,32 @@ class ResumeThreadData:
 
 
 class WorkspaceCommands(SharedHelpers):
+    def _resolve_workspace_path(
+        self,
+        record: Optional["TelegramTopicRecord"],
+        *,
+        allow_pma: bool = False,
+    ) -> tuple[Optional[str], Optional[str]]:
+        if record and record.workspace_path:
+            return record.workspace_path, None
+        if allow_pma and record and record.pma_enabled:
+            hub_root = getattr(self, "_hub_root", None)
+            if hub_root is None:
+                return None, "PMA unavailable; hub root not configured."
+            return str(hub_root), None
+        return None, "Topic not bound. Use /bind <repo_id> or /bind <path>."
+
+    def _record_with_workspace_path(
+        self,
+        record: Optional["TelegramTopicRecord"],
+        workspace_path: Optional[str],
+    ) -> Optional["TelegramTopicRecord"]:
+        if record is None or not workspace_path:
+            return record
+        if record.workspace_path == workspace_path:
+            return record
+        return dataclasses.replace(record, workspace_path=workspace_path)
+
     async def _apply_agent_change(
         self,
         chat_id: int,
@@ -165,8 +195,17 @@ class WorkspaceCommands(SharedHelpers):
             )
             return
         desired = normalize_agent(argv[0])
+        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(record.workspace_path)
+            client = await self._client_for_workspace(workspace_path)
         except AppServerUnavailableError as exc:
             log_event(
                 self._logger,
@@ -186,7 +225,7 @@ class WorkspaceCommands(SharedHelpers):
         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,
             )
@@ -532,11 +571,37 @@ class WorkspaceCommands(SharedHelpers):
         return await self._router.update_topic(chat_id, thread_id, apply)
 
     async def _require_bound_record(
-        self, message: TelegramMessage, *, prompt: Optional[str] = None
+        self,
+        message: TelegramMessage,
+        *,
+        prompt: Optional[str] = None,
+        allow_pma: bool = False,
     ) -> Optional["TelegramTopicRecord"]:
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
         record = await self._router.get_topic(key)
-        if record is None or not record.workspace_path:
+        if record is None:
+            await self._send_message(
+                message.chat_id,
+                prompt or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return None
+        if record.workspace_path:
+            await self._refresh_workspace_id(key, record)
+            return record
+        if allow_pma and record.pma_enabled:
+            hub_root = getattr(self, "_hub_root", None)
+            if hub_root is None:
+                await self._send_message(
+                    message.chat_id,
+                    "PMA unavailable; hub root not configured.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return None
+            return record
+        if not record.workspace_path:
             await self._send_message(
                 message.chat_id,
                 prompt or "Topic not bound. Use /bind <repo_id> or /bind <path>.",
@@ -544,7 +609,6 @@ class WorkspaceCommands(SharedHelpers):
                 reply_to=message.message_id,
             )
             return None
-        await self._refresh_workspace_id(key, record)
         return record
 
     async def _ensure_thread_id(
@@ -777,6 +841,45 @@ class WorkspaceCommands(SharedHelpers):
             return False
         return True
 
+    async def _handle_repos(
+        self, message: TelegramMessage, _args: str, _runtime: Any
+    ) -> None:
+        if not self._manifest_path or not self._hub_root:
+            await self._send_message(
+                message.chat_id,
+                "Hub manifest not configured.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        try:
+            manifest = load_manifest(self._manifest_path, self._hub_root)
+        except Exception as exc:
+            await self._send_message(
+                message.chat_id,
+                f"Failed to load manifest: {exc}",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        lines = ["Repositories:"]
+        for repo in manifest.repos:
+            if not repo.enabled:
+                continue
+            lines.append(f"- `{repo.id}` ({repo.path})")
+
+        lines.append("\nUse /bind <repo_id> to switch context.")
+
+        await self._send_message(
+            message.chat_id,
+            "\n".join(lines),
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+            parse_mode="Markdown",
+        )
+
     async def _handle_bind(self, message: TelegramMessage, args: str) -> None:
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
         if not args:
@@ -828,13 +931,19 @@ class WorkspaceCommands(SharedHelpers):
             scope=scope,
         )
         workspace_id = self._workspace_id_for_path(workspace_path)
-        if workspace_id:
-            await self._router.update_topic(
-                chat_id,
-                thread_id,
-                lambda record: setattr(record, "workspace_id", workspace_id),
-                scope=scope,
-            )
+
+        def apply_bind_updates(record: TelegramTopicRecord) -> None:
+            if workspace_id:
+                record.workspace_id = workspace_id
+            # Mutual exclusion: Binding to a repo disables PMA mode.
+            record.pma_enabled = False
+
+        await self._router.update_topic(
+            chat_id,
+            thread_id,
+            apply_bind_updates,
+            scope=scope,
+        )
         await self._answer_callback(callback, "Bound to repo")
         await self._finalize_selection(
             key,
@@ -866,16 +975,173 @@ class WorkspaceCommands(SharedHelpers):
             scope=scope,
         )
         workspace_id = self._workspace_id_for_path(workspace_path)
-        if workspace_id:
-            await self._router.update_topic(
+
+        def apply_bind_updates(record: TelegramTopicRecord) -> None:
+            if workspace_id:
+                record.workspace_id = workspace_id
+            # Mutual exclusion: Binding to a repo disables PMA mode.
+            record.pma_enabled = False
+
+        await self._router.update_topic(
+            message.chat_id,
+            message.thread_id,
+            apply_bind_updates,
+            scope=scope,
+        )
+        await self._send_message(
+            message.chat_id,
+            f"Bound to {repo_id or workspace_path}.",
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+
+    async def _handle_reset(self, message: TelegramMessage) -> None:
+        key = await self._resolve_topic_key(message.chat_id, message.thread_id)
+        record = await self._router.get_topic(key)
+        pma_enabled = bool(record and record.pma_enabled)
+        if pma_enabled:
+            registry = getattr(self, "_hub_thread_registry", None)
+            agent = self._effective_agent(record)
+            pma_key = PMA_OPENCODE_KEY if agent == "opencode" else PMA_KEY
+            if registry:
+                registry.reset_thread(pma_key)
+            await self._send_message(
                 message.chat_id,
-                message.thread_id,
-                lambda record: setattr(record, "workspace_id", workspace_id),
-                scope=scope,
+                "PMA thread reset. Send a message to start a fresh PMA turn.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
             )
+            return
+        if record is None or not record.workspace_path:
+            await self._send_message(
+                message.chat_id,
+                "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        agent = self._effective_agent(record)
+        if agent == "opencode":
+            supervisor = getattr(self, "_opencode_supervisor", None)
+            if supervisor is None:
+                await self._send_message(
+                    message.chat_id,
+                    "OpenCode backend unavailable; install opencode or switch to /agent codex.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            workspace_root = self._canonical_workspace_root(record.workspace_path)
+            if workspace_root is None:
+                await self._send_message(
+                    message.chat_id,
+                    "Workspace unavailable.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            try:
+                client = await supervisor.get_client(workspace_root)
+                session = await client.create_session(directory=str(workspace_root))
+            except Exception as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.opencode.session.failed",
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                    exc=exc,
+                )
+                await self._send_message(
+                    message.chat_id,
+                    "Failed to reset OpenCode thread.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            session_id = extract_session_id(session, allow_fallback_id=True)
+            if not session_id:
+                await self._send_message(
+                    message.chat_id,
+                    "Failed to reset OpenCode thread.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+
+            def apply(record: "TelegramTopicRecord") -> None:
+                record.active_thread_id = session_id
+                if session_id in record.thread_ids:
+                    record.thread_ids.remove(session_id)
+                record.thread_ids.insert(0, session_id)
+                if len(record.thread_ids) > MAX_TOPIC_THREAD_HISTORY:
+                    record.thread_ids = record.thread_ids[:MAX_TOPIC_THREAD_HISTORY]
+                _set_thread_summary(
+                    record,
+                    session_id,
+                    last_used_at=now_iso(),
+                    workspace_path=record.workspace_path,
+                    rollout_path=record.rollout_path,
+                )
+
+            await self._router.update_topic(message.chat_id, message.thread_id, apply)
+            thread_id = session_id
+        else:
+            try:
+                client = await self._client_for_workspace(record.workspace_path)
+            except AppServerUnavailableError as exc:
+                log_event(
+                    self._logger,
+                    logging.WARNING,
+                    "telegram.app_server.unavailable",
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                    exc=exc,
+                )
+                await self._send_message(
+                    message.chat_id,
+                    "App server unavailable; try again or check logs.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            if client is None:
+                await self._send_message(
+                    message.chat_id,
+                    "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            thread = await client.thread_start(record.workspace_path, agent=agent)
+            if not await self._require_thread_workspace(
+                message, record.workspace_path, thread, action="thread_start"
+            ):
+                return
+            thread_id = _extract_thread_id(thread)
+            if not thread_id:
+                await self._send_message(
+                    message.chat_id,
+                    "Failed to reset thread.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            await self._apply_thread_result(
+                message.chat_id, message.thread_id, thread, active_thread_id=thread_id
+            )
+        effort_label = (
+            record.effort or "default" if self._agent_supports_effort(agent) else "n/a"
+        )
         await self._send_message(
             message.chat_id,
-            f"Bound to {repo_id or workspace_path}.",
+            "\n".join(
+                [
+                    f"Reset thread {thread_id}.",
+                    f"Agent: {agent}",
+                    f"Effort: {effort_label}",
+                ]
+            ),
             thread_id=message.thread_id,
             reply_to=message.message_id,
         )
@@ -883,6 +1149,20 @@ class WorkspaceCommands(SharedHelpers):
     async def _handle_new(self, message: TelegramMessage) -> None:
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
         record = await self._router.get_topic(key)
+        pma_enabled = bool(record and record.pma_enabled)
+        if pma_enabled:
+            registry = getattr(self, "_hub_thread_registry", None)
+            agent = self._effective_agent(record)
+            pma_key = PMA_OPENCODE_KEY if agent == "opencode" else PMA_KEY
+            if registry:
+                registry.reset_thread(pma_key)
+            await self._send_message(
+                message.chat_id,
+                "PMA session reset. Send a message to start a fresh PMA turn.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
         if record is None or not record.workspace_path:
             await self._send_message(
                 message.chat_id,
@@ -1128,9 +1408,16 @@ class WorkspaceCommands(SharedHelpers):
         if await self._handle_resume_shortcuts(key, message, parsed_args):
             return
         record = await self._router.get_topic(key)
-        record = await self._ensure_resume_record(message, record)
+        record = await self._ensure_resume_record(message, record, allow_pma=True)
         if record is None:
             return
+        if record.pma_enabled and not parsed_args.show_unscoped:
+            parsed_args = ResumeCommandArgs(
+                trimmed=parsed_args.trimmed,
+                remaining=parsed_args.remaining,
+                show_unscoped=True,
+                refresh=parsed_args.refresh,
+            )
         if self._effective_agent(record) == "opencode":
             await self._handle_opencode_resume(
                 message,
@@ -1208,10 +1495,14 @@ class WorkspaceCommands(SharedHelpers):
         return False
 
     async def _ensure_resume_record(
-        self, message: TelegramMessage, record: Optional["TelegramTopicRecord"]
+        self,
+        message: TelegramMessage,
+        record: Optional["TelegramTopicRecord"],
+        *,
+        allow_pma: bool = False,
     ) -> Optional["TelegramTopicRecord"]:
         """Validate resume preconditions and return the topic record."""
-        if record is None or not record.workspace_path:
+        if record is None:
             await self._send_message(
                 message.chat_id,
                 "Topic not bound. Use /bind <repo_id> or /bind <path>.",
@@ -1219,6 +1510,28 @@ class WorkspaceCommands(SharedHelpers):
                 reply_to=message.message_id,
             )
             return None
+        if not record.workspace_path:
+            if allow_pma and record.pma_enabled:
+                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 "PMA unavailable; hub root not configured.",
+                        thread_id=message.thread_id,
+                        reply_to=message.message_id,
+                    )
+                    return None
+                record = self._record_with_workspace_path(record, workspace_path)
+            else:
+                await self._send_message(
+                    message.chat_id,
+                    "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return None
         agent = self._effective_agent(record)
         if not self._agent_supports_resume(agent):
             await self._send_message(
@@ -1234,8 +1547,17 @@ class WorkspaceCommands(SharedHelpers):
         self, message: TelegramMessage, record: "TelegramTopicRecord"
     ) -> Optional[CodexAppServerClient]:
         """Resolve the app server client for the topic workspace."""
+        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 None
         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,
@@ -1255,7 +1577,7 @@ class WorkspaceCommands(SharedHelpers):
         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,
             )
@@ -1999,22 +2321,33 @@ class WorkspaceCommands(SharedHelpers):
             runtime = self._router.runtime_for(key)
         approval_policy, sandbox_policy = self._effective_policies(record)
         agent = self._effective_agent(record)
+        is_pma = bool(getattr(record, "pma_enabled", False))
+        workspace_label = record.workspace_path or ("hub" if is_pma else "unbound")
         effort_label = (
             record.effort or "default" if self._agent_supports_effort(agent) else "n/a"
         )
-        lines = [
-            f"Workspace: {record.workspace_path or 'unbound'}",
-            f"Workspace ID: {record.workspace_id or 'unknown'}",
-            f"Active thread: {record.active_thread_id or 'none'}",
-            f"Active turn: {runtime.current_turn_id or 'none'}",
-            f"Agent: {agent}",
-            f"Resume: {'supported' if self._agent_supports_resume(agent) else 'unsupported'}",
-            f"Model: {record.model or 'default'}",
-            f"Effort: {effort_label}",
-            f"Approval mode: {record.approval_mode}",
-            f"Approval policy: {approval_policy or 'default'}",
-            f"Sandbox policy: {_format_sandbox_policy(sandbox_policy)}",
-        ]
+        lines = []
+        if is_pma:
+            lines.append("Mode: PMA (hub)")
+            # Show previous binding if available
+            if record.pma_prev_workspace_path:
+                lines.append(f"Previous binding: {record.pma_prev_workspace_path}")
+                lines.append("Use /pma off to restore previous binding.")
+        lines.extend(
+            [
+                f"Workspace: {workspace_label}",
+                f"Workspace ID: {record.workspace_id or 'unknown'}",
+                f"Active thread: {record.active_thread_id or 'none'}",
+                f"Active turn: {runtime.current_turn_id or 'none'}",
+                f"Agent: {agent}",
+                f"Resume: {'supported' if self._agent_supports_resume(agent) else 'unsupported'}",
+                f"Model: {record.model or 'default'}",
+                f"Effort: {effort_label}",
+                f"Approval mode: {record.approval_mode}",
+                f"Approval policy: {approval_policy or 'default'}",
+                f"Sandbox policy: {_format_sandbox_policy(sandbox_policy)}",
+            ]
+        )
         pending = await self._store.pending_approvals_for_key(key)
         if pending:
             lines.append(f"Pending approvals: {len(pending)}")
@@ -2033,8 +2366,136 @@ class WorkspaceCommands(SharedHelpers):
             lines.extend(_format_token_usage(token_usage))
         rate_limits = await self._read_rate_limits(record.workspace_path, agent=agent)
         lines.extend(_format_rate_limits(rate_limits))
-        if not record.workspace_path:
+
+        manifest_path = getattr(self, "_manifest_path", None)
+        hub_root = getattr(self, "_hub_root", None)
+        if is_pma:
+            if hub_root:
+                lines.append(f"Hub root: {hub_root}")
+            if manifest_path:
+                lines.append(f"Manifest: {manifest_path}")
+            registry = getattr(self, "_hub_thread_registry", None)
+            if registry and hasattr(self, "_pma_registry_key"):
+                try:
+                    pma_key = self._pma_registry_key(record, message)
+                    pma_thread_id = registry.get_thread_id(pma_key) if pma_key else None
+                    # Show thread scoping
+                    require_topics = getattr(self._config, "require_topics", False)
+                    scoping = "per-topic" if require_topics else "global (per hub)"
+                    lines.append(f"PMA thread: {pma_thread_id or 'none'} ({scoping})")
+                except Exception:
+                    pass
+            if hub_root:
+                try:
+                    pma_dir = hub_root / ".codex-autorunner" / "pma"
+                    inbox_dir = pma_dir / "inbox"
+                    outbox_dir = pma_dir / "outbox"
+                    inbox_count = (
+                        len(
+                            [
+                                path
+                                for path in inbox_dir.iterdir()
+                                if path.is_file() and not path.name.startswith(".")
+                            ]
+                        )
+                        if inbox_dir.exists()
+                        else 0
+                    )
+                    outbox_count = (
+                        len(
+                            [
+                                path
+                                for path in outbox_dir.iterdir()
+                                if path.is_file() and not path.name.startswith(".")
+                            ]
+                        )
+                        if outbox_dir.exists()
+                        else 0
+                    )
+                    lines.append(
+                        f"PMA files: inbox {inbox_count}, outbox {outbox_count}"
+                    )
+                except Exception:
+                    pass
+        if is_pma and manifest_path and hub_root:
+            try:
+                manifest = load_manifest(manifest_path, hub_root)
+                enabled_repos = [repo for repo in manifest.repos if repo.enabled]
+                lines.append(
+                    f"Hub repos: {len(enabled_repos)}/{len(manifest.repos)} enabled"
+                )
+                active_count = 0
+                paused_count = 0
+                idle_count = 0
+                active_repos: list[str] = []
+                paused_repos: list[str] = []
+                for repo in manifest.repos:
+                    if not repo.enabled:
+                        continue
+                    repo_root = (hub_root / repo.path).resolve()
+                    db_path = repo_root / ".codex-autorunner" / "flows.db"
+                    if not db_path.exists():
+                        idle_count += 1
+                        continue
+
+                    store = FlowStore(db_path)
+                    try:
+                        store.initialize()
+                        runs = store.list_flow_runs(flow_type="ticket_flow")
+                        if runs:
+                            latest = runs[0]
+                            if latest.status.is_active():
+                                active_count += 1
+                                active_repos.append(repo.id)
+                            elif latest.status == FlowRunStatus.PAUSED:
+                                paused_count += 1
+                                paused_repos.append(repo.id)
+                            else:
+                                idle_count += 1
+                        else:
+                            idle_count += 1
+                    except Exception:
+                        pass
+                    finally:
+                        store.close()
+                lines.append(
+                    f"Hub flows: {active_count} active, {paused_count} paused, {idle_count} idle"
+                )
+                if active_repos:
+                    preview = ", ".join(active_repos[:5])
+                    suffix = "" if len(active_repos) <= 5 else "..."
+                    lines.append(f"Active repos: {preview}{suffix}")
+                if paused_repos:
+                    preview = ", ".join(paused_repos[:5])
+                    suffix = "" if len(paused_repos) <= 5 else "..."
+                    lines.append(f"Paused repos: {preview}{suffix}")
+            except Exception:
+                pass
+
+        if not record.workspace_path and not is_pma:
             lines.append("Use /bind <repo_id> or /bind <path>.")
+
+        if record.workspace_path and not is_pma:
+            repo_root = Path(record.workspace_path)
+            db_path = repo_root / ".codex-autorunner" / "flows.db"
+            if db_path.exists():
+                store = FlowStore(db_path)
+                try:
+                    store.initialize()
+                    runs = store.list_flow_runs(flow_type="ticket_flow")
+                    if runs:
+                        latest = runs[0]
+                        if latest.status.is_active():
+                            lines.append(
+                                f"Active Flow: {latest.status.value} (run {latest.id})"
+                            )
+                        elif latest.status == FlowRunStatus.PAUSED:
+                            lines.append(f"Active Flow: PAUSED (run {latest.id})")
+                except Exception:
+                    pass
+                finally:
+                    store.close()
+
         await self._send_message(
             message.chat_id,
             "\n".join(lines),