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

codex_autorunner/agents/__init__.py

@@ -1 +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

@@ -3,11 +3,11 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any, AsyncIterator, Optional, Protocol
 
-from .types import ConversationRef, ModelCatalog, TurnRef
+from .types import AgentId, ConversationRef, ModelCatalog, TurnRef
 
 
 class AgentHarness(Protocol):
-    agent_id: str
+    agent_id: AgentId
     display_name: str
 
     async def ensure_ready(self, workspace_root: Path) -> None: ...

codex_autorunner/agents/codex/harness.py

@@ -73,7 +73,7 @@ def _coerce_reasoning_efforts(entry: dict[str, Any]) -> list[str]:
 
 
 class CodexHarness(AgentHarness):
-    agent_id: AgentId = "codex"
+    agent_id: AgentId = AgentId("codex")
     display_name = "Codex"
 
     def __init__(

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

@@ -3,12 +3,16 @@
 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",
 ]

codex_autorunner/agents/opencode/agent_config.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+async def ensure_agent_config(
+    workspace_root: Path,
+    agent_id: str,
+    model: Optional[str],
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+) -> None:
+    """Ensure .opencode/agent/<agent_id>.md exists with frontmatter config.
+
+    Args:
+        workspace_root: Path to the workspace root
+        agent_id: Agent ID (e.g., "subagent")
+        model: Model ID in format "providerID/modelID" (e.g., "zai-coding-plan/glm-4.7-flashx")
+        title: Optional title for the agent
+        description: Optional description for the agent
+    """
+    if model is None:
+        logger.debug(f"Skipping agent config for {agent_id}: no model configured")
+        return
+
+    agent_dir = workspace_root / ".opencode" / "agent"
+    agent_file = agent_dir / f"{agent_id}.md"
+
+    # Check if file already exists and has the correct model
+    if agent_file.exists():
+        existing_content = agent_file.read_text(encoding="utf-8")
+        existing_model = _extract_model_from_frontmatter(existing_content)
+        if existing_model == model:
+            logger.debug(f"Agent config already exists for {agent_id}: {agent_file}")
+            return
+
+    # Create agent directory if needed
+    await asyncio.to_thread(agent_dir.mkdir, parents=True, exist_ok=True)
+
+    # Build agent markdown with frontmatter
+    content = _build_agent_md(
+        agent_id=agent_id,
+        model=model,
+        title=title or agent_id,
+        description=description or f"Subagent for {agent_id} tasks",
+    )
+
+    # Write atomically
+    await asyncio.to_thread(agent_file.write_text, content, encoding="utf-8")
+    logger.info(f"Created agent config: {agent_file} with model {model}")
+
+
+def _build_agent_md(
+    agent_id: str,
+    model: str,
+    title: str,
+    description: str,
+) -> str:
+    """Generate markdown with YAML frontmatter.
+
+    Frontmatter format per OpenCode config schema:
+    ---
+    agent: <agent_id>
+    title: "<title>"
+    description: "<description>"
+    model: <providerID>/<modelID>
+    ---
+
+    <Optional agent instructions go here>
+    """
+    return f"""---
+agent: {agent_id}
+title: "{title}"
+description: "{description}"
+model: {model}
+---
+"""
+
+
+def _extract_model_from_frontmatter(content: str) -> Optional[str]:
+    """Extract model value from YAML frontmatter.
+
+    Returns None if frontmatter or model field is not found.
+    """
+    lines = content.splitlines()
+    if not lines or not lines[0].startswith("---"):
+        return None
+
+    for _i, line in enumerate(lines[1:], start=1):
+        if line.startswith("---"):
+            break
+        if line.startswith("model:"):
+            model = line.split(":", 1)[1].strip()
+            return model if model else None
+
+    return None
+
+
+__all__ = ["ensure_agent_config"]