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

codex_autorunner/integrations/templates/scan_agent.py

@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import dataclasses
+import json
+from datetime import datetime, timezone
+from typing import Any, Iterable, Optional
+
+from ...core.config import RepoConfig, load_hub_config
+from ...core.ports.backend_orchestrator import BackendOrchestrator
+from ...core.ports.run_event import Completed, Failed, OutputDelta, RunEvent
+from ...core.prompts import TEMPLATE_SCAN_PROMPT
+from ...core.templates import FetchedTemplate, TemplateScanRecord, write_scan_record
+
+_FORMAT_ERROR_HINT = (
+    "FORMAT ERROR: Output must be EXACTLY ONE LINE of JSON in the specified schema. "
+    "Do not include markdown, code fences, or extra text."
+)
+
+_APPROVE_TOOL = "template_scan_approve"
+_REJECT_TOOL = "template_scan_reject"
+_ALLOWED_TOOLS = {_APPROVE_TOOL, _REJECT_TOOL}
+_APPROVE_SEVERITIES = {"low", "medium"}
+_REJECT_SEVERITIES = {"high"}
+
+
+class TemplateScanError(RuntimeError):
+    pass
+
+
+class TemplateScanFormatError(TemplateScanError):
+    pass
+
+
+class TemplateScanRejectedError(TemplateScanError):
+    def __init__(self, record: TemplateScanRecord, message: str) -> None:
+        super().__init__(message)
+        self.record = record
+
+
+class TemplateScanBackendError(TemplateScanError):
+    pass
+
+
+@dataclasses.dataclass(frozen=True)
+class TemplateScanDecision:
+    tool: str
+    blob_sha: str
+    severity: str
+    reason: str
+    evidence: Optional[list[str]]
+
+
+def build_template_scan_prompt(template: FetchedTemplate) -> str:
+    prompt = TEMPLATE_SCAN_PROMPT
+    replacements = {
+        "repo_id": template.repo_id,
+        "repo_url": template.url,
+        "trusted_repo": str(template.trusted),
+        "path": template.path,
+        "ref": template.ref,
+        "commit_sha": template.commit_sha,
+        "blob_sha": template.blob_sha,
+        "template_content": template.content,
+    }
+    for key, value in replacements.items():
+        prompt = prompt.replace(f"{{{{{key}}}}}", str(value))
+    return prompt
+
+
+def _extract_output_text(events: Iterable[RunEvent]) -> str:
+    deltas: list[str] = []
+    final_message: Optional[str] = None
+    for event in events:
+        if isinstance(event, Completed):
+            final_message = event.final_message
+            continue
+        if isinstance(event, OutputDelta) and event.delta_type in {
+            "assistant_message",
+            "assistant_stream",
+        }:
+            if event.content:
+                deltas.append(event.content)
+    if final_message:
+        return final_message
+    if deltas:
+        return "".join(deltas)
+    return ""
+
+
+def _normalize_line(text: str) -> str:
+    line = text.strip()
+    if "\n" in line or "\r" in line:
+        raise TemplateScanFormatError("Output must be a single line")
+    return line
+
+
+def _parse_json_line(text: str) -> dict[str, Any]:
+    try:
+        payload = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise TemplateScanFormatError(f"Invalid JSON: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise TemplateScanFormatError("Output JSON must be an object")
+    return payload
+
+
+def _coerce_evidence(value: Any) -> Optional[list[str]]:
+    if value is None or value == []:
+        return None
+    if isinstance(value, list):
+        evidence = [str(item) for item in value][:3]
+        return evidence or None
+    return [str(value)]
+
+
+def parse_template_scan_output(
+    raw: str, *, expected_blob_sha: str
+) -> TemplateScanDecision:
+    line = _normalize_line(raw)
+    if not line:
+        raise TemplateScanFormatError("Empty output from scan agent")
+
+    payload = _parse_json_line(line)
+    tool = payload.get("tool")
+    blob_sha = payload.get("blob_sha")
+    severity = payload.get("severity")
+    reason = payload.get("reason")
+    evidence = _coerce_evidence(payload.get("evidence"))
+
+    if tool not in _ALLOWED_TOOLS:
+        raise TemplateScanFormatError("Missing or invalid tool field")
+    if not isinstance(blob_sha, str) or not blob_sha:
+        raise TemplateScanFormatError("Missing blob_sha field")
+    if blob_sha != expected_blob_sha:
+        raise TemplateScanFormatError("blob_sha mismatch")
+    if not isinstance(severity, str) or not severity:
+        raise TemplateScanFormatError("Missing severity field")
+    if not isinstance(reason, str) or not reason:
+        raise TemplateScanFormatError("Missing reason field")
+
+    if tool == _APPROVE_TOOL and severity not in _APPROVE_SEVERITIES:
+        raise TemplateScanFormatError("Invalid severity for approve decision")
+    if tool == _REJECT_TOOL and severity not in _REJECT_SEVERITIES:
+        raise TemplateScanFormatError("Invalid severity for reject decision")
+
+    return TemplateScanDecision(
+        tool=tool,
+        blob_sha=blob_sha,
+        severity=severity,
+        reason=reason,
+        evidence=evidence,
+    )
+
+
+def _decision_to_record(
+    template: FetchedTemplate,
+    decision: TemplateScanDecision,
+    *,
+    scanner: Optional[dict[str, str]] = None,
+) -> TemplateScanRecord:
+    scanned_at = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+    return TemplateScanRecord(
+        blob_sha=template.blob_sha,
+        repo_id=template.repo_id,
+        path=template.path,
+        ref=template.ref,
+        commit_sha=template.commit_sha,
+        trusted=template.trusted,
+        decision="approve" if decision.tool == _APPROVE_TOOL else "reject",
+        severity=decision.severity,
+        reason=decision.reason,
+        evidence=decision.evidence,
+        scanned_at=scanned_at,
+        scanner=scanner,
+    )
+
+
+def _scanner_metadata(config: Optional[RepoConfig]) -> Optional[dict[str, str]]:
+    if config is None:
+        return None
+    model = config.codex_model or ""
+    reasoning = config.codex_reasoning or ""
+    metadata: dict[str, str] = {"agent": "codex"}
+    if model:
+        metadata["model"] = model
+    if reasoning:
+        metadata["reasoning"] = reasoning
+    return metadata or None
+
+
+def format_template_scan_rejection(record: TemplateScanRecord) -> str:
+    lines = [
+        "Template scan rejected this template.",
+        f"repo_id={record.repo_id}",
+        f"path={record.path}",
+        f"ref={record.ref}",
+        f"commit_sha={record.commit_sha}",
+        f"blob_sha={record.blob_sha}",
+        f"reason={record.reason}",
+        "Pause and notify the user; do not continue with this template.",
+    ]
+    if record.evidence:
+        lines.append("evidence:")
+        lines.extend([f"- {item}" for item in record.evidence])
+    return "\n".join(lines)
+
+
+async def run_template_scan_with_orchestrator(
+    *,
+    config: RepoConfig,
+    backend_orchestrator: BackendOrchestrator,
+    template: FetchedTemplate,
+    hub_root: Any,
+    max_attempts: int = 2,
+) -> TemplateScanRecord:
+    if max_attempts < 1:
+        raise ValueError("max_attempts must be >= 1")
+
+    prompt = build_template_scan_prompt(template)
+    state = _build_scan_state()
+    scanner = _scanner_metadata(config)
+    last_error: Optional[str] = None
+
+    for attempt in range(max_attempts):
+        if attempt > 0:
+            prompt = f"{_FORMAT_ERROR_HINT}\n\n{prompt}"
+        events: list[RunEvent] = []
+        try:
+            async for event in backend_orchestrator.run_turn(
+                agent_id="codex",
+                state=state,
+                prompt=prompt,
+                model=config.codex_model,
+                reasoning=config.codex_reasoning,
+                session_key=f"template_scan:{template.blob_sha}:{attempt}",
+            ):
+                events.append(event)
+        except Exception as exc:
+            raise TemplateScanBackendError(str(exc)) from exc
+
+        for event in events:
+            if isinstance(event, Failed):
+                raise TemplateScanBackendError(event.error_message)
+
+        output = _extract_output_text(events)
+        if not output:
+            last_error = "Empty scan output"
+            continue
+        try:
+            decision = parse_template_scan_output(
+                output, expected_blob_sha=template.blob_sha
+            )
+        except TemplateScanFormatError as exc:
+            last_error = str(exc)
+            continue
+
+        record = _decision_to_record(template, decision, scanner=scanner)
+        write_scan_record(record, hub_root)
+        if record.decision == "reject":
+            raise TemplateScanRejectedError(
+                record, format_template_scan_rejection(record)
+            )
+        return record
+
+    raise TemplateScanFormatError(last_error or "Scan output failed validation")
+
+
+async def run_template_scan(
+    *,
+    ctx: Any,
+    template: FetchedTemplate,
+    max_attempts: int = 2,
+) -> TemplateScanRecord:
+    backend_orchestrator = getattr(ctx, "_backend_orchestrator", None)
+    if backend_orchestrator is None:
+        raise TemplateScanBackendError(
+            "Template scanning requires a backend orchestrator; configure Codex or OpenCode."
+        )
+
+    config = ctx.config
+    try:
+        hub_root = load_hub_config(config.root).root
+    except Exception:
+        hub_root = getattr(config, "root", None)
+    if hub_root is None:
+        raise TemplateScanBackendError("Missing hub root for scan cache writes")
+
+    return await run_template_scan_with_orchestrator(
+        config=config,
+        backend_orchestrator=backend_orchestrator,
+        template=template,
+        hub_root=hub_root,
+        max_attempts=max_attempts,
+    )
+
+
+def _build_scan_state() -> Any:
+    from ...core.state import RunnerState
+
+    return RunnerState(
+        last_run_id=None,
+        status="running",
+        last_exit_code=None,
+        last_run_started_at=None,
+        last_run_finished_at=None,
+        autorunner_agent_override="codex",
+        autorunner_model_override=None,
+        autorunner_effort_override=None,
+        autorunner_approval_policy="never",
+        autorunner_sandbox_mode="readOnly",
+        autorunner_workspace_write_network=False,
+    )

codex_autorunner/routes/__init__.py

@@ -1,76 +1,37 @@
-"""
-Modular API routes for the codex-autorunner server.
-
-This package splits monolithic api_routes.py into focused modules:
-- base: Index, WebSocket terminal, and general endpoints
-- agents: Agent harness models and event streaming
-- app_server: App-server thread registry endpoints
-- workspace: Optional workspace docs (active_context/decisions/spec)
-- flows: Flow runtime management (start/stop/resume/status/events/artifacts)
-- messages: Inbox/message wrappers over ticket_flow dispatch + reply histories
-- repos: Run control (start/stop/resume/reset)
-- sessions: Terminal session registry endpoints
-- settings: Session settings for autorunner overrides
-- file_chat: Unified file chat (tickets + workspace docs)
-- 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 .analytics import build_analytics_routes
-from .app_server import build_app_server_routes
-from .base import build_base_routes, build_frontend_routes
-from .file_chat import build_file_chat_routes
-from .flows import build_flow_routes
-from .messages import build_messages_routes
-from .repos import build_repos_routes
-from .review import build_review_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 .usage import build_usage_routes
-from .voice import build_voice_routes
-from .workspace import build_workspace_routes
-
-
-def build_repo_router(static_dir: Path) -> APIRouter:
-    """
-    Build complete API router by combining all route modules.
-
-    Args:
-        static_dir: Path to 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_analytics_routes())
-    router.include_router(build_agents_routes())
-    router.include_router(build_app_server_routes())
-    router.include_router(build_workspace_routes())
-    router.include_router(build_flow_routes())
-    router.include_router(build_file_chat_routes())
-    router.include_router(build_messages_routes())
-    router.include_router(build_repos_routes())
-    router.include_router(build_review_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_usage_routes())
-    router.include_router(build_voice_routes())
-    # Include frontend routes last to avoid shadowing API routes
-    router.include_router(build_frontend_routes(static_dir))
-
-    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