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

codex_autorunner/integrations/telegram/transport.py

@@ -41,14 +41,33 @@ class TelegramMessageTransport:
         message_id: int,
         text: str,
         *,
+        message_thread_id: Optional[int] = None,
         reply_markup: Optional[dict[str, Any]] = None,
     ) -> bool:
         try:
             payload_text, parse_mode = self._prepare_message(text)
+            if len(payload_text) > TELEGRAM_MAX_MESSAGE_LENGTH:
+                trimmed = trim_markdown_message(
+                    payload_text,
+                    max_len=TELEGRAM_MAX_MESSAGE_LENGTH,
+                    render=(
+                        _format_telegram_html
+                        if parse_mode == "HTML"
+                        else (
+                            lambda v: (
+                                _format_telegram_markdown(v, parse_mode)
+                                if parse_mode in ("Markdown", "MarkdownV2")
+                                else v
+                            )
+                        )
+                    ),
+                )
+                payload_text = trimmed
             await self._bot.edit_message_text(
                 chat_id,
                 message_id,
                 payload_text,
+                message_thread_id=message_thread_id,
                 reply_markup=reply_markup,
                 parse_mode=parse_mode,
             )
@@ -56,11 +75,17 @@ class TelegramMessageTransport:
             return False
         return True
 
-    async def _delete_message(self, chat_id: int, message_id: Optional[int]) -> bool:
+    async def _delete_message(
+        self, chat_id: int, message_id: Optional[int], thread_id: Optional[int] = None
+    ) -> bool:
         if message_id is None:
             return False
         try:
-            return bool(await self._bot.delete_message(chat_id, message_id))
+            return bool(
+                await self._bot.delete_message(
+                    chat_id, message_id, message_thread_id=thread_id
+                )
+            )
         except Exception:
             return False
 
@@ -77,6 +102,7 @@ class TelegramMessageTransport:
             callback.chat_id,
             callback.message_id,
             text,
+            message_thread_id=callback.thread_id,
             reply_markup=reply_markup,
         )
 
@@ -358,7 +384,7 @@ class TelegramMessageTransport:
         thread_id: Optional[int] = None,
         reply_to: Optional[int] = None,
         caption: Optional[str] = None,
-    ) -> None:
+    ) -> bool:
         try:
             await self._bot.send_document(
                 chat_id,
@@ -368,6 +394,7 @@ class TelegramMessageTransport:
                 reply_to_message_id=reply_to,
                 caption=caption,
             )
+            return True
         except Exception as exc:
             log_event(
                 self._logger,
@@ -378,6 +405,7 @@ class TelegramMessageTransport:
                 reply_to_message_id=reply_to,
                 exc=exc,
             )
