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

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

@@ -9,8 +9,7 @@ from pathlib import Path
 from typing import Callable, Optional
 
 from .....agents.registry import validate_agent_id
-from .....core.config import load_repo_config
-from .....core.engine import Engine
+from .....core.config import load_hub_config, load_repo_config
 from .....core.flows import FlowController, FlowStore
 from .....core.flows.models import FlowRunStatus
 from .....core.flows.reconciler import reconcile_flow_run
@@ -22,19 +21,24 @@ from .....core.flows.ux_helpers import (
     issue_md_path,
     seed_issue_from_github,
     seed_issue_from_text,
+    ticket_progress,
 )
 from .....core.flows.worker_process import (
     FlowWorkerHealth,
     check_worker_health,
     clear_worker_metadata,
 )
+from .....core.logging_utils import log_event
+from .....core.runtime import RuntimeContext
 from .....core.state import now_iso
 from .....core.utils import atomic_write, canonicalize_path
 from .....flows.ticket_flow import build_ticket_flow_definition
+from .....integrations.agents import build_backend_orchestrator
 from .....integrations.agents.wiring import (
     build_agent_backend_factory,
     build_app_server_supervisor_factory,
 )
+from .....manifest import load_manifest
 from .....tickets import AgentPool
 from .....tickets.files import list_ticket_paths
 from .....tickets.outbox import resolve_outbox_paths
@@ -67,6 +71,11 @@ def _ticket_dir(repo_root: Path) -> Path:
     return repo_root.resolve() / ".codex-autorunner" / "tickets"
 
 
+def _load_flow_store(repo_root: Path, hub_root: Optional[Path] = None) -> FlowStore:
+    config = load_repo_config(repo_root, hub_root)
+    return FlowStore(_flow_paths(repo_root)[0], durable=config.durable_writes)
+
+
 def _normalize_run_id(value: str) -> Optional[str]:
     try:
         return str(uuid.UUID(str(value)))
@@ -107,16 +116,70 @@ def _flow_help_lines() -> list[str]:
         "/flow restart",
         "/flow archive [run_id] [--force]",
         "/flow reply <message>",
-        "Aliases: /flow start, /flow_status",
+        "Alias: /flow start",
     ]
 
 
+def _discover_unregistered_worktrees(
+    manifest, hub_root: Optional[Path]
+) -> list[dict[str, object]]:
+    if not hub_root:
+        return []
+    try:
+        hub_config = load_hub_config(hub_root)
+    except Exception:
+        return []
+    worktrees_root = hub_config.worktrees_root
+    if not worktrees_root.exists() or not worktrees_root.is_dir():
+        return []
+
+    known_paths = {(hub_root / repo.path).resolve() for repo in manifest.repos}
+    known_ids = {repo.id for repo in manifest.repos}
+    extras: list[dict[str, object]] = []
+    for child in sorted(worktrees_root.iterdir()):
+        if not child.is_dir():
+            continue
+        if not (child / ".git").exists():
+            continue
+        resolved = child.resolve()
+        if resolved in known_paths:
+            continue
+
+        flows_root = child / ".codex-autorunner" / "flows"
+        flows_db = child / ".codex-autorunner" / "flows.db"
+        if not flows_root.exists() and not flows_db.exists():
+            continue
+
+        repo_id = child.name
+        label = repo_id
+        indent = ""
+        if "--" in repo_id:
+            _, suffix = repo_id.split("--", 1)
+            label = suffix or repo_id
+            indent = "  - "
+        label = f"{label} (unregistered)"
+        if repo_id in known_ids:
+            label = f"{label} (duplicate id)"
+        extras.append(
+            {
+                "repo_id": repo_id,
+                "repo_root": resolved,
+                "label": label,
+                "indent": indent,
+                "unregistered": True,
+            }
+        )
+    return extras
+
+
 def _get_ticket_controller(repo_root: Path) -> FlowController:
     db_path, artifacts_root = _flow_paths(repo_root)
     config = load_repo_config(repo_root)
