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

codex_autorunner/integrations/telegram/handlers/commands_spec.py

@@ -36,10 +36,17 @@ def build_command_specs(handlers: Any) -> dict[str, CommandSpec]:
             "run a code review",
             handlers._handle_review,
         ),
-        "pr": CommandSpec(
-            "pr",
-            "run the GitHub PR flow",
-            handlers._handle_pr,
+        "flow": CommandSpec(
+            "flow",
+            "start/resume ticket flow runs",
+            lambda message, args, _runtime: handlers._handle_flow(message, args),
+            allow_during_turn=True,
+        ),
+        "reply": CommandSpec(
+            "reply",
+            "reply to a paused ticket flow dispatch",
+            lambda message, args, _runtime: handlers._handle_reply(message, args),
+            allow_during_turn=True,
         ),
         "agent": CommandSpec(
             "agent",

codex_autorunner/integrations/telegram/handlers/messages.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import Any, Optional, Sequence
 
 from ....core.logging_utils import log_event
-from ....integrations.github.service import parse_github_url
+from ....core.utils import canonicalize_path
 from ..adapter import (
     TelegramDocument,
     TelegramMessage,
@@ -19,6 +19,7 @@ from ..adapter import (
 )
 from ..config import TelegramMediaCandidate
 from ..constants import TELEGRAM_MAX_MESSAGE_LENGTH
+from ..trigger_mode import should_trigger_run
 from .questions import handle_custom_text_input
 
 COALESCE_LONG_MESSAGE_WINDOW_SECONDS = 6.0
@@ -37,6 +38,14 @@ IMAGE_EXTS = set(IMAGE_CONTENT_TYPES.values())
 MAX_BATCH_ITEMS = 10
 
 
+def _is_ticket_reply(message: TelegramMessage, bot_username: Optional[str]) -> bool:
+    if message.reply_to_is_bot and message.reply_to_message_id is not None:
+        if bot_username and message.reply_to_username:
+            return message.reply_to_username.lower() == bot_username.lower()
+        return True
+    return False
+
+
 @dataclass
 class _CoalescedBuffer:
     message: TelegramMessage
@@ -246,14 +255,6 @@ async def handle_message_inner(
         await _clear_placeholder()
         return
 
-    if text:
-        parsed = parse_github_url(text.strip())
-        if parsed and parsed[1] == "issue":
-            slug, kind, number = parsed
-            await handlers._handle_github_issue_url(message, key, slug, number)
-            await _clear_placeholder()
-            return
-
     if text and is_interrupt_alias(text):
         await handlers._handle_interrupt(message, runtime)
         await _clear_placeholder()
@@ -347,6 +348,66 @@ async def handle_message_inner(
             )
         return
 
+    record = await handlers._router.get_topic(key)
+    paused = None
+    workspace_root: Optional[Path] = None
+    if record and record.workspace_path:
+        workspace_root = canonicalize_path(Path(record.workspace_path))
+        preferred_run_id = handlers._ticket_flow_pause_targets.get(
+            str(workspace_root), None
+        )
+        paused = handlers._get_paused_ticket_flow(
+            workspace_root, preferred_run_id=preferred_run_id
+        )
+    if (
+        paused
+        and text
+        and not _is_ticket_reply(message, handlers._bot_username)
+        and not command
+    ):
+        await handlers._send_message(
+            message.chat_id,
+            "Ticket flow is paused. Reply to the latest dispatch message (tap Reply) or use /flow resume.",
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+        await _clear_placeholder()
+        return
+    if paused and text and _is_ticket_reply(message, handlers._bot_username):
+        run_id, run_record = paused
+        success, result = await handlers._write_user_reply_from_telegram(
+            workspace_root or Path("."), run_id, run_record, message, text
+        )
+        await handlers._send_message(
+            message.chat_id,
+            result,
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+        if success and getattr(handlers._config, "ticket_flow_auto_resume", False):
+            await handlers._ticket_flow_bridge.auto_resume_run(
+                workspace_root or Path("."), run_id
+            )
+        await _clear_placeholder()
+        return
+
+    if handlers._config.trigger_mode == "mentions" and not should_trigger_run(
+        message,
+        text=text,
+        bot_username=handlers._bot_username,
+    ):
+        log_event(
+            handlers._logger,
+            logging.INFO,
+            "telegram.trigger.ignored",
+            chat_id=message.chat_id,
+            thread_id=message.thread_id,
+            message_id=message.message_id,
+            reason="mentions_only",
+        )
+        await _clear_placeholder()
+        return
+
     if has_media:
 
         async def work() -> None:
@@ -752,6 +813,56 @@ async def handle_media_message(
         )
         return
 
+    workspace_root = canonicalize_path(Path(record.workspace_path))
+    preferred_run_id = handlers._ticket_flow_pause_targets.get(
+        str(workspace_root), None
+    )
+    paused = handlers._get_paused_ticket_flow(
+        workspace_root, preferred_run_id=preferred_run_id
+    )
+    if paused and caption_text and _is_ticket_reply(message, handlers._bot_username):
+        run_id, run_record = paused
+        files = []
+        if message.photos:
+            photos = sorted(
+                message.photos,
+                key=lambda p: (p.file_size or 0, p.width * p.height),
+                reverse=True,
+            )
+            if photos:
+                best = photos[0]
+                try:
+                    file_info = await handlers._bot.get_file(best.file_id)
+                    data = await handlers._bot.download_file(file_info.file_path)
+                    filename = f"photo_{best.file_id}.jpg"
+                    files.append((filename, data))
+                except Exception as exc:
+                    handlers._logger.debug("Failed to download photo: %s", exc)
+                    pass
+        elif message.document:
+            try:
+                file_info = await handlers._bot.get_file(message.document.file_id)
+                data = await handlers._bot.download_file(file_info.file_path)
+                filename = (
+                    message.document.file_name or f"document_{message.document.file_id}"
+                )
+                files.append((filename, data))
+            except Exception as exc:
+                handlers._logger.debug("Failed to download document: %s", exc)
+                pass
+        success, result = await handlers._write_user_reply_from_telegram(
+            workspace_root, run_id, run_record, message, caption_text, files
+        )
+        await handlers._send_message(
+            message.chat_id,
+            result,
+            thread_id=message.thread_id,
+            reply_to=message.message_id,
+        )
+        if success and getattr(handlers._config, "ticket_flow_auto_resume", False):
+            await handlers._ticket_flow_bridge.auto_resume_run(workspace_root, run_id)
+        return
+
     image_candidate = select_image_candidate(message)
     if image_candidate:
         if not handlers._config.media.images:

codex_autorunner/integrations/telegram/helpers.py

@@ -42,6 +42,85 @@ class ModelOption:
     default_effort: Optional[str] = None
 
 
+@dataclass(frozen=True)
+class CodexFeatureRow:
+    key: str
+    stage: str
+    enabled: bool
+
+
+def derive_codex_features_command(app_server_command: Sequence[str]) -> list[str]:
+    """
+    Build a Codex CLI invocation for `features list` that mirrors the configured app-server command.
+
+    We strip a trailing \"app-server\" subcommand (plus keep any preceding flags/binary),
+    so custom binaries or wrapper scripts stay aligned with the running app server.
+    """
+    base = list(app_server_command or [])
+    if base and base[-1] == "app-server":
+        base = base[:-1]
+    if not base:
+        base = ["codex"]
+    return [*base, "features", "list"]
+
+
+def parse_codex_features_list(stdout: str) -> list[CodexFeatureRow]:
+    rows: list[CodexFeatureRow] = []
+    if not isinstance(stdout, str):
+        return rows
+    for line in stdout.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        parts = line.split("\t")
+        if len(parts) != 3:
+            continue
+        key, stage, enabled_raw = parts
+        key = key.strip()
+        stage = stage.strip()
+        enabled_raw = enabled_raw.strip().lower()
+        if not key or not stage:
+            continue
+        if enabled_raw in ("true", "1", "yes", "y", "on"):
+            enabled = True
+        elif enabled_raw in ("false", "0", "no", "n", "off"):
+            enabled = False
+        else:
+            continue
+        rows.append(CodexFeatureRow(key=key, stage=stage, enabled=enabled))
+    return rows
+
+
+def format_codex_features(
+    rows: Sequence[CodexFeatureRow], *, stage_filter: Optional[str]
+) -> str:
+    filtered = [
+        row
+        for row in rows
+        if stage_filter is None or row.stage.lower() == stage_filter.lower()
+    ]
+    if not filtered:
+        label = (
+            "feature flags" if stage_filter is None else f"{stage_filter} feature flags"
+        )
+        return f"No {label} found."
+    header = (
+        "Codex feature flags (all):"
+        if stage_filter is None
+        else f"Codex feature flags ({stage_filter}):"
+    )
+    lines = [header]
+    for row in sorted(filtered, key=lambda r: r.key):
+        lines.append(f"- {row.key}: {row.enabled}")
+    lines.append("")
+    lines.append("Usage:")
+    lines.append("/experimental enable <flag>")
+    lines.append("/experimental disable <flag>")
+    if stage_filter is not None:
+        lines.append("/experimental all")
+    return "\n".join(lines)
+
+
 def _extract_thread_id(payload: Any) -> Optional[str]:
     if not isinstance(payload, dict):
         return None
@@ -837,14 +916,7 @@ def _format_help_text(command_specs: dict[str, CommandSpec]) -> str:
         lines.append("/review commit <sha> (or /review commit to pick)")
         lines.append("/review custom <instructions> (or /review custom to prompt)")
         lines.append("/review detached ...")
-    if "pr" in command_specs:
-        lines.append("")
-        lines.append("PR Flow:")
-        lines.append(
-            "/pr start <issueRef> [--draft|--ready] [--base <branch>] [--until minor|clean] [--max-cycles N]"
-        )
-        lines.append("/pr fix <prRef> [--until minor|clean] [--max-cycles N]")
-        lines.append("/pr status | /pr stop | /pr resume | /pr collect")
+
     lines.append("")
     lines.append("Other:")
     lines.append("Note: /resume is supported for the codex and opencode agents.")
@@ -1244,7 +1316,7 @@ FIRST_USER_PREVIEW_IGNORE_PATTERNS = (
     ),
 )
 
-USER_MESSAGE_BEGIN_STRIP_RE = re.compile(
+DISPATCH_BEGIN_STRIP_RE = re.compile(
     r"(?s)^\s*(?:<prior context>\s*)?##\s*My request for Codex:\s*",
     re.IGNORECASE,
 )
@@ -1261,17 +1333,17 @@ def _is_ignored_first_user_preview(text: Optional[str]) -> bool:
     )
 
 
-def _strip_user_message_begin(text: Optional[str]) -> Optional[str]:
+def _strip_dispatch_begin(text: Optional[str]) -> Optional[str]:
     if not isinstance(text, str):
         return text
-    stripped = USER_MESSAGE_BEGIN_STRIP_RE.sub("", text)
+    stripped = DISPATCH_BEGIN_STRIP_RE.sub("", text)
     return stripped if stripped != text else text
 
 
 def _sanitize_user_preview(text: Optional[str]) -> Optional[str]:
     if not isinstance(text, str):
         return text
-    stripped = _strip_user_message_begin(text)
+    stripped = _strip_dispatch_begin(text)
     if _is_ignored_first_user_preview(stripped):
         return None
     return stripped
@@ -1293,7 +1365,7 @@ def _github_preview_matcher(text: Optional[str]) -> Optional[str]:
     return None
 
 
-COMPACT_SEED_PREFIX = "Context handoff from previous thread:"
+COMPACT_SEED_PREFIX = "Context from previous thread:"
 COMPACT_SEED_SUFFIX = "Continue from this context. Ask for missing info if needed."
 
 
@@ -1572,7 +1644,7 @@ def _extract_rollout_first_user_preview(path: Path) -> Optional[str]:
             continue
         for role, text in _iter_role_texts(payload):
             if role == "user" and text:
-                stripped = _strip_user_message_begin(text)
+                stripped = _strip_dispatch_begin(text)
                 if stripped and not _is_ignored_first_user_preview(stripped):
                     return stripped
     return None
@@ -1632,7 +1704,7 @@ def _extract_turns_first_user_preview(turns: Any) -> Optional[str]:
             for item in iterable:
                 for role, text in _iter_role_texts(item):
                     if role == "user" and text:
-                        stripped = _strip_user_message_begin(text)
+                        stripped = _strip_dispatch_begin(text)
                         if stripped and not _is_ignored_first_user_preview(stripped):
                             return stripped
     return None
@@ -1770,7 +1842,7 @@ def _extract_first_user_preview(entry: Any) -> Optional[str]:
         "initialMessage",
     )
     user_preview = _coerce_preview_field(entry, user_preview_keys)
-    user_preview = _strip_user_message_begin(user_preview)
+    user_preview = _strip_dispatch_begin(user_preview)
     if _is_ignored_first_user_preview(user_preview):
         user_preview = None
     turns = entry.get("turns")