+            return False
 
     async def _answer_callback(
         self, callback: Optional[TelegramCallbackQuery], text: str
@@ -385,7 +413,13 @@ class TelegramMessageTransport:
         if callback is None:
             return
         try:
-            await self._bot.answer_callback_query(callback.callback_id, text=text)
+            await self._bot.answer_callback_query(
+                callback.callback_id,
+                chat_id=callback.chat_id,
+                thread_id=callback.thread_id,
+                message_id=callback.message_id,
+                text=text,
+            )
         except Exception as exc:
             log_event(
                 self._logger,
@@ -393,6 +427,7 @@ class TelegramMessageTransport:
                 "telegram.answer_callback.failed",
                 chat_id=callback.chat_id,
                 thread_id=callback.thread_id,
+                message_id=callback.message_id,
                 callback_id=callback.callback_id,
                 exc=exc,
             )

codex_autorunner/integrations/telegram/trigger_mode.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from .adapter import TelegramMessage
+
+TriggerMode = Literal["all", "mentions"]
+
+
+def should_trigger_run(
+    message: TelegramMessage,
+    *,
+    text: str,
+    bot_username: Optional[str],
+) -> bool:
+    """Return True if this message should start a run in mentions-only mode.
+
+    This mirrors Takopi's "mentions" trigger mode semantics (subset):
+
+    - Always trigger in private chats.
+    - Trigger when the bot is explicitly mentioned: "@<bot_username>" anywhere in the text.
+    - Trigger when replying to a bot message (but ignore the common forum-topic
+      "implicit root reply" case where clients set reply_to_message_id == thread_id).
+    - Otherwise, do not trigger (commands and other explicit affordances are handled elsewhere).
+    """
+
+    if message.chat_type == "private":
+        return True
+
+    lowered = (text or "").lower()
+    if bot_username:
+        needle = f"@{bot_username}".lower()
+        if needle in lowered:
+            return True
+
+    implicit_topic_reply = (
+        message.thread_id is not None
+        and message.reply_to_message_id is not None
+        and message.reply_to_message_id == message.thread_id
+    )
+
+    if message.reply_to_is_bot and not implicit_topic_reply:
+        return True
+
+    if (
+        bot_username
+        and message.reply_to_username
+        and message.reply_to_username.lower() == bot_username.lower()
+        and not implicit_topic_reply
+    ):
+        return True
+
+    return False

codex_autorunner/manifest.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, List, Optional, cast
 import yaml
 
 MANIFEST_VERSION = 2
+MANIFEST_HEADER = "# GENERATED by CAR - DO NOT EDIT\n"
 _SAFE_REPO_ID_PATTERN = re.compile(r"^[A-Za-z0-9._-]+$")
 _SANITIZE_REPO_ID_PATTERN = re.compile(r"[^A-Za-z0-9._-]+")
 
@@ -194,4 +195,5 @@ def save_manifest(manifest_path: Path, manifest: Manifest, hub_root: Path) -> No
         "repos": [repo.to_dict(hub_root) for repo in manifest.repos],
     }
     with manifest_path.open("w", encoding="utf-8") as f:
+        f.write(MANIFEST_HEADER)
         yaml.safe_dump(payload, f, sort_keys=False)

codex_autorunner/plugin_api.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+"""Codex Autorunner plugin API metadata.
+
+This module is intentionally small and stable. External plugins SHOULD depend
+only on the public API in `codex_autorunner.api` + this version constant.
+
+Notes:
+- Backwards-incompatible changes to the plugin API MUST bump
+  `CAR_PLUGIN_API_VERSION`.
+"""
+
+CAR_PLUGIN_API_VERSION = 1
+
+# Entry point groups (Python packaging entry points).
+#
+# Plugins can publish new agent backends by defining an entry point:
+#
+#   [project.entry-points."codex_autorunner.agent_backends"]
+#   myagent = "my_package.my_module:AGENT_BACKEND"
+#
+CAR_AGENT_ENTRYPOINT_GROUP = "codex_autorunner.agent_backends"

codex_autorunner/routes/__init__.py