-    engine = Engine(
+    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,
@@ -251,61 +314,123 @@ class FlowCommands(SharedHelpers):
 
     async def _handle_flow(self, message: TelegramMessage, args: str) -> None:
         argv = self._parse_command_args(args)
+
+        target_repo_root = None
+        effective_args = args
+
+        if argv:
+            resolved = self._resolve_workspace(argv[0])
+            if resolved:
+                target_repo_root = Path(resolved[0])
+                argv = argv[1:]
+                # Reconstruct args for remainder logic (imperfect but sufficient for text commands)
+                effective_args = " ".join(argv)
+
         action_raw = argv[0] if argv else ""
+        if target_repo_root and not action_raw:
+            action_raw = "status"
+            argv = ["status"]
+            effective_args = "status"
         action = _normalize_flow_action(action_raw)
-        _, remainder = _split_flow_action(args)
+        _, remainder = _split_flow_action(effective_args)
         rest_argv = argv[1:]
 
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
         record = await self._store.get_topic(key)
+        is_pma = bool(record and getattr(record, "pma_enabled", False))
+        is_unbound = bool(not record or not getattr(record, "workspace_path", None))
+
+        if not target_repo_root and not action_raw:
+            # Check if we should show Hub Overview
+            if is_pma or is_unbound:
+                await self._send_flow_hub_overview(message)
+                return
+            action = "status"
+            rest_argv = []
 
         if action == "help":
             await self._send_flow_overview(message, record)
             return
 
-        if not record or not record.workspace_path:
+        if target_repo_root:
+            repo_root = canonicalize_path(target_repo_root)
+        elif record and record.workspace_path:
+            repo_root = canonicalize_path(Path(record.workspace_path))
+        else:
+            if action == "status" and (is_pma or is_unbound):
+                await self._send_flow_hub_overview(message)
+                return
             await self._send_message(
                 message.chat_id,
-                "No workspace bound. Use /bind to bind this topic to a repo first.",
+                "No workspace bound. Use /flow <repo-id> status to inspect a repo without binding, or /bind <repo-id> to attach this topic.",
                 thread_id=message.thread_id,
                 reply_to=message.message_id,
             )
             return
 
-        repo_root = canonicalize_path(Path(record.workspace_path))
-
-        if action == "status":
-            await self._handle_flow_status_action(message, repo_root, rest_argv)
-            return
-        if action == "runs":
-            await self._handle_flow_runs(message, repo_root, rest_argv)
-            return
-        if action == "bootstrap":
-            await self._handle_flow_bootstrap(message, repo_root, rest_argv)
-            return
-        if action == "issue":
-            await self._handle_flow_issue(message, repo_root, remainder)
-            return
-        if action == "plan":
-            await self._handle_flow_plan(message, repo_root, remainder)
-            return
-        if action == "resume":
-            await self._handle_flow_resume(message, repo_root, rest_argv)
-            return
-        if action == "stop":
-            await self._handle_flow_stop(message, repo_root, rest_argv)
-            return
-        if action == "recover":
-            await self._handle_flow_recover(message, repo_root, rest_argv)
-            return
-        if action == "restart":
-            await self._handle_flow_restart(message, repo_root, rest_argv)
-            return
-        if action == "archive":
-            await self._handle_flow_archive(message, repo_root, rest_argv)
-            return
-        if action == "reply":
-            await self._handle_reply(message, remainder)
+        try:
+            if action == "status":
+                await self._handle_flow_status_action(message, repo_root, rest_argv)
+                return
+            if action == "runs":
+                await self._handle_flow_runs(message, repo_root, rest_argv)
+                return
+            if action == "bootstrap":
+                await self._handle_flow_bootstrap(message, repo_root, rest_argv)
+                return
+            if action == "issue":
+                await self._handle_flow_issue(message, repo_root, remainder)
+                return
+            if action == "plan":
+                await self._handle_flow_plan(message, repo_root, remainder)
+                return
+            if action == "resume":
+                await self._handle_flow_resume(message, repo_root, rest_argv)
+                return
+            if action == "stop":
+                await self._handle_flow_stop(message, repo_root, rest_argv)
+                return
+            if action == "recover":
+                await self._handle_flow_recover(message, repo_root, rest_argv)
+                return
+            if action == "restart":
+                await self._handle_flow_restart(message, repo_root, rest_argv)
+                return
+            if action == "archive":
+                await self._handle_flow_archive(message, repo_root, rest_argv)
+                return
+            if action == "reply":
+                await self._handle_reply(message, remainder)
+                return
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            # Let cancellations propagate so shutdowns/timeouts are not masked.
+            raise
+        except Exception as exc:  # pragma: no cover - defensive
+            log_event(
+                _logger,
+                logging.WARNING,
+                "telegram.flow.command_failed",
+                chat_id=message.chat_id,
+                thread_id=message.thread_id,
+                action=action or "unknown",
+                exc=exc,
+            )
+            format_msg = getattr(self, "_with_conversation_id", None)
+            error_text = (
+                format_msg(
+                    "Flow command failed; check logs for details.",
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                )
+                if callable(format_msg)
+                else "Flow command failed; check logs for details."
+            )
+            await self._send_message(
+                message.chat_id,
+                error_text,
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
             return
 
         await self._send_message(
@@ -323,7 +448,7 @@ class FlowCommands(SharedHelpers):
         repo_root: Path,
         run_id_raw: Optional[str],
     ) -> None:
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         try:
             store.initialize()
             record, error = self._resolve_status_record(store, run_id_raw)
@@ -365,7 +490,7 @@ class FlowCommands(SharedHelpers):
         error = None
         notice = None
         if action == "resume":
-            store = FlowStore(_flow_paths(repo_root)[0])
+            store = _load_flow_store(repo_root)
             try:
                 store.initialize()
                 run_id, error = self._resolve_run_id_input(store, run_id_raw)
@@ -388,7 +513,7 @@ class FlowCommands(SharedHelpers):
                 _spawn_flow_worker(repo_root, updated.id)
                 notice = "Resumed."
         elif action == "stop":
-            store = FlowStore(_flow_paths(repo_root)[0])
+            store = _load_flow_store(repo_root)
             try:
                 store.initialize()
                 run_id, error = self._resolve_run_id_input(store, run_id_raw)
@@ -411,7 +536,7 @@ class FlowCommands(SharedHelpers):
                 await controller.stop_flow(record.id)
                 notice = "Stopped."
         elif action == "recover":
-            store = FlowStore(_flow_paths(repo_root)[0])
+            store = _load_flow_store(repo_root)
             try:
                 store.initialize()
                 run_id, error = self._resolve_run_id_input(store, run_id_raw)
@@ -435,7 +560,7 @@ class FlowCommands(SharedHelpers):
             finally:
                 store.close()
         elif action == "archive":
-            store = FlowStore(_flow_paths(repo_root)[0])
+            store = _load_flow_store(repo_root)
             record = None
             try:
                 store.initialize()
@@ -479,7 +604,7 @@ class FlowCommands(SharedHelpers):
                     archived_runs_dir = artifacts_root / record.id / "archived_runs"
                     shutil.move(str(run_dir), str(archived_runs_dir))
 
-                store = FlowStore(_flow_paths(repo_root)[0])
+                store = _load_flow_store(repo_root)
                 try:
                     store.initialize()
                     store.delete_flow_run(record.id)
@@ -569,7 +694,16 @@ class FlowCommands(SharedHelpers):
         run = record
         status = getattr(run, "status", None)
         status_value = status.value if status else "unknown"
+        progress = snapshot.get("ticket_progress") if snapshot else None
+        progress_label = None
+        if isinstance(progress, dict):
+            done = progress.get("done")
+            total = progress.get("total")
+            if isinstance(done, int) and isinstance(total, int) and total >= 0:
+                progress_label = f"{done}/{total}"
         lines = [f"Run: {run.id}", f"Status: {status_value}"]
+        if progress_label:
+            lines.append(f"Tickets: {progress_label}")
         flow_type = getattr(run, "flow_type", None)
         if flow_type:
             lines.append(f"Flow: {flow_type}")
@@ -721,7 +855,7 @@ class FlowCommands(SharedHelpers):
             f"Workspace: {repo_root}" if repo_root else "Workspace: unbound",
         ]
         if repo_root:
-            store = FlowStore(_flow_paths(repo_root)[0])
+            store = _load_flow_store(repo_root)
             try:
                 store.initialize()
                 runs = store.list_flow_runs(flow_type="ticket_flow")
@@ -741,10 +875,164 @@ class FlowCommands(SharedHelpers):
             reply_to=message.message_id,
         )
 
