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

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

@@ -27,6 +27,7 @@ from .....agents.opencode.runtime import (
     split_model_id,
 )
 from .....agents.opencode.supervisor import OpenCodeSupervisorError
+from .....core.about_car import CAR_CONTEXT_HINT, CAR_CONTEXT_KEYWORDS
 from .....core.config import load_repo_config
 from .....core.injected_context import wrap_injected_context
 from .....core.logging_utils import log_event
@@ -46,7 +47,6 @@ from ...constants import (
     DEFAULT_INTERRUPT_TIMEOUT_SECONDS,
     MAX_MENTION_BYTES,
     MAX_TOPIC_THREAD_HISTORY,
-    OPENCODE_TURN_TIMEOUT_SECONDS,
     PLACEHOLDER_TEXT,
     QUEUED_PLACEHOLDER_TEXT,
     RESUME_PREVIEW_ASSISTANT_LIMIT,
@@ -94,20 +94,6 @@ OUTBOX_CONTEXT_RE = re.compile(
     re.IGNORECASE,
 )
 
-CAR_CONTEXT_KEYWORDS = (
-    "car",
-    "codex",
-    "todo",
-    "progress",
-    "opinions",
-    "spec",
-    "summary",
-    "autorunner",
-    "work docs",
-)
-CAR_CONTEXT_HINT = (
-    "Context: read .codex-autorunner/ABOUT_CAR.md for repo-specific rules."
-)
 
 FILES_HINT_TEMPLATE = (
     "Inbox: {inbox}\n"
@@ -1692,6 +1678,7 @@ class ExecutionCommands(SharedHelpers):
                             opencode_client,
                             session_id=thread_id,
                             workspace_path=str(workspace_root),
+                            model_payload=model_payload,
                             progress_session_ids=watched_session_ids,
                             permission_policy=permission_policy,
                             permission_handler=(
@@ -1719,9 +1706,14 @@ class ExecutionCommands(SharedHelpers):
                         codex_thread_id=thread_id,
                         sse_ready_ms=sse_ready_ms,
                     )
-                    timeout_task = asyncio.create_task(
-                        asyncio.sleep(OPENCODE_TURN_TIMEOUT_SECONDS)
+                    timeout_seconds = self._config.agent_turn_timeout_seconds.get(
+                        "opencode"
                     )
+                    timeout_task: Optional[asyncio.Task] = None
+                    if timeout_seconds is not None and timeout_seconds > 0:
+                        timeout_task = asyncio.create_task(
+                            asyncio.sleep(timeout_seconds)
+                        )
                     prompt_sent_at = time.monotonic()
                     prompt_task = asyncio.create_task(
                         opencode_client.prompt_async(
@@ -1745,52 +1737,54 @@ class ExecutionCommands(SharedHelpers):
                             endpoint="/session/{id}/prompt_async",
                         )
                     except Exception as exc:
-                        timeout_task.cancel()
-                        with suppress(asyncio.CancelledError):
-                            await timeout_task
+                        if timeout_task is not None:
+                            timeout_task.cancel()
+                            with suppress(asyncio.CancelledError):
+                                await timeout_task
                         output_task.cancel()
                         with suppress(asyncio.CancelledError):
                             await output_task
                         raise exc
-                    done, _pending = await asyncio.wait(
-                        {output_task, timeout_task},
-                        return_when=asyncio.FIRST_COMPLETED,
-                    )
-                    if timeout_task in done:
-                        runtime.interrupt_requested = True
-                        await _abort_opencode()
-                        output_task.cancel()
-                        with suppress(asyncio.CancelledError):
-                            await output_task
+                    if timeout_task is not None:
+                        done, _pending = await asyncio.wait(
+                            {output_task, timeout_task},
+                            return_when=asyncio.FIRST_COMPLETED,
+                        )
+                        if timeout_task in done:
+                            runtime.interrupt_requested = True
+                            await _abort_opencode()
+                            output_task.cancel()
+                            with suppress(asyncio.CancelledError):
+                                await output_task
+                            timeout_task.cancel()
+                            with suppress(asyncio.CancelledError):
+                                await timeout_task
+                            turn_elapsed_seconds = time.monotonic() - turn_started_at
+                            completion_mode = (
+                                "timeout"
+                                if not runtime.interrupt_requested
+                                else "interrupt"
+                            )
+                            log_event(
+                                self._logger,
+                                logging.INFO,
+                                "telegram.opencode.completed",
+                                topic_key=key,
+                                chat_id=message.chat_id,
+                                thread_id=message.thread_id,
+                                codex_thread_id=thread_id,
+                                completion_mode=completion_mode,
+                                elapsed_seconds=turn_elapsed_seconds,
+                            )
+                            return _TurnRunFailure(
+                                "OpenCode turn timed out.",
+                                placeholder_id,
+                                transcript_message_id,
+                                transcript_text,
+                            )
                         timeout_task.cancel()
                         with suppress(asyncio.CancelledError):
                             await timeout_task
-                        turn_elapsed_seconds = time.monotonic() - turn_started_at
-                        completion_mode = (
-                            "timeout"
-                            if not runtime.interrupt_requested
-                            else "interrupt"
-                        )
-                        log_event(
-                            self._logger,
-                            logging.INFO,
-                            "telegram.opencode.completed",
-                            topic_key=key,
-                            chat_id=message.chat_id,
-                            thread_id=message.thread_id,
-                            codex_thread_id=thread_id,
-                            completion_mode=completion_mode,
-                            elapsed_seconds=turn_elapsed_seconds,
-                        )
-                        return _TurnRunFailure(
-                            "OpenCode turn timed out.",
-                            placeholder_id,
-                            transcript_message_id,
-                            transcript_text,
-                        )
-                    timeout_task.cancel()
-                    with suppress(asyncio.CancelledError):
-                        await timeout_task
                     output_result = await output_task
                     turn_elapsed_seconds = time.monotonic() - turn_started_at
                     log_event(
@@ -2225,7 +2219,9 @@ class ExecutionCommands(SharedHelpers):
                 result = await self._wait_for_turn_result(
                     client,
                     turn_handle,
-                    timeout_seconds=self._config.app_server_turn_timeout_seconds,
+                    timeout_seconds=self._config.agent_turn_timeout_seconds.get(
+                        "codex"
+                    ),
                     topic_key=key,
                     chat_id=message.chat_id,
                     thread_id=message.thread_id,

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

@@ -8,7 +8,7 @@ import secrets
 import time
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Sequence
+from typing import Any, Optional, Sequence
 
 from .....core.injected_context import wrap_injected_context
 from .....core.logging_utils import log_event
@@ -16,13 +16,10 @@ from .....core.state import now_iso
 from ...adapter import TelegramMessage
 from ...config import TelegramMediaCandidate
 from ...helpers import _path_within
+from ...state import PendingVoiceRecord, TelegramTopicRecord
 from .. import messages as message_handlers
 from .shared import SharedHelpers
 
-if TYPE_CHECKING:
-    from ...state import PendingVoiceRecord, TelegramTopicRecord
-
-
 FILES_HINT_TEMPLATE = (
     "Inbox: {inbox}\n"
     "Outbox (pending): {outbox}\n"
@@ -100,7 +97,6 @@ class MediaBatchResult:
 
 
 class FilesCommands(SharedHelpers):
-
     def _format_telegram_download_error(self, exc: Exception) -> Optional[str]:
         for current in _iter_exception_chain(exc):
             if isinstance(current, Exception):

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

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from .....core.engine import Engine
+from .....core.flows import FlowController, FlowStore
+from .....core.flows.models import FlowRunStatus
+from .....core.flows.worker_process import (
+    check_worker_health,
+    spawn_flow_worker,
+)
+from .....core.utils import canonicalize_path
+from .....flows.ticket_flow import build_ticket_flow_definition
+from .....tickets import AgentPool
+from ...adapter import TelegramMessage
+from ...helpers import _truncate_text
+from .shared import SharedHelpers
+
+_logger = logging.getLogger(__name__)
+
+
+def _flow_paths(repo_root: Path) -> tuple[Path, Path]:
+    repo_root = repo_root.resolve()
+    db_path = repo_root / ".codex-autorunner" / "flows.db"
+    artifacts_root = repo_root / ".codex-autorunner" / "flows"
+    return db_path, artifacts_root
+
+
+def _get_ticket_controller(repo_root: Path) -> FlowController:
+    db_path, artifacts_root = _flow_paths(repo_root)
+    engine = Engine(repo_root)
+    agent_pool = AgentPool(engine.config)
+    definition = build_ticket_flow_definition(agent_pool=agent_pool)
+    definition.validate()
+    controller = FlowController(
+        definition=definition, db_path=db_path, artifacts_root=artifacts_root
+    )
+    controller.initialize()
+    return controller
+
+
+def _spawn_flow_worker(repo_root: Path, run_id: str) -> None:
+    health = check_worker_health(repo_root, run_id)
+    if health.is_alive:
+        _logger.info("Worker already active for run %s (pid=%s)", run_id, health.pid)
+        return
+
+    proc, out, err = spawn_flow_worker(repo_root, run_id)
+    try:
+        # We don't track handles in Telegram commands, close in parent after spawn.
+        out.close()
+        err.close()
+    finally:
+        if proc.poll() is not None:
+            _logger.warning("Flow worker for %s exited immediately", run_id)
+
+
+class FlowCommands(SharedHelpers):
+    async def _handle_flow(self, message: TelegramMessage, args: str) -> None:
+        """
+        /flow start     - seed tickets if missing and start ticket_flow
+        /flow resume    - resume latest paused ticket_flow run
+        /flow status    - show latest ticket_flow run status
+        """
+        key = await self._resolve_topic_key(message.chat_id, message.thread_id)
+        record = await self._store.get_topic(key)
+        if not record or not record.workspace_path:
+            await self._send_message(
+                message.chat_id,
+                "No workspace bound. Use /bind to bind this topic to a repo first.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        repo_root = canonicalize_path(Path(record.workspace_path))
+        cmd = (args or "").strip().lower().split()
+        action = cmd[0] if cmd else "status"
+
+        controller = _get_ticket_controller(repo_root)
+
+        store = FlowStore(_flow_paths(repo_root)[0])
+        try:
+            store.initialize()
+            runs = store.list_flow_runs(flow_type="ticket_flow")
+            latest = runs[0] if runs else None
+        finally:
+            store.close()
+
+        if action == "start":
+            if latest and latest.status.is_active():
+                await self._send_message(
+                    message.chat_id,
+                    f"Ticket flow already active (run {latest.id}, status {latest.status.value}).",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            # seed ticket if missing
+            ticket_dir = repo_root / ".codex-autorunner" / "tickets"
+            ticket_dir.mkdir(parents=True, exist_ok=True)
+            first_ticket = ticket_dir / "TICKET-001.md"
+            seeded = False
+            if not first_ticket.exists():
+                first_ticket.write_text(
+                    """---
+agent: codex
+done: false
+title: Bootstrap ticket flow
+goal: Create SPEC.md and additional tickets, then pause for review
+---
+
+Create SPEC.md and additional tickets under .codex-autorunner/tickets/. Then write a pause DISPATCH.md for review.
+""",
+                    encoding="utf-8",
+                )
+                seeded = True
+
+            flow_record = await controller.start_flow(
+                input_data={},
+                metadata={"seeded_ticket": seeded, "origin": "telegram"},
+            )
+            _spawn_flow_worker(repo_root, flow_record.id)
+            await self._send_message(
+                message.chat_id,
+                f"Started ticket flow run {flow_record.id}.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        if action == "resume":
+            if not latest:
+                await self._send_message(
+                    message.chat_id,
+                    "No ticket flow run found.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            if latest.status != FlowRunStatus.PAUSED:
+                await self._send_message(
+                    message.chat_id,
+                    f"Latest run is {latest.status.value}, not paused.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            updated = await controller.resume_flow(latest.id)
+            _spawn_flow_worker(repo_root, updated.id)
+            await self._send_message(
+                message.chat_id,
+                f"Resumed run {updated.id}.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        # status (default)
+        if not latest:
+            await self._send_message(
+                message.chat_id,
+                "No ticket flow run found. Use /flow start to start.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        state = latest.state or {}
+        engine = state.get("ticket_engine") or {}
+        current = engine.get("current_ticket") or "–"
+        reason = engine.get("reason") or latest.error_message or ""
+        text = f"Run {latest.id}\nStatus: {latest.status.value}\nCurrent: {current}"
+        if reason:
+            text += f"\nReason: {_truncate_text(str(reason), 400)}"
+        text += "\n\nUse /flow resume to resume a paused run."
+        await self._send_message(
+            message.chat_id,
+            text,
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+
+    async def _handle_reply(self, message: TelegramMessage, args: str) -> None:
+        key = await self._resolve_topic_key(message.chat_id, message.thread_id)
+        record = await self._store.get_topic(key)
+        if not record or not record.workspace_path:
+            await self._send_message(
+                message.chat_id,
+                "No workspace bound. Use /bind to bind this topic to a repo first.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        repo_root = canonicalize_path(Path(record.workspace_path))
+        text = args.strip()
+        if not text:
+            await self._send_message(
+                message.chat_id,
+                "Provide a reply: `/reply <message>`",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        target_run_id = self._ticket_flow_pause_targets.get(str(repo_root))
+        paused = self._get_paused_ticket_flow(repo_root, preferred_run_id=target_run_id)
+        if not paused:
+            await self._send_message(
+                message.chat_id,
+                "No paused ticket flow run found for this workspace.",
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+
+        run_id, run_record = paused
+        success, result = await self._write_user_reply_from_telegram(
+            repo_root, run_id, run_record, message, text
+        )
+        await self._send_message(
+            message.chat_id,
+            result,
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )

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

@@ -75,7 +75,7 @@ class FormattingHelpers:
     def _build_compact_seed_prompt(self, summary_text: str) -> str:
         summary_text = summary_text.strip() or "(no summary)"
         return (
-            "Context handoff from previous thread:\n\n"
+            "Context from previous thread:\n\n"
             f"{summary_text}\n\n"
             "Continue from this context. Ask for missing info if needed."
         )