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

codex_autorunner/agents/__init__.py

@@ -0,0 +1,21 @@
+"""Agent harness abstractions."""
+
+from .registry import (
+    AgentCapability,
+    AgentDescriptor,
+    get_agent_descriptor,
+    get_available_agents,
+    get_registered_agents,
+    has_capability,
+    validate_agent_id,
+)
+
+__all__ = [
+    "AgentCapability",
+    "AgentDescriptor",
+    "get_registered_agents",
+    "get_available_agents",
+    "get_agent_descriptor",
+    "validate_agent_id",
+    "has_capability",
+]

codex_autorunner/agents/base.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, AsyncIterator, Optional, Protocol
+
+from .types import AgentId, ConversationRef, ModelCatalog, TurnRef
+
+
+class AgentHarness(Protocol):
+    agent_id: AgentId
+    display_name: str
+
+    async def ensure_ready(self, workspace_root: Path) -> None: ...
+
+    async def model_catalog(self, workspace_root: Path) -> ModelCatalog: ...
+
+    async def new_conversation(
+        self, workspace_root: Path, title: Optional[str] = None
+    ) -> ConversationRef: ...
+
+    async def list_conversations(
+        self, workspace_root: Path
+    ) -> list[ConversationRef]: ...
+
+    async def resume_conversation(
+        self, workspace_root: Path, conversation_id: str
+    ) -> ConversationRef: ...
+
+    async def start_turn(
+        self,
+        workspace_root: Path,
+        conversation_id: str,
+        prompt: str,
+        model: Optional[str],
+        reasoning: Optional[str],
+        *,
+        approval_mode: Optional[str],
+        sandbox_policy: Optional[Any],
+    ) -> TurnRef: ...
+
+    async def start_review(
+        self,
+        workspace_root: Path,
+        conversation_id: str,
+        prompt: str,
+        model: Optional[str],
+        reasoning: Optional[str],
+        *,
+        approval_mode: Optional[str],
+        sandbox_policy: Optional[Any],
+    ) -> TurnRef: ...
+
+    async def interrupt(
+        self, workspace_root: Path, conversation_id: str, turn_id: Optional[str]
+    ) -> None: ...
+
+    def stream_events(
+        self, workspace_root: Path, conversation_id: str, turn_id: str
+    ) -> AsyncIterator[str]: ...
+
+
+__all__ = ["AgentHarness"]

codex_autorunner/agents/codex/__init__.py

@@ -0,0 +1,5 @@
+"""Codex harness adapter."""
+
+from .harness import CodexHarness
+
+__all__ = ["CodexHarness"]