+    async def _send_flow_hub_overview(self, message: TelegramMessage) -> 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:
+            await self._send_message(
+                message.chat_id,
+                "Failed to load manifest.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        def _group_key(repo_id: str) -> tuple[str, Optional[str]]:
+            parts = repo_id.split("--", 1)
+            if len(parts) == 1:
+                return repo_id, None
+            return parts[0], parts[1]
+
+        def _format_status_line(
+            label: str,
+            *,
+            status_icon: str,
+            status_value: str,
+            progress_label: str,
+            run_id: Optional[str],
+            indent: str = "",
+        ) -> str:
+            run_suffix = f" run {run_id}" if run_id else ""
+            return f"{indent}{status_icon} {label}: {status_value} {progress_label}{run_suffix}"
+
+        lines = ["Hub Flow Overview:"]
+        groups: dict[str, list[tuple[str, str]]] = {}
+        group_order: list[str] = []
+
+        entries: list[dict[str, object]] = []
+        for repo in manifest.repos:
+            if not repo.enabled:
+                continue
+            repo_root = (self._hub_root / repo.path).resolve()
+            group, suffix = _group_key(repo.id)
+            label = suffix or repo.id
+            indent = "  - " if suffix else ""
+            entries.append(
+                {
+                    "repo_id": repo.id,
+                    "repo_root": repo_root,
+                    "label": label,
+                    "indent": indent,
+                    "group": group,
+                    "unregistered": False,
+                }
+            )
+
+        extras = _discover_unregistered_worktrees(manifest, self._hub_root)
+        for extra in extras:
+            repo_id = str(extra["repo_id"])
+            group, _ = _group_key(repo_id)
+            extra["group"] = group
+            entries.append(extra)
+
+        for entry in entries:
+            repo_id = str(entry["repo_id"])
+            repo_root = Path(entry["repo_root"])
+            label = str(entry["label"])
+            indent = str(entry.get("indent", ""))
+            group = str(entry.get("group", repo_id))
+            if group not in groups:
+                groups[group] = []
+                group_order.append(group)
+
+            store = _load_flow_store(repo_root)
+            try:
+                store.initialize()
+                progress = ticket_progress(repo_root)
+                done = progress.get("done", 0)
+                total = progress.get("total", 0)
+                progress_label = f"{done}/{total}"
+                active = _select_latest_run(store, lambda run: run.status.is_active())
+                if active:
+                    status_icon = (
+                        "🟢" if active.status == FlowRunStatus.RUNNING else "🟡"
+                    )
+                    status_line = _format_status_line(
+                        label,
+                        status_icon=status_icon,
+                        status_value=active.status.value,
+                        progress_label=progress_label,
+                        run_id=active.id,
+                        indent=indent,
+                    )
+                else:
+                    paused = _select_latest_run(
+                        store, lambda run: run.status == FlowRunStatus.PAUSED
+                    )
+                    if paused:
+                        status_line = _format_status_line(
+                            label,
+                            status_icon="🔴",
+                            status_value="PAUSED",
+                            progress_label=progress_label,
+                            run_id=paused.id,
+                            indent=indent,
+                        )
+                    else:
+                        status_line = _format_status_line(
+                            label,
+                            status_icon="⚪",
+                            status_value="Idle",
+                            progress_label=progress_label,
+                            run_id=None,
+                            indent=indent,
+                        )
+            except Exception:
+                status_line = f"{indent}❓ {label}: Error reading state"
+            finally:
+                store.close()
+
+            groups[group].append((label, status_line))
+
+        for group in group_order:
+            entries = groups.get(group, [])
+            if not entries:
+                continue
+            entries.sort(key=lambda pair: (0 if pair[0] == group else 1, pair[0]))
+            lines.extend([line for _label, line in entries])
+            lines.append("")
+
+        if lines and lines[-1] == "":
+            lines.pop()
+        if extras:
+            lines.append("")
+            lines.append(
+                "Note: Unregistered worktrees detected. Run 'car hub scan' to register them."
+            )
+        lines.append("")
+        lines.append("Tip: use /flow <repo-id> status for repo details.")
+
+        await self._send_message(
+            message.chat_id,
+            "\n".join(lines),
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+            parse_mode=None,
+        )
+
     async def _handle_flow_status_action(
         self, message: TelegramMessage, repo_root: Path, argv: list[str]
     ) -> None:
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         try:
             store.initialize()
             run_id_raw = self._first_non_flag(argv)
@@ -785,7 +1073,7 @@ class FlowCommands(SharedHelpers):
                 return
             limit = min(limit_value, 50)
 
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         try:
             store.initialize()
             runs = store.list_flow_runs(flow_type="ticket_flow")
@@ -838,7 +1126,7 @@ class FlowCommands(SharedHelpers):
         tickets_exist = bool(existing_tickets)
         issue_exists = issue_md_has_content(repo_root)
 
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         active_run = None
         try:
             store.initialize()
@@ -865,7 +1153,7 @@ class FlowCommands(SharedHelpers):
             if gh_available:
                 repo_label = f" for {repo_slug}" if repo_slug else ""
                 prompt = (
-                    "Enter GitHub issue number or URL" f"{repo_label} to seed ISSUE.md:"
+                    f"Enter GitHub issue number or URL{repo_label} to seed ISSUE.md:"
                 )
                 issue_ref = await self._prompt_flow_text_input(message, prompt)
                 if not issue_ref:
@@ -1057,7 +1345,7 @@ You are the first ticket in a new ticket_flow run.
     async def _handle_flow_resume(
         self, message: TelegramMessage, repo_root: Path, argv: list[str]
     ) -> None:
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         try:
             store.initialize()
             run_id_raw = self._first_non_flag(argv)
@@ -1117,7 +1405,7 @@ You are the first ticket in a new ticket_flow run.
     async def _handle_flow_stop(
         self, message: TelegramMessage, repo_root: Path, argv: list[str]
     ) -> None:
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         try:
             store.initialize()
             run_id_raw = self._first_non_flag(argv)
@@ -1165,7 +1453,7 @@ You are the first ticket in a new ticket_flow run.
     async def _handle_flow_recover(
         self, message: TelegramMessage, repo_root: Path, argv: list[str]
     ) -> None:
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         try:
             store.initialize()
             run_id_raw = self._first_non_flag(argv)
@@ -1218,7 +1506,7 @@ You are the first ticket in a new ticket_flow run.
         argv: Optional[list[str]] = None,
     ) -> None:
         argv = argv or []
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         record = None
         try:
             store.initialize()
@@ -1241,7 +1529,7 @@ You are the first ticket in a new ticket_flow run.
         self, message: TelegramMessage, repo_root: Path, argv: list[str]
     ) -> None:
         force = self._has_flag(argv, "--force")
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         record = None
         try:
             store.initialize()
@@ -1304,7 +1592,7 @@ You are the first ticket in a new ticket_flow run.
             archived_runs_dir = artifacts_root / record.id / "archived_runs"
             shutil.move(str(run_dir), str(archived_runs_dir))
 
-        store = FlowStore(_flow_paths(repo_root)[0])
+        store = _load_flow_store(repo_root)
         try:
             store.initialize()
             store.delete_flow_run(record.id)