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

codex_autorunner/integrations/telegram/ticket_flow_bridge.py

@@ -6,6 +6,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Awaitable, Callable, Optional
 
+from ...core.config import load_repo_config
 from ...core.flows import FlowStore
 from ...core.flows.controller import FlowController
 from ...core.flows.models import FlowRunRecord, FlowRunStatus
@@ -241,7 +242,8 @@ class TelegramTicketFlowBridge:
         db_path = workspace_root / ".codex-autorunner" / "flows.db"
         if not db_path.exists():
             return None
-        store = FlowStore(db_path)
+        config = load_repo_config(workspace_root)
+        store = FlowStore(db_path, durable=config.durable_writes)
         try:
             store.initialize()
             runs = store.list_flow_runs(
@@ -305,7 +307,8 @@ class TelegramTicketFlowBridge:
         db_path = workspace_root / ".codex-autorunner" / "flows.db"
         if not db_path.exists():
             return None
-        store = FlowStore(db_path)
+        config = load_repo_config(workspace_root)
+        store = FlowStore(db_path, durable=config.durable_writes)
         try:
             store.initialize()
             if preferred_run_id:
@@ -573,16 +576,19 @@ def _ticket_controller_for(repo_root: Path) -> FlowController:
     artifacts_root = repo_root / ".codex-autorunner" / "flows"
     from ...agents.registry import validate_agent_id
     from ...core.config import load_repo_config
-    from ...core.engine import Engine
+    from ...core.runtime import RuntimeContext
+    from ...integrations.agents import build_backend_orchestrator
     from ...integrations.agents.wiring import (
         build_agent_backend_factory,
         build_app_server_supervisor_factory,
     )
 
     config = load_repo_config(repo_root)
-    engine = Engine(
+    backend_orchestrator = build_backend_orchestrator(repo_root, config)
+    engine = RuntimeContext(
         repo_root,
         config=config,
+        backend_orchestrator=backend_orchestrator,
         backend_factory=build_agent_backend_factory(repo_root, config),
         app_server_supervisor_factory=build_app_server_supervisor_factory(config),
         agent_id_validator=validate_agent_id,

codex_autorunner/integrations/telegram/transport.py

@@ -265,6 +265,7 @@ class TelegramMessageTransport:
         thread_id: Optional[int] = None,
         reply_to: Optional[int] = None,
         reply_markup: Optional[dict[str, Any]] = None,
+        parse_mode: Optional[str] = None,
     ) -> None:
         if _should_trace_message(text):
             text = _with_conversation_id(
@@ -279,9 +280,15 @@ class TelegramMessageTransport:
         )
         if prefix:
             text = f"{prefix}{text}"
-        parse_mode = self._config.parse_mode
-        if parse_mode:
-            rendered, used_mode = self._render_message(text)
+        effective_parse_mode = parse_mode or self._config.parse_mode
+        if effective_parse_mode:
+            try:
+                rendered, used_mode = self._render_message(
+                    text, parse_mode=effective_parse_mode
+                )
+            except TypeError:
+                # Back-compat for subclasses/tests that don't accept parse_mode kwarg
+                rendered, used_mode = self._render_message(text)  # type: ignore[misc]
             if used_mode and len(rendered) > TELEGRAM_MAX_MESSAGE_LENGTH:
                 overflow_mode = getattr(self._config, "message_overflow", "document")
                 if overflow_mode == "split" and used_mode in (

codex_autorunner/integrations/templates/__init__.py

@@ -0,0 +1,27 @@
+"""Template integration helpers."""
+
+from .scan_agent import (
+    TemplateScanBackendError,
+    TemplateScanDecision,
+    TemplateScanError,
+    TemplateScanFormatError,
+    TemplateScanRejectedError,
+    build_template_scan_prompt,
+    format_template_scan_rejection,
+    parse_template_scan_output,
+    run_template_scan,
+    run_template_scan_with_orchestrator,
+)
+
+__all__ = [
+    "TemplateScanBackendError",
+    "TemplateScanDecision",
+    "TemplateScanError",
+    "TemplateScanFormatError",
+    "TemplateScanRejectedError",
+    "build_template_scan_prompt",
+    "format_template_scan_rejection",
+    "parse_template_scan_output",
+    "run_template_scan",
+    "run_template_scan_with_orchestrator",
+]

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/server.py

@@ -1,12 +1,12 @@
 from importlib import resources
 
-from .core.engine import Engine, LockError, clear_stale_lock, doctor
+from .core.runtime import LockError, RuntimeContext, clear_stale_lock, doctor
 from .surfaces.web.app import create_app, create_hub_app, create_repo_app
 from .surfaces.web.middleware import BasePathRouterMiddleware
 
 __all__ = [
-    "Engine",
     "LockError",
+    "RuntimeContext",
     "BasePathRouterMiddleware",
     "clear_stale_lock",
     "create_app",

codex_autorunner/static/agentControls.js

@@ -1,10 +1,13 @@
 // GENERATED FILE - do not edit directly. Source: static_src/
 import { api, flash } from "./utils.js";
 import { createSmartRefresh } from "./smartRefresh.js";
+import { REPO_ID } from "./env.js";
+const API_PREFIX = REPO_ID ? "/api" : "/hub/pma";
+const STORAGE_PREFIX = REPO_ID ? "car.agent" : "car.pma.agent";
 const STORAGE_KEYS = {
-    selected: "car.agent.selected",
-    model: (agent) => `car.agent.${agent}.model`,
-    reasoning: (agent) => `car.agent.${agent}.reasoning`,
+    selected: `${STORAGE_PREFIX}.selected`,
+    model: (agent) => `${STORAGE_PREFIX}.${agent}.model`,
+    reasoning: (agent) => `${STORAGE_PREFIX}.${agent}.reasoning`,
 };
 const FALLBACK_AGENTS = [
     { id: "codex", name: "Codex" },
@@ -92,7 +95,7 @@ async function loadAgents() {
     }
     agentsLoadPromise = (async () => {
         try {
-            const data = await api("/api/agents", { method: "GET" });
+            const data = await api(`${API_PREFIX}/agents`, { method: "GET" });
             const agents = Array.isArray(data?.agents) ? data.agents : [];
             // Only use API response if it contains valid agents
             if (agents.length > 0 && agents.every((a) => a && typeof a.id === "string")) {
@@ -152,7 +155,7 @@ async function loadModelCatalog(agent) {
     if (modelCatalogPromises.has(agent)) {
         return await modelCatalogPromises.get(agent) || null;
     }
-    const promise = api(`/api/agents/${encodeURIComponent(agent)}/models`, {
+    const promise = api(`${API_PREFIX}/agents/${encodeURIComponent(agent)}/models`, {
         method: "GET",
     })
         .then((data) => {
@@ -379,3 +382,16 @@ export function initAgentControls(config = {}) {
 export async function ensureAgentCatalog() {
     await refreshAgentControls({ force: true, reason: "manual" });
 }
+export function clearAgentSelectionStorage() {
+    if (REPO_ID)
+        return;
+    safeSetStorage(STORAGE_KEYS.selected, "");
+    const candidates = new Set([
+        ...agentList.map((agent) => agent.id),
+        ...FALLBACK_AGENTS.map((agent) => agent.id),
+    ]);
+    candidates.forEach((agentId) => {
+        safeSetStorage(STORAGE_KEYS.model(agentId), "");
+        safeSetStorage(STORAGE_KEYS.reasoning(agentId), "");
+    });
+}

codex_autorunner/static/app.js

@@ -8,12 +8,115 @@ import { initMessages, initMessageBell } from "./messages.js";
 import { initMobileCompact } from "./mobileCompact.js";
 import { subscribe } from "./bus.js";
 import { initRepoSettingsPanel, openRepoSettings } from "./settings.js";
-import { flash } from "./utils.js";
+import { flash, getAuthToken, repairModalBackgroundIfStuck, resolvePath, updateUrlParams, } from "./utils.js";
 import { initLiveUpdates } from "./liveUpdates.js";
 import { initHealthGate } from "./health.js";
 import { initWorkspace } from "./workspace.js";
 import { initDashboard } from "./dashboard.js";
 import { initArchive } from "./archive.js";
+import { initPMA } from "./pma.js";
+import { initNotifications } from "./notifications.js";
+let pmaInitialized = false;
+async function initPMAView() {
+    if (!pmaInitialized) {
+        await initPMA();
+        pmaInitialized = true;
+    }
+}
+function showHubView() {
+    const hubShell = document.getElementById("hub-shell");
+    const pmaShell = document.getElementById("pma-shell");
+    if (hubShell)
+        hubShell.classList.remove("hidden");
+    if (pmaShell)
+        pmaShell.classList.add("hidden");
+    updateModeToggle("manual");
+    updateUrlParams({ view: null });
+}
+function showPMAView() {
+    const hubShell = document.getElementById("hub-shell");
+    const pmaShell = document.getElementById("pma-shell");
+    if (hubShell)
+        hubShell.classList.add("hidden");
+    if (pmaShell)
+        pmaShell.classList.remove("hidden");
+    updateModeToggle("pma");
+    void initPMAView();
+    updateUrlParams({ view: "pma" });
+}
+function updateModeToggle(mode) {
+    const manualBtns = document.querySelectorAll('[data-hub-mode="manual"]');
+    const pmaBtns = document.querySelectorAll('[data-hub-mode="pma"]');
+    manualBtns.forEach((btn) => {
+        const active = mode === "manual";
+        btn.classList.toggle("active", active);
+        btn.setAttribute("aria-selected", active ? "true" : "false");
+    });
+    pmaBtns.forEach((btn) => {
+        const active = mode === "pma";
+        btn.classList.toggle("active", active);
+        btn.setAttribute("aria-selected", active ? "true" : "false");
+    });
+}
+async function probePMAEnabled() {
+    const headers = {};
+    const token = getAuthToken();
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    try {
+        const res = await fetch(resolvePath("/hub/pma/agents"), {
+            method: "GET",
+            headers,
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function initHubShell() {
+    const hubShell = document.getElementById("hub-shell");
+    const repoShell = document.getElementById("repo-shell");
+    const manualBtns = Array.from(document.querySelectorAll('[data-hub-mode="manual"]'));
+    const pmaBtns = Array.from(document.querySelectorAll('[data-hub-mode="pma"]'));
+    if (hubShell)
+        hubShell.classList.remove("hidden");
+    if (repoShell)
+        repoShell.classList.add("hidden");
+    initHub();
+    initNotifications();
+    manualBtns.forEach((btn) => {
+        btn.addEventListener("click", () => {
+            showHubView();
+        });
+    });
+    pmaBtns.forEach((btn) => {
+        btn.addEventListener("click", () => {
+            showPMAView();
+        });
+    });
+    const urlParams = new URLSearchParams(window.location.search);
+    const requestedPMA = urlParams.get("view") === "pma";
+    const pmaEnabled = await probePMAEnabled();
+    if (!pmaEnabled) {
+        pmaBtns.forEach((btn) => {
+            btn.disabled = true;
+            btn.setAttribute("aria-disabled", "true");
+            btn.title = "Enable PMA in config to use Project Manager";
+            btn.classList.add("hidden");
+            btn.classList.remove("active");
+            btn.setAttribute("aria-selected", "false");
+        });
+        if (requestedPMA) {
+            showHubView();
+        }
+        return;
+    }
+    if (requestedPMA) {
+        showPMAView();
+    }
+}
 async function initRepoShell() {
     await initHealthGate();
     if (REPO_ID) {
@@ -88,22 +191,23 @@ async function initRepoShell() {
     if (repoShell?.hasAttribute("inert")) {
         const openModals = document.querySelectorAll(".modal-overlay:not([hidden])");
         const count = openModals.length;
-        flash(count
-            ? `UI inert: ${count} modal${count === 1 ? "" : "s"} open`
-            : "UI inert but no modal is visible", "error");
+        if (!count && repairModalBackgroundIfStuck()) {
+            flash("Recovered from stuck modal state (UI was inert).", "info");
+        }
+        else {
+            flash(count
+                ? `UI inert: ${count} modal${count === 1 ? "" : "s"} open`
+                : "UI inert but no modal is visible", "error");
+        }
     }
 }
 function bootstrap() {
-    const hubShell = document.getElementById("hub-shell");
-    const repoShell = document.getElementById("repo-shell");
     if (!REPO_ID) {
-        if (hubShell)
-            hubShell.classList.remove("hidden");
-        if (repoShell)
-            repoShell.classList.add("hidden");
-        initHub();
+        void initHubShell();
         return;
     }
+    const hubShell = document.getElementById("hub-shell");
+    const repoShell = document.getElementById("repo-shell");
     if (repoShell)
         repoShell.classList.remove("hidden");
     if (hubShell)