codex_autorunner/agents/codex/harness.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, AsyncIterator, Optional
+
+from ...core.app_server_events import AppServerEventBuffer
+from ...integrations.app_server.supervisor import WorkspaceAppServerSupervisor
+from ..base import AgentHarness
+from ..types import AgentId, ConversationRef, ModelCatalog, ModelSpec, TurnRef
+
+_DEFAULT_REASONING_EFFORTS = ("none", "minimal", "low", "medium", "high", "xhigh")
+
+
+def _coerce_entries(result: Any, keys: tuple[str, ...]) -> list[dict[str, Any]]:
+    if isinstance(result, list):
+        return [entry for entry in result if isinstance(entry, dict)]
+    if isinstance(result, dict):
+        for key in keys:
+            value = result.get(key)
+            if isinstance(value, list):
+                return [entry for entry in value if isinstance(entry, dict)]
+    return []
+
+
+def _select_default_model(result: Any, entries: list[dict[str, Any]]) -> str:
+    if isinstance(result, dict):
+        for key in (
+            "defaultModel",
+            "default_model",
+            "default",
+            "model",
+            "modelId",
+            "model_id",
+        ):
+            value = result.get(key)
+            if isinstance(value, str) and value:
+                return value
+        config = result.get("config")
+        if isinstance(config, dict):
+            for key in ("defaultModel", "default_model", "model", "modelId"):
+                value = config.get(key)
+                if isinstance(value, str) and value:
+                    return value
+    for entry in entries:
+        if entry.get("default") or entry.get("isDefault"):
+            model_id = entry.get("model") or entry.get("id")
+            if isinstance(model_id, str) and model_id:
+                return model_id
+    for entry in entries:
+        model_id = entry.get("model") or entry.get("id")
+        if isinstance(model_id, str) and model_id:
+            return model_id
+    return ""
+
+
+def _coerce_reasoning_efforts(entry: dict[str, Any]) -> list[str]:
+    efforts_raw = entry.get("supportedReasoningEfforts")
+    efforts: list[str] = []
+    if isinstance(efforts_raw, list):
+        for effort in efforts_raw:
+            if isinstance(effort, dict):
+                value = effort.get("reasoningEffort")
+                if isinstance(value, str):
+                    efforts.append(value)
+            elif isinstance(effort, str):
+                efforts.append(effort)
+    default_effort = entry.get("defaultReasoningEffort")
+    if isinstance(default_effort, str) and default_effort:
+        efforts.append(default_effort)
+    if not efforts:
+        efforts = list(_DEFAULT_REASONING_EFFORTS)
+    return list(dict.fromkeys(efforts))
+
+
+class CodexHarness(AgentHarness):
+    agent_id: AgentId = AgentId("codex")
+    display_name = "Codex"
+
+    def __init__(
+        self,
+        supervisor: WorkspaceAppServerSupervisor,
+        events: AppServerEventBuffer,
+    ) -> None:
+        self._supervisor = supervisor
+        self._events = events
+
+    async def ensure_ready(self, workspace_root: Path) -> None:
+        await self._supervisor.get_client(workspace_root)
+
+    async def model_catalog(self, workspace_root: Path) -> ModelCatalog:
+        client = await self._supervisor.get_client(workspace_root)
+        result = await client.model_list()
+        entries = _coerce_entries(result, ("data", "models", "items", "results"))
+        models: list[ModelSpec] = []
+        for entry in entries:
+            model_id = entry.get("model") or entry.get("id")
+            if not isinstance(model_id, str) or not model_id:
+                continue
+            display_name = entry.get("displayName") or entry.get("name") or model_id
+            if not isinstance(display_name, str) or not display_name:
+                display_name = model_id
+            efforts = _coerce_reasoning_efforts(entry)
+            models.append(
+                ModelSpec(
+                    id=model_id,
+                    display_name=display_name,
+                    supports_reasoning=bool(efforts),
+                    reasoning_options=efforts,
+                )
+            )
+        default_model = _select_default_model(result, entries)
+        if not default_model and models:
+            default_model = models[0].id
+        return ModelCatalog(default_model=default_model, models=models)
+
+    async def new_conversation(
+        self, workspace_root: Path, title: Optional[str] = None
+    ) -> ConversationRef:
+        client = await self._supervisor.get_client(workspace_root)
+        result = await client.thread_start(str(workspace_root))
+        thread_id = result.get("id")
+        if not isinstance(thread_id, str) or not thread_id:
+            raise ValueError("Codex app-server did not return a thread id")
+        return ConversationRef(agent=self.agent_id, id=thread_id)
+
+    async def list_conversations(self, workspace_root: Path) -> list[ConversationRef]:
+        client = await self._supervisor.get_client(workspace_root)
+        result = await client.thread_list()
+        entries = _coerce_entries(result, ("threads", "data", "items", "results"))
+        conversations: list[ConversationRef] = []
+        for entry in entries:
+            thread_id = entry.get("id")
+            if isinstance(thread_id, str) and thread_id:
+                conversations.append(ConversationRef(agent=self.agent_id, id=thread_id))
+        return conversations
+
+    async def resume_conversation(
+        self, workspace_root: Path, conversation_id: str
+    ) -> ConversationRef:
+        client = await self._supervisor.get_client(workspace_root)
+        result = await client.thread_resume(conversation_id)
+        thread_id = result.get("id") or conversation_id
+        if not isinstance(thread_id, str) or not thread_id:
+            thread_id = conversation_id
+        return ConversationRef(agent=self.agent_id, id=thread_id)
+
+    async def start_turn(
+        self,
+        workspace_root: Path,
+        conversation_id: str,
+        prompt: str,
+        model: Optional[str],
+        reasoning: Optional[str],
+        *,
+        approval_mode: Optional[str],
+        sandbox_policy: Optional[Any],
+    ) -> TurnRef:
+        client = await self._supervisor.get_client(workspace_root)
+        turn_kwargs: dict[str, Any] = {}
+        if model:
+            turn_kwargs["model"] = model
+        if reasoning:
+            turn_kwargs["effort"] = reasoning
+        handle = await client.turn_start(
+            conversation_id,
+            prompt,
+            approval_policy=approval_mode,
+            sandbox_policy=sandbox_policy,
+            **turn_kwargs,
+        )
+        await self._events.register_turn(handle.thread_id, handle.turn_id)
+        return TurnRef(conversation_id=handle.thread_id, turn_id=handle.turn_id)
+
+    async def start_review(
+        self,
+        workspace_root: Path,
+        conversation_id: str,
+        prompt: str,
+        model: Optional[str],
+        reasoning: Optional[str],
+        *,
+        approval_mode: Optional[str],
+        sandbox_policy: Optional[Any],
+    ) -> TurnRef:
+        client = await self._supervisor.get_client(workspace_root)
+        review_kwargs: dict[str, Any] = {}
+        if model:
+            review_kwargs["model"] = model
+        if reasoning:
+            review_kwargs["effort"] = reasoning
+        instructions = (prompt or "").strip()
+        if instructions:
+            target = {"type": "custom", "instructions": instructions}
+        else:
+            target = {"type": "uncommittedChanges"}
+        handle = await client.review_start(
+            conversation_id,
+            target=target,
+            approval_policy=approval_mode,
+            sandbox_policy=sandbox_policy,
+            **review_kwargs,
+        )
+        await self._events.register_turn(handle.thread_id, handle.turn_id)
+        return TurnRef(conversation_id=handle.thread_id, turn_id=handle.turn_id)
+
+    async def interrupt(
+        self, workspace_root: Path, conversation_id: str, turn_id: Optional[str]
+    ) -> None:
+        if not turn_id:
+            return
+        client = await self._supervisor.get_client(workspace_root)
+        await client.turn_interrupt(turn_id, thread_id=conversation_id)
+
+    def stream_events(
+        self, workspace_root: Path, conversation_id: str, turn_id: str
+    ) -> AsyncIterator[str]:
+        return self._events.stream(conversation_id, turn_id)
+
+
+__all__ = ["CodexHarness"]