@@ -1,67 +1,37 @@
-"""
-Modular API routes for the codex-autorunner server.
-
-This package splits the monolithic api_routes.py into focused modules:
-- base: Index, state streaming, and general endpoints
-- agents: Agent harness models and event streaming
-- app_server: App-server thread registry endpoints
-- docs: Document management (read/write) and chat
-- github: GitHub integration endpoints
-- repos: Run control (start/stop/resume/reset)
-- runs: Run telemetry and artifacts
-- sessions: Terminal session registry endpoints
-- settings: Session settings for autorunner overrides
-- voice: Voice transcription and config
-- terminal_images: Terminal image uploads
-"""
-
-from pathlib import Path
-
-from fastapi import APIRouter
-
-from .agents import build_agents_routes
-from .app_server import build_app_server_routes
-from .base import build_base_routes
-from .docs import build_docs_routes
-from .github import build_github_routes
-from .repos import build_repos_routes
-from .review import build_review_routes
-from .runs import build_runs_routes
-from .sessions import build_sessions_routes
-from .settings import build_settings_routes
-from .system import build_system_routes
-from .terminal_images import build_terminal_image_routes
-from .voice import build_voice_routes
-
-
-def build_repo_router(static_dir: Path) -> APIRouter:
-    """
-    Build the complete API router by combining all route modules.
-
-    Args:
-        static_dir: Path to the static assets directory
-
-    Returns:
-        Combined APIRouter with all endpoints
-    """
-    router = APIRouter()
-
-    # Include all route modules
-    router.include_router(build_base_routes(static_dir))
-    router.include_router(build_agents_routes())
-    router.include_router(build_app_server_routes())
-    router.include_router(build_docs_routes())
-    router.include_router(build_github_routes())
-    router.include_router(build_repos_routes())
-    router.include_router(build_review_routes())
-    router.include_router(build_runs_routes())
-    router.include_router(build_sessions_routes())
-    router.include_router(build_settings_routes())
-    router.include_router(build_system_routes())
-    router.include_router(build_terminal_image_routes())
-    router.include_router(build_voice_routes())
-
-    return router
-
-
-__all__ = ["build_repo_router"]
+"""Backward-compatible route exports."""
+
+from . import (  # noqa: F401
+    analytics,
+    app_server,
+    base,
+    file_chat,
+    flows,
+    messages,
+    repos,
+    review,
+    sessions,
+    settings,
+    shared,
+    system,
+    usage,
+    voice,
+    workspace,
+)
+
+__all__ = [
+    "analytics",
+    "app_server",
+    "base",
+    "file_chat",
+    "flows",
+    "messages",
+    "repos",
+    "review",
+    "sessions",
+    "settings",
+    "shared",
+    "system",
+    "usage",
+    "voice",
+    "workspace",
+]

codex_autorunner/routes/agents.py

@@ -1,138 +1,3 @@
-"""
-Agent harness support routes (models + event streaming).
-"""
+"""Backward-compatible agent routes."""
 
