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

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

@@ -9,7 +9,6 @@ import re
 import time
 from contextlib import suppress
 from dataclasses import dataclass
-from os import getenv
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional
 
@@ -26,20 +25,14 @@ from .....agents.opencode.runtime import (
     opencode_missing_env,
     split_model_id,
 )
-from .....core.config import load_hub_config, load_repo_config
 from .....core.logging_utils import log_event
 from .....core.state import now_iso
 from .....core.text_delta_coalescer import TextDeltaCoalescer
-from .....core.utils import canonicalize_path
-from .....integrations.github.service import GitHubError, GitHubService
-from .....manifest import load_manifest
 from ....app_server.client import (
     CodexAppServerDisconnected,
 )
 from ...adapter import (
     InlineButton,
-    PrFlowStartCallback,
-    TelegramCallbackQuery,
     TelegramMessage,
     build_inline_keyboard,
     encode_cancel_callback,
@@ -47,7 +40,6 @@ from ...adapter import (
 from ...config import AppServerUnavailableError
 from ...constants import (
     MAX_TOPIC_THREAD_HISTORY,
-    OPENCODE_TURN_TIMEOUT_SECONDS,
     PLACEHOLDER_TEXT,
     QUEUED_PLACEHOLDER_TEXT,
     RESUME_PREVIEW_ASSISTANT_LIMIT,
@@ -411,7 +403,7 @@ class GitHubCommands(SharedHelpers):
         result = await self._wait_for_turn_result(
             setup.client,
             turn_context.turn_handle,
-            timeout_seconds=self._config.app_server_turn_timeout_seconds,
+            timeout_seconds=self._config.agent_turn_timeout_seconds.get("codex"),
             topic_key=topic_key,
             chat_id=message.chat_id,
             thread_id=message.thread_id,
@@ -1212,6 +1204,7 @@ class GitHubCommands(SharedHelpers):
                         setup.client,
                         session_id=setup.review_session_id,
                         workspace_path=str(setup.workspace_root),
+                        model_payload=model_payload,
                         progress_session_ids=watched_session_ids,
                         permission_policy=setup.permission_policy,
                         permission_handler=(
@@ -1226,9 +1219,12 @@ class GitHubCommands(SharedHelpers):
                 )
                 with suppress(asyncio.TimeoutError):
                     await asyncio.wait_for(ready_event.wait(), timeout=2.0)
-                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))
                 command_task = asyncio.create_task(
                     setup.client.send_command(
                         setup.review_session_id,
@@ -1240,45 +1236,47 @@ class GitHubCommands(SharedHelpers):
                 try:
                     await command_task
                 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_context.turn_elapsed_seconds = (
+                            time.monotonic() - turn_started_at
+                            if turn_started_at is not None
+                            else None
+                        )
+                        failure_message = "OpenCode review timed out."
+                        response_sent = await self._deliver_turn_response(
+                            chat_id=message.chat_id,
+                            thread_id=message.thread_id,
+                            reply_to=message.message_id,
+                            placeholder_id=placeholder_id,
+                            response=failure_message,
+                        )
+                        if response_sent:
+                            await self._delete_message(message.chat_id, placeholder_id)
+                        return turn_context, None
                     timeout_task.cancel()
                     with suppress(asyncio.CancelledError):
                         await timeout_task
-                    turn_context.turn_elapsed_seconds = (
-                        time.monotonic() - turn_started_at
-                        if turn_started_at is not None
-                        else None
-                    )
-                    failure_message = "OpenCode review timed out."
-                    response_sent = await self._deliver_turn_response(
-                        chat_id=message.chat_id,
-                        thread_id=message.thread_id,
-                        reply_to=message.message_id,
-                        placeholder_id=placeholder_id,
-                        response=failure_message,
-                    )
-                    if response_sent:
-                        await self._delete_message(message.chat_id, placeholder_id)
-                    return turn_context, None
-                timeout_task.cancel()
-                with suppress(asyncio.CancelledError):
-                    await timeout_task
                 output_result = await output_task
                 elapsed = (
                     time.monotonic() - turn_started_at
@@ -1563,520 +1561,6 @@ class GitHubCommands(SharedHelpers):
             delivery=delivery,
         )
 
-    def _resolve_pr_flow_repo_id(self, record: "TelegramTopicRecord") -> Optional[str]:
-        if record.repo_id:
-            return record.repo_id
-        if not self._hub_root or not self._manifest_path or not record.workspace_path:
-            return None
-        try:
-            manifest = load_manifest(self._manifest_path, self._hub_root)
-        except Exception:
-            return None
-        try:
-            workspace_path = canonicalize_path(Path(record.workspace_path))
-        except Exception:
-            return None
-        for repo in manifest.repos:
-            repo_path = canonicalize_path(self._hub_root / repo.path)
-            if repo_path == workspace_path:
-                return repo.id
-        return None
-
-    def _pr_flow_api_base(
-        self, record: "TelegramTopicRecord"
-    ) -> tuple[Optional[str], dict[str, str]]:
-        headers: dict[str, str] = {}
-        if self._hub_root is not None:
-            try:
-                hub_config = load_hub_config(self._hub_root)
-            except Exception:
-                return None, headers
-            host = hub_config.server_host
-            port = hub_config.server_port
-            base_path = hub_config.server_base_path
-            auth_env = hub_config.server_auth_token_env
-            repo_id = self._resolve_pr_flow_repo_id(record)
-            if not repo_id:
-                return None, headers
-            repo_prefix = f"/repos/{repo_id}"
-        else:
-            if not record.workspace_path:
-                return None, headers
-            try:
-                repo_config = load_repo_config(
-                    Path(record.workspace_path), hub_path=None
-                )
-            except Exception:
-                return None, headers
-            host = repo_config.server_host
-            port = repo_config.server_port
-            base_path = repo_config.server_base_path
-            auth_env = repo_config.server_auth_token_env
-            repo_prefix = ""
-        if isinstance(auth_env, str) and auth_env:
-            token = getenv(auth_env)
-            if token:
-                headers["Authorization"] = f"Bearer {token}"
-        if not host:
-            return None, headers
-        if host.startswith("http://") or host.startswith("https://"):
-            base = host.rstrip("/")
-        else:
-            base = f"http://{host}:{int(port)}"
-        base_path = (base_path or "").strip("/")
-        if base_path:
-            base = f"{base}/{base_path}"
-        return f"{base}{repo_prefix}", headers
-
-    async def _pr_flow_request(
-        self,
-        record: "TelegramTopicRecord",
-        *,
-        method: str,
-        path: str,
-        payload: Optional[dict[str, Any]] = None,
-    ) -> dict[str, Any]:
-        base, headers = self._pr_flow_api_base(record)
-        if not base:
-            raise RuntimeError(
-                "PR flow cannot start: repo server base URL could not be resolved for this chat/topic."
-            )
-        url = f"{base}{path}"
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            res = await client.request(method, url, json=payload, headers=headers)
-            res.raise_for_status()
-            data = res.json()
-            if isinstance(data, dict):
-                return data
-            return {"status": "ok", "flow": data}
-
-    def _parse_pr_flags(self, argv: list[str]) -> tuple[Optional[str], dict[str, Any]]:
-        ref: Optional[str] = None
-        flags: dict[str, Any] = {}
-        idx = 0
-        while idx < len(argv):
-            token = argv[idx]
-            if token.startswith("--"):
-                if token == "--draft":
-                    flags["draft"] = True
-                    idx += 1
-                    continue
-                if token == "--ready":
-                    flags["draft"] = False
-                    idx += 1
-                    continue
-                if token == "--base" and idx + 1 < len(argv):
-                    flags["base_branch"] = argv[idx + 1]
-                    idx += 2
-                    continue
-                if token == "--until" and idx + 1 < len(argv):
-                    until = argv[idx + 1].strip().lower()
-                    if until in ("minor", "minor_only"):
-                        flags["stop_condition"] = "minor_only"
-                    elif until in ("clean", "no_issues"):
-                        flags["stop_condition"] = "no_issues"
-                    idx += 2
-                    continue
-                if token in ("--max-cycles", "--max_cycles") and idx + 1 < len(argv):
-                    try:
-                        flags["max_cycles"] = int(argv[idx + 1])
-                    except ValueError:
-                        pass
-                    idx += 2
-                    continue
-                if token in ("--max-runs", "--max_runs") and idx + 1 < len(argv):
-                    try:
-                        flags["max_implementation_runs"] = int(argv[idx + 1])
-                    except ValueError:
-                        pass
-                    idx += 2
-                    continue
-                if token in ("--timeout", "--timeout-seconds") and idx + 1 < len(argv):
-                    try:
-                        flags["max_wallclock_seconds"] = int(argv[idx + 1])
-                    except ValueError:
-                        pass
-                    idx += 2
-                    continue
-                idx += 1
-                continue
-            if ref is None:
-                ref = token
-            idx += 1
-        return ref, flags
-
-    def _format_pr_flow_status(self, flow: dict[str, Any]) -> str:
-        status = flow.get("status") or "unknown"
-        step = flow.get("step") or "unknown"
-        cycle = flow.get("cycle") or 0
-        pr_url = flow.get("pr_url") or ""
-        lines = [f"PR flow: {status} (step: {step}, cycle: {cycle})"]
-        if pr_url:
-            lines.append(f"PR: {pr_url}")
-        return "\n".join(lines)
-
-    async def _handle_github_issue_url(
-        self,
-        message: TelegramMessage,
-        key: str,
-        slug: str,
-        number: int,
-    ) -> None:
-        if key is None:
-            return
-
-        record = await self._router.get_topic(key)
-        if record is None or not record.workspace_path:
-            await self._send_message(
-                message.chat_id,
-                self._with_conversation_id(
-                    "Topic not bound. Use /bind <repo_id> or /bind <path>.",
-                    chat_id=message.chat_id,
-                    thread_id=message.thread_id,
-                ),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-
-        try:
-            from pathlib import Path
-
-            service = GitHubService(Path(record.workspace_path), self._raw_config)
-            issue_ref = f"{slug}#{number}"
-            service.validate_issue_same_repo(issue_ref)
-        except GitHubError as exc:
-            await self._send_message(
-                message.chat_id,
-                str(exc),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-
-        await self._offer_pr_flow_start(message, record, slug, number)
-
-    async def _offer_pr_flow_start(
-        self,
-        message: TelegramMessage,
-        record: "TelegramTopicRecord",
-        slug: str,
-        number: int,
-    ) -> None:
-        from ...adapter import (
-            InlineButton,
-            build_inline_keyboard,
-            encode_cancel_callback,
-            encode_pr_flow_start_callback,
-        )
-
-        keyboard = build_inline_keyboard(
-            [
-                [
-                    InlineButton(
-                        f"Create PR for #{number}",
-                        encode_pr_flow_start_callback(slug, number),
-                    ),
-                    InlineButton(
-                        "Cancel",
-                        encode_cancel_callback("pr_flow_offer"),
-                    ),
-                ]
-            ]
-        )
-        await self._send_message(
-            message.chat_id,
-            f"Detected GitHub issue: {slug}#{number}\nStart PR flow to create a PR?",
-            thread_id=message.thread_id,
-            reply_to=message.message_id,
-            reply_markup=keyboard,
-        )
-
-    async def _handle_pr_flow_start_callback(
-        self,
-        key: str,
-        callback: TelegramCallbackQuery,
-        parsed: PrFlowStartCallback,
-    ) -> None:
-        from ...adapter import TelegramMessage
-
-        await self._answer_callback(callback)
-        record = await self._router.get_topic(key)
-        if record is None or not record.workspace_path:
-            return
-
-        issue_ref = f"{parsed.slug}#{parsed.number}"
-        payload = {"mode": "issue", "issue": issue_ref}
-        payload["source"] = "telegram"
-        source_meta: dict[str, Any] = {}
-        if callback.chat_id is not None:
-            source_meta["chat_id"] = callback.chat_id
-        if callback.thread_id is not None:
-            source_meta["thread_id"] = callback.thread_id
-        if source_meta:
-            payload["source_meta"] = source_meta
-
-        message = TelegramMessage(
-            update_id=callback.update_id,
-            message_id=callback.message_id or 0,
-            chat_id=callback.chat_id or 0,
-            thread_id=callback.thread_id,
-            from_user_id=callback.from_user_id,
-            text="",
-            date=None,
-            is_topic_message=False,
-        )
-
-        try:
-            data = await self._pr_flow_request(
-                record,
-                method="POST",
-                path="/api/github/pr_flow/start",
-                payload=payload,
-            )
-            flow = data.get("flow") if isinstance(data, dict) else data
-        except Exception as exc:
-            detail = _format_httpx_exception(exc) or str(exc)
-            await self._send_message(
-                message.chat_id,
-                f"PR flow error: {detail}",
-                thread_id=message.thread_id,
-                reply_to=callback.message_id,
-            )
-            return
-        await self._send_message(
-            message.chat_id,
-            self._format_pr_flow_status(flow),
-            thread_id=message.thread_id,
-            reply_to=callback.message_id,
-        )
-
-    async def _handle_pr(
-        self, message: TelegramMessage, args: str, runtime: Any
-    ) -> None:
-        record = await self._require_bound_record(message)
-        if not record:
-            return
-        argv = self._parse_command_args(args)
-        if not argv:
-            await self._send_message(
-                message.chat_id,
-                "Usage: /pr start <issueRef> | /pr fix <prRef> | /pr status | /pr stop | /pr resume | /pr collect",
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        command = argv[0].lower()
-        if command == "status":
-            try:
-                data = await self._pr_flow_request(
-                    record, method="GET", path="/api/github/pr_flow/status"
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command == "stop":
-            try:
-                data = await self._pr_flow_request(
-                    record, method="POST", path="/api/github/pr_flow/stop", payload={}
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command == "resume":
-            try:
-                data = await self._pr_flow_request(
-                    record, method="POST", path="/api/github/pr_flow/resume", payload={}
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command == "collect":
-            try:
-                data = await self._pr_flow_request(
-                    record,
-                    method="POST",
-                    path="/api/github/pr_flow/collect",
-                    payload={},
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command in ("start", "implement"):
-            ref, flags = self._parse_pr_flags(argv[1:])
-            if not ref:
-                gh = GitHubService(Path(record.workspace_path))
-                issues = await asyncio.to_thread(gh.list_open_issues, limit=5)
-                if issues:
-                    lines = ["Open issues:"]
-                    for issue in issues:
-                        num = issue.get("number")
-                        title = issue.get("title") or ""
-                        lines.append(f"- #{num} {title}".strip())
-                    lines.append("Use /pr start <issueRef> to begin.")
-                    await self._send_message(
-                        message.chat_id,
-                        "\n".join(lines),
-                        thread_id=message.thread_id,
-                        reply_to=message.message_id,
-                    )
-                    return
-                await self._send_message(
-                    message.chat_id,
-                    "Usage: /pr start <issueRef>",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            payload = {"mode": "issue", "issue": ref, **flags}
-            payload["source"] = "telegram"
-            payload["source_meta"] = {
-                "chat_id": message.chat_id,
-                "thread_id": message.thread_id,
-            }
-            try:
-                data = await self._pr_flow_request(
-                    record,
-                    method="POST",
-                    path="/api/github/pr_flow/start",
-                    payload=payload,
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        if command in ("fix", "pr"):
-            ref, flags = self._parse_pr_flags(argv[1:])
-            if not ref:
-                gh = GitHubService(Path(record.workspace_path))
-                prs = await asyncio.to_thread(gh.list_open_prs, limit=5)
-                if prs:
-                    lines = ["Open PRs:"]
-                    for pr in prs:
-                        num = pr.get("number")
-                        title = pr.get("title") or ""
-                        lines.append(f"- #{num} {title}".strip())
-                    lines.append("Use /pr fix <prRef> to begin.")
-                    await self._send_message(
-                        message.chat_id,
-                        "\n".join(lines),
-                        thread_id=message.thread_id,
-                        reply_to=message.message_id,
-                    )
-                    return
-                await self._send_message(
-                    message.chat_id,
-                    "Usage: /pr fix <prRef>",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            payload = {"mode": "pr", "pr": ref, **flags}
-            payload["source"] = "telegram"
-            payload["source_meta"] = {
-                "chat_id": message.chat_id,
-                "thread_id": message.thread_id,
-            }
-            try:
-                data = await self._pr_flow_request(
-                    record,
-                    method="POST",
-                    path="/api/github/pr_flow/start",
-                    payload=payload,
-                )
-                flow = data.get("flow") if isinstance(data, dict) else data
-            except Exception as exc:
-                detail = _format_httpx_exception(exc) or str(exc)
-                await self._send_message(
-                    message.chat_id,
-                    f"PR flow error: {detail}",
-                    thread_id=message.thread_id,
-                    reply_to=message.message_id,
-                )
-                return
-            await self._send_message(
-                message.chat_id,
-                self._format_pr_flow_status(flow),
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
-            return
-        await self._send_message(
-            message.chat_id,
-            "Unknown /pr command. Use /pr start|fix|status|stop|resume|collect.",
-            thread_id=message.thread_id,
-            reply_to=message.message_id,
-        )
-
     async def _prompt_review_commit_picker(
         self,
         message: TelegramMessage,
@@ -2202,28 +1686,3 @@ def _extract_opencode_error_detail(payload: Any) -> Optional[str]:
         if isinstance(value, str) and value:
             return value
     return None
-
-
-def _format_httpx_exception(exc: Exception) -> Optional[str]:
-    """Format httpx exceptions for user-friendly error messages."""
-    if isinstance(exc, httpx.HTTPStatusError):
-        try:
-            payload = exc.response.json()
-        except Exception:
-            payload = None
-        if isinstance(payload, dict):
-            detail = (
-                payload.get("detail") or payload.get("message") or payload.get("error")
-            )
-            if isinstance(detail, str) and detail:
-                return detail
-        response_text = exc.response.text.strip()
-        if response_text:
-            return response_text
-        return f"Request failed (HTTP {exc.response.status_code})."
-    if isinstance(exc, httpx.RequestError):
-        detail = str(exc).strip()
-        if detail:
-            return detail
-        return "Request failed."
-    return None