codex_autorunner/agents/execution/policy.py

@@ -0,0 +1,292 @@
+"""Centralized approval and sandbox policy mappings for Codex and OpenCode agents."""
+
+from dataclasses import dataclass
+from typing import Any, Optional, Union
+
+# ========================================================================
+# Approval Policies
+# ========================================================================
+
+
+class ApprovalPolicy:
+    """Canonical approval policy values for both Codex and OpenCode."""
+
+    NEVER = "never"
+    ON_FAILURE = "on-failure"
+    ON_REQUEST = "on-request"
+    UNTRUSTED = "untrusted"
+
+    ALL_VALUES = {NEVER, ON_FAILURE, ON_REQUEST, UNTRUSTED}
+
+
+# ========================================================================
+# Sandbox Policies (Codex)
+# ========================================================================
+
+
+class SandboxPolicy:
+    """Canonical sandbox policy values for Codex app-server."""
+
+    DANGER_FULL_ACCESS = "dangerFullAccess"
+    READ_ONLY = "readOnly"
+    WORKSPACE_WRITE = "workspaceWrite"
+    EXTERNAL_SANDBOX = "externalSandbox"
+
+    ALL_VALUES = {
+        DANGER_FULL_ACCESS,
+        READ_ONLY,
+        WORKSPACE_WRITE,
+        EXTERNAL_SANDBOX,
+    }
+
+
+# ========================================================================
+# Permission Policies (OpenCode)
+# ========================================================================
+
+
+class PermissionPolicy:
+    """Canonical permission policy values for OpenCode."""
+
+    ALLOW = "allow"
+    DENY = "deny"
+    ASK = "ask"
+
+    ALL_VALUES = {ALLOW, DENY, ASK}
+
+
+# ========================================================================
+# Data Classes
+# ========================================================================
+
+
+@dataclass
+class SandboxPolicyConfig:
+    """Configuration for Codex sandbox policies."""
+
+    policy: Union[str, dict[str, Any]]
+    """Either a string policy type or full policy dict with type and options."""
+
+
+@dataclass
+class PolicyMapping:
+    """Unified policy mapping for both Codex and OpenCode agents."""
+
+    approval_policy: str
+    sandbox_policy: Union[str, dict[str, Any]]
+    permission_policy: Optional[str] = None
+
+
+# ========================================================================
+# Normalization Functions
+# ========================================================================
+
+
+def normalize_approval_policy(policy: Optional[str]) -> str:
+    """Normalize approval policy to canonical value.
+
+    Args:
+        policy: Approval policy string (case-insensitive, various aliases accepted).
+
+    Returns:
+        Canonical approval policy value.
+
+    Raises:
+        ValueError: If policy is not a recognized value.
+    """
+    if policy is None:
+        return ApprovalPolicy.NEVER
+
+    if not isinstance(policy, str):
+        raise ValueError(f"Invalid approval policy: {policy!r}")
+
+    normalized = policy.strip()
+    if not normalized:
+        raise ValueError(f"Invalid approval policy: {policy!r}")
+
+    normalized = normalized.lower()
+
+    # Aliases for never
+    if normalized in ("never", "no", "false", "0"):
+        return ApprovalPolicy.NEVER
+
+    # Aliases for on-failure
+    if normalized in (
+        "on-failure",
+        "on_failure",
+        "onfailure",
+        "fail",
+        "failure",
+    ):
+        return ApprovalPolicy.ON_FAILURE
+
+    # Aliases for on-request
+    if normalized in ("on-request", "on_request", "onrequest", "ask", "prompt"):
+        return ApprovalPolicy.ON_REQUEST
+
+    # Aliases for untrusted
+    if normalized in (
+        "untrusted",
+        "unlesstrusted",
+        "unless-trusted",
+        "unless trusted",
+        "auto",
+    ):
+        return ApprovalPolicy.UNTRUSTED
+
+    raise ValueError(
+        f"Invalid approval policy: {policy!r}. "
+        f"Valid values: {', '.join(sorted(ApprovalPolicy.ALL_VALUES))}"
+    )
+
+
+def normalize_sandbox_policy(policy: Optional[Any]) -> Union[str, dict[str, Any]]:
+    """Normalize sandbox policy to canonical value.
+
+    Args:
+        policy: Sandbox policy (string or dict with 'type' field).
+
+    Returns:
+        Normalized sandbox policy as string or dict.
+    """
+    if policy is None:
+        return SandboxPolicy.DANGER_FULL_ACCESS
+
+    # If it's a dict, normalize the type field
+    if isinstance(policy, dict):
+        policy_value = policy.copy()
+        type_value = policy_value.get("type")
+        if isinstance(type_value, str):
+            policy_value["type"] = normalize_sandbox_policy_type(type_value)
+        return policy_value
+
+    # If it's a string, wrap in dict structure
+    if isinstance(policy, str):
+        normalized_type = normalize_sandbox_policy_type(policy)
+        return {"type": normalized_type}
+
+    # For other types, convert to string and wrap
+    return {"type": SandboxPolicy.DANGER_FULL_ACCESS}
+
+
+def normalize_sandbox_policy_type(raw: str) -> str:
+    """Normalize sandbox policy type string to canonical value.
+
+    Args:
+        raw: Sandbox policy type string (case-insensitive).
+
+    Returns:
+        Canonical sandbox policy type.
+    """
+    if not raw:
+        return SandboxPolicy.DANGER_FULL_ACCESS
+
+    # Normalize case and remove special characters
+    import re
+
+    cleaned = re.sub(r"[^a-zA-Z0-9]+", "", raw.strip())
+    if not cleaned:
+        return SandboxPolicy.DANGER_FULL_ACCESS
+
+    canonical = _SANDBOX_POLICY_CANONICAL.get(cleaned.lower())
+    return canonical or raw.strip()
+
+
+_SANDBOX_POLICY_CANONICAL = {
+    "dangerfullaccess": SandboxPolicy.DANGER_FULL_ACCESS,
+    "readonly": SandboxPolicy.READ_ONLY,
+    "workspacewrite": SandboxPolicy.WORKSPACE_WRITE,
+    "externalsandbox": SandboxPolicy.EXTERNAL_SANDBOX,
+}
+
+
+# ========================================================================
+# Mapping Functions
+# ========================================================================
+
+
+def map_approval_to_permission(
+    approval_policy: Optional[str], *, default: str = PermissionPolicy.ALLOW
+) -> str:
+    """Map approval policy to OpenCode permission policy.
+
+    This maps Codex-style approval policies to OpenCode-style permission policies.
+
+    Args:
+        approval_policy: Codex approval policy.
+        default: Default permission if policy is None or unrecognized.
+
+    Returns:
+        OpenCode permission policy (allow/deny/ask).
+    """
+    if approval_policy is None:
+        return default
+
+    try:
+        normalized = normalize_approval_policy(approval_policy)
+    except ValueError:
+        # Invalid policy, return default
+        return default
+
+    # Direct matches
+    if normalized == ApprovalPolicy.NEVER:
+        return PermissionPolicy.ALLOW
+    if normalized == ApprovalPolicy.ON_FAILURE:
+        return PermissionPolicy.ASK
+    if normalized == ApprovalPolicy.ON_REQUEST:
+        return PermissionPolicy.ASK
+    if normalized == ApprovalPolicy.UNTRUSTED:
+        return PermissionPolicy.ASK
+
+    return default
+
+
+def build_codex_sandbox_policy(
+    sandbox_mode: Optional[str],
+    *,
+    repo_root: Optional[Any] = None,
+    network_access: bool = False,
+) -> Union[str, dict[str, Any]]:
+    """Build Codex sandbox policy from mode string.
+
+    Args:
+        sandbox_mode: Sandbox mode string.
+        repo_root: Repository root path (for workspaceWrite policy).
+        network_access: Whether to allow network access (for workspaceWrite).
+
+    Returns:
+        Sandbox policy string or dict.
+    """
+    if not sandbox_mode:
+        return SandboxPolicy.DANGER_FULL_ACCESS
+
+    normalized_mode = normalize_sandbox_policy_type(sandbox_mode)
+
+    # workspaceWrite requires dict structure with writableRoots and networkAccess
+    if normalized_mode == SandboxPolicy.WORKSPACE_WRITE and repo_root is not None:
+        return {
+            "type": SandboxPolicy.WORKSPACE_WRITE,
+            "writableRoots": [str(repo_root)],
+            "networkAccess": network_access,
+        }
+
+    # Other modes can be simple strings
+    return normalized_mode
+
+
+# ========================================================================
+# Exports
+# ========================================================================
+
+__all__ = [
+    "ApprovalPolicy",
+    "SandboxPolicy",
+    "PermissionPolicy",
+    "SandboxPolicyConfig",
+    "PolicyMapping",
+    "normalize_approval_policy",
+    "normalize_sandbox_policy",
+    "normalize_sandbox_policy_type",
+    "map_approval_to_permission",
+    "build_codex_sandbox_policy",
+]