-from __future__ import annotations
-
-from typing import Any, Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import StreamingResponse
-
-from ..agents.codex.harness import CodexHarness
-from ..agents.opencode.harness import OpenCodeHarness
-from ..agents.opencode.supervisor import OpenCodeSupervisorError
-from ..agents.types import ModelCatalog
-from .shared import SSE_HEADERS
-
-
-def _available_agents(request: Request) -> tuple[list[dict[str, str]], str]:
-    agents: list[dict[str, str]] = []
-    default_agent: Optional[str] = None
-
-    if getattr(request.app.state, "app_server_supervisor", None) is not None:
-        agents.append({"id": "codex", "name": "Codex", "protocol_version": "2.0"})
-        default_agent = "codex"
-
-    if getattr(request.app.state, "opencode_supervisor", None) is not None:
-        supervisor = getattr(request.app.state, "opencode_supervisor", None)
-        version = None
-        if supervisor and hasattr(supervisor, "_handles"):
-            handles = supervisor._handles
-            if handles:
-                first_handle = next(iter(handles.values()), None)
-                if first_handle:
-                    version = getattr(first_handle, "version", None)
-        agent_data = {"id": "opencode", "name": "OpenCode"}
-        if version:
-            agent_data["version"] = str(version)
-        agents.append(agent_data)
-        if default_agent is None:
-            default_agent = "opencode"
-
-    if not agents:
-        agents = [{"id": "codex", "name": "Codex", "protocol_version": "2.0"}]
-        default_agent = "codex"
-
-    return agents, default_agent or "codex"
-
-
-def _serialize_model_catalog(catalog: ModelCatalog) -> dict[str, Any]:
-    return {
-        "default_model": catalog.default_model,
-        "models": [
-            {
-                "id": model.id,
-                "display_name": model.display_name,
-                "supports_reasoning": model.supports_reasoning,
-                "reasoning_options": list(model.reasoning_options),
-            }
-            for model in catalog.models
-        ],
-    }
-
-
-def build_agents_routes() -> APIRouter:
-    router = APIRouter()
-
-    @router.get("/api/agents")
-    def list_agents(request: Request) -> dict[str, Any]:
-        agents, default_agent = _available_agents(request)
-        return {"agents": agents, "default": default_agent}
-
-    @router.get("/api/agents/{agent}/models")
-    async def list_agent_models(agent: str, request: Request):
-        agent_id = (agent or "").strip().lower()
-        engine = request.app.state.engine
-        if agent_id == "codex":
-            supervisor = request.app.state.app_server_supervisor
-            events = request.app.state.app_server_events
-            if supervisor is None:
-                raise HTTPException(status_code=404, detail="Codex harness unavailable")
-            codex_harness = CodexHarness(supervisor, events)
-            catalog = await codex_harness.model_catalog(engine.repo_root)
-            return _serialize_model_catalog(catalog)
-        if agent_id == "opencode":
-            supervisor = getattr(request.app.state, "opencode_supervisor", None)
-            if supervisor is None:
-                raise HTTPException(
-                    status_code=404, detail="OpenCode harness unavailable"
-                )
-            try:
-                opencode_harness = OpenCodeHarness(supervisor)
-                catalog = await opencode_harness.model_catalog(engine.repo_root)
-                return _serialize_model_catalog(catalog)
-            except OpenCodeSupervisorError as exc:
-                raise HTTPException(status_code=502, detail=str(exc)) from exc
-            except Exception as exc:
-                raise HTTPException(status_code=502, detail=str(exc)) from exc
-        raise HTTPException(status_code=404, detail="Unknown agent")
-
-    @router.get("/api/agents/{agent}/turns/{turn_id}/events")
-    async def stream_agent_turn_events(
-        agent: str, turn_id: str, request: Request, thread_id: Optional[str] = None
-    ):
-        agent_id = (agent or "").strip().lower()
-        if agent_id == "codex":
-            events = getattr(request.app.state, "app_server_events", None)
-            if events is None:
-                raise HTTPException(status_code=404, detail="Codex events unavailable")
-            if not thread_id:
-                raise HTTPException(status_code=400, detail="thread_id is required")
-            return StreamingResponse(
-                events.stream(thread_id, turn_id),
-                media_type="text/event-stream",
-                headers=SSE_HEADERS,
-            )
-        if agent_id == "opencode":
-            if not thread_id:
-                raise HTTPException(status_code=400, detail="thread_id is required")
-            supervisor = getattr(request.app.state, "opencode_supervisor", None)
-            if supervisor is None:
-                raise HTTPException(
-                    status_code=404, detail="OpenCode events unavailable"
-                )
-            harness = OpenCodeHarness(supervisor)
-            return StreamingResponse(
-                harness.stream_events(
-                    request.app.state.engine.repo_root, thread_id, turn_id
-                ),
-                media_type="text/event-stream",
-                headers=SSE_HEADERS,
-            )
-        raise HTTPException(status_code=404, detail="Unknown agent")
-
-    return router
-
-
-__all__ = ["build_agents_routes"]
+from ..surfaces.web.routes.agents import *  # noqa: F401,F403

codex_autorunner/routes/analytics.py

@@ -0,0 +1,3 @@
+"""Backward-compatible analytics routes."""
+
+from ..surfaces.web.routes.analytics import *  # noqa: F401,F403

codex_autorunner/routes/app_server.py

@@ -1,132 +1,3 @@
-"""
-App-server support routes (thread registry).
-"""
+"""Backward-compatible app-server routes."""
 
-from pathlib import Path
-
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import FileResponse, StreamingResponse
-
-from ..core.app_server_threads import normalize_feature_key
-from ..core.utils import is_within
-from ..integrations.app_server.client import CodexAppServerError
-from ..web.schemas import (
-    AppServerThreadArchiveRequest,
-    AppServerThreadArchiveResponse,
-    AppServerThreadResetAllResponse,
-    AppServerThreadResetRequest,
-    AppServerThreadResetResponse,
-    AppServerThreadsResponse,
-)
-from .shared import SSE_HEADERS
-
-
-def build_app_server_routes() -> APIRouter:
-    router = APIRouter()
-
-    @router.get("/api/app-server/turns/{turn_id}/events")
-    async def stream_app_server_turn_events(
-        turn_id: str, request: Request, thread_id: str
-    ):
-        events = getattr(request.app.state, "app_server_events", None)
-        if events is None:
-            raise HTTPException(status_code=404, detail="App-server events unavailable")
-        if not thread_id:
-            raise HTTPException(status_code=400, detail="thread_id is required")
-        return StreamingResponse(
-            events.stream(thread_id, turn_id),
-            media_type="text/event-stream",
-            headers=SSE_HEADERS,
-        )
-
-    @router.get("/api/app-server/threads", response_model=AppServerThreadsResponse)
-    def app_server_threads(request: Request):
-        registry = request.app.state.app_server_threads
-        return registry.feature_map()
-
-    @router.get("/api/app-server/models")
-    async def app_server_models(request: Request):
-        engine = request.app.state.engine
-        supervisor = request.app.state.app_server_supervisor
-        try:
-            client = await supervisor.get_client(engine.repo_root)
-            return await client.model_list()
-        except CodexAppServerError as exc:
-            raise HTTPException(status_code=502, detail=str(exc)) from exc
-
-    @router.post(
-        "/api/app-server/threads/reset", response_model=AppServerThreadResetResponse
-    )
-    def reset_app_server_thread(request: Request, payload: AppServerThreadResetRequest):
-        registry = request.app.state.app_server_threads
-        try:
-            key = normalize_feature_key(payload.key)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-        cleared = registry.reset_thread(key)
-        return {"status": "ok", "key": key, "cleared": cleared}
-
-    @router.post(
-        "/api/app-server/threads/archive",
-        response_model=AppServerThreadArchiveResponse,
-    )
-    async def archive_app_server_thread(
-        request: Request, payload: AppServerThreadArchiveRequest
-    ):
-        thread_id = payload.thread_id.strip()
-        if not thread_id:
-            raise HTTPException(status_code=400, detail="thread_id is required")
-        engine = request.app.state.engine
-        supervisor = request.app.state.app_server_supervisor
-        try:
-            client = await supervisor.get_client(engine.repo_root)
-            await client.thread_archive(thread_id)
-        except CodexAppServerError as exc:
-            raise HTTPException(status_code=502, detail=str(exc)) from exc
-        return {"status": "ok", "thread_id": thread_id, "archived": True}
-
-    @router.post(
-        "/api/app-server/threads/reset-all",
-        response_model=AppServerThreadResetAllResponse,
-    )
-    def reset_app_server_threads(request: Request):
-        registry = request.app.state.app_server_threads
-        registry.reset_all()
-        return {"status": "ok", "cleared": True}
-
-    @router.get("/api/app-server/threads/backup")
-    def download_app_server_threads_backup(request: Request):
-        registry = request.app.state.app_server_threads
-        notice = registry.corruption_notice() or {}
-        backup_path = notice.get("backup_path")
-        if not isinstance(backup_path, str) or not backup_path:
-            raise HTTPException(status_code=404, detail="No backup available")
-        path = Path(backup_path)
-        engine = request.app.state.engine
-        if not is_within(engine.repo_root, path):
-            raise HTTPException(status_code=400, detail="Invalid backup path")
-        if not path.exists():
-            raise HTTPException(status_code=404, detail="Backup not found")
-        return FileResponse(path, filename=path.name)
-
-    @router.get("/api/app-server/account")
-    async def app_server_account(request: Request):
-        engine = request.app.state.engine
-        supervisor = request.app.state.app_server_supervisor
-        try:
-            client = await supervisor.get_client(engine.repo_root)
-            return await client.account_read()
-        except CodexAppServerError as exc:
-            raise HTTPException(status_code=502, detail=str(exc)) from exc
-
-    @router.get("/api/app-server/rate-limits")
-    async def app_server_rate_limits(request: Request):
-        engine = request.app.state.engine
-        supervisor = request.app.state.app_server_supervisor
-        try:
-            client = await supervisor.get_client(engine.repo_root)
-            return await client.rate_limits_read()
-        except CodexAppServerError as exc:
-            raise HTTPException(status_code=502, detail=str(exc)) from exc
-
-    return router
+from ..surfaces.web.routes.app_server import *  # noqa: F401,F403