codex_autorunner/agents/factory.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import Optional, cast
+
+from ..core.app_server_events import AppServerEventBuffer
+from ..integrations.app_server.supervisor import WorkspaceAppServerSupervisor
+from .codex.harness import CodexHarness
+from .opencode.harness import OpenCodeHarness
+from .opencode.supervisor import OpenCodeSupervisor
+from .orchestrator import AgentOrchestrator, CodexOrchestrator, OpenCodeOrchestrator
+from .registry import get_agent_descriptor
+
+
+def create_orchestrator(
+    agent_id: str,
+    codex_supervisor: Optional[WorkspaceAppServerSupervisor] = None,
+    codex_events: Optional[AppServerEventBuffer] = None,
+    opencode_supervisor: Optional[OpenCodeSupervisor] = None,
+) -> AgentOrchestrator:
+    descriptor = get_agent_descriptor(agent_id)
+    if descriptor is None:
+        raise ValueError(f"Unknown agent: {agent_id}")
+
+    class _AppContext:
+        def __init__(
+            self,
+            app_server_supervisor: Optional[WorkspaceAppServerSupervisor] = None,
+            app_server_events: Optional[AppServerEventBuffer] = None,
+            opencode_supervisor: Optional[OpenCodeSupervisor] = None,
+        ):
+            self.app_server_supervisor = app_server_supervisor
+            self.app_server_events = app_server_events
+            self.opencode_supervisor = opencode_supervisor
+
+    app_ctx = _AppContext(codex_supervisor, codex_events, opencode_supervisor)
+    harness = descriptor.make_harness(app_ctx)
+
+    if agent_id == "codex":
+        if not isinstance(harness, CodexHarness):
+            raise RuntimeError(f"Expected CodexHarness but got {type(harness)}")
+        return CodexOrchestrator(harness, cast(AppServerEventBuffer, codex_events))
+    elif agent_id == "opencode":
+        if not isinstance(harness, OpenCodeHarness):
+            raise RuntimeError(f"Expected OpenCodeHarness but got {type(harness)}")
+        return OpenCodeOrchestrator(harness)
+    else:
+        raise RuntimeError(f"No orchestrator implementation for agent: {agent_id}")
+
+
+__all__ = [
+    "create_orchestrator",
+]

codex_autorunner/agents/opencode/__init__.py

@@ -0,0 +1,18 @@
+"""OpenCode harness support."""
+
+from .client import OpenCodeClient
+from .events import SSEEvent, parse_sse_lines
+from .harness import OpenCodeHarness
+from .run_prompt import OpenCodeRunConfig, OpenCodeRunResult, run_opencode_prompt
+from .supervisor import OpenCodeSupervisor
+
+__all__ = [
+    "OpenCodeClient",
+    "OpenCodeHarness",
+    "OpenCodeRunConfig",
+    "OpenCodeRunResult",
+    "OpenCodeSupervisor",
+    "SSEEvent",
+    "parse_sse_lines",
+    "run_opencode_prompt",
+]