autopilot-code 1.0.0 → 2.1.0

package/README.md

@@ -43,7 +43,6 @@ The new runner provides enhanced progress tracking and session continuity:
 
 ```json
 {
-  "useNewRunner": true,
   "enablePlanningStep": true
 }
 ```
@@ -104,7 +103,6 @@ Example:
 Notes:
 - `repo` must be the GitHub `owner/name`.
 - `agent` (optional, default `"opencode"`): set to `"opencode"` or `"claude"` to choose which coding agent to use.
-- `useNewRunner` (optional, default `true`): enable the new runner with step labels and session continuity. The legacy bash runner is deprecated and will be removed in a future version.
 - `autoMerge` (optional, default `true`): if `true`, autopilot will automatically merge PRs after checks pass.
 - `mergeMethod` (optional, default `"squash"`): merge strategy to use. Options: `"squash"`, `"merge"`, or `"rebase"`.
 - `allowedMergeUsers` (required when `autoMerge=true`): list of GitHub usernames allowed to auto-merge. The runner verifies the authenticated GitHub user is in this list before merging.
@@ -114,7 +112,7 @@ Notes:
 - `conflictResolutionMaxAttempts` (optional, default `3`): maximum number of attempts to resolve merge conflicts.
 - `autoFixChecks` (optional, default `true`): if `true`, autopilot will attempt to automatically fix failing CI checks.
 - `autoFixChecksMaxAttempts` (optional, default `3`): maximum number of attempts to fix failing checks.
-- `enablePlanningStep` (optional, default `true`): if `true`, add an explicit planning phase before implementation (requires `useNewRunner: true`).
+- `enablePlanningStep` (optional, default `true`): if `true`, add an explicit planning phase before implementation.
 - `agentPath` (optional): custom path to agent executable (defaults to searching PATH).
 
 ## Workflow (labels)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "1.0.0",
+  "version": "2.1.0",
   "private": false,
   "description": "Repo-issue–driven autopilot runner",
   "license": "MIT",

package/scripts/issue_runner/agents/__init__.py

@@ -1,8 +1,15 @@
 from .base import BaseAgent, AgentResult
 from .opencode import OpenCodeAgent
+from .opencode_server import OpenCodeServerAgent
 from .claude import ClaudeCodeAgent
 
-__all__ = ["BaseAgent", "AgentResult", "OpenCodeAgent", "ClaudeCodeAgent"]
+__all__ = [
+    "BaseAgent",
+    "AgentResult",
+    "OpenCodeAgent",
+    "OpenCodeServerAgent",
+    "ClaudeCodeAgent",
+]
 
 
 def get_agent(agent_type: str, config: dict) -> BaseAgent:
@@ -10,7 +17,7 @@ def get_agent(agent_type: str, config: dict) -> BaseAgent:
     Factory function to create the appropriate agent.
 
     Args:
-        agent_type: "opencode" or "claude"
+        agent_type: "opencode", "opencode-server", or "claude"
         config: Agent configuration from autopilot.json
 
     Returns:
@@ -21,6 +28,7 @@ def get_agent(agent_type: str, config: dict) -> BaseAgent:
     """
     agents = {
         "opencode": OpenCodeAgent,
+        "opencode-server": OpenCodeServerAgent,
         "claude": ClaudeCodeAgent,
     }
 

package/scripts/issue_runner/agents/opencode_client.py

@@ -0,0 +1,486 @@
+"""
+HTTP client for OpenCode server API.
+
+This module provides a client for interacting with the OpenCode server
+via its HTTP API, enabling session-based conversations with proper
+session persistence across server restarts.
+"""
+
+import json
+import logging
+import os
+import re
+import signal
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ServerInfo:
+    """Information about a running OpenCode server."""
+    port: int
+    pid: int
+    worktree: Path
+
+
+@dataclass
+class MessagePart:
+    """A part of a message response."""
+    type: str
+    text: Optional[str] = None
+    tool: Optional[str] = None
+    tool_input: Optional[Dict[str, Any]] = None
+    tool_output: Optional[str] = None
+
+
+@dataclass
+class MessageResponse:
+    """Response from sending a message."""
+    message_id: str
+    session_id: str
+    role: str
+    parts: List[MessagePart]
+    tokens: Dict[str, int]
+    finish_reason: Optional[str] = None
+
+    def get_text(self) -> str:
+        """Extract all text content from response parts."""
+        text_parts = [p.text for p in self.parts if p.type == "text" and p.text]
+        return "\n".join(text_parts)
+
+
+class OpenCodeClient:
+    """
+    HTTP client for OpenCode server.
+
+    Handles communication with an OpenCode server instance running
+    in a specific worktree directory.
+    """
+
+    def __init__(self, port: int, host: str = "127.0.0.1", timeout: int = 1800):
+        """
+        Initialize client for a specific server.
+
+        Args:
+            port: Port the server is listening on
+            host: Hostname (default localhost)
+            timeout: Request timeout in seconds (default 30 minutes for long agent runs)
+        """
+        # 30-minute timeout matches the agent execution limit - complex implementations
+        # or CI fixes can take significant time as the LLM explores the codebase.
+        self.port = port
+        self.host = host
+        self.timeout = timeout
+        self.base_url = f"http://{host}:{port}"
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        data: Optional[Dict] = None,
+        timeout: Optional[int] = None,
+    ) -> Optional[Dict]:
+        """
+        Make an HTTP request to the server using curl.
+
+        We use curl instead of urllib/requests because:
+        1. Zero dependencies - curl is universally available
+        2. Reliable timeout handling for very long requests (30+ min)
+        3. The ~10ms subprocess overhead is negligible vs. agent execution time
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            path: API path (e.g., /session)
+            data: JSON data to send (for POST/PATCH)
+            timeout: Override default timeout
+
+        Returns:
+            Parsed JSON response or None on error
+        """
+        url = f"{self.base_url}{path}"
+        # Use -w to append HTTP status code on a new line for validation
+        cmd = ["curl", "-s", "-X", method, "-w", "\n%{http_code}", url]
+
+        if data is not None:
+            cmd.extend(["-H", "Content-Type: application/json"])
+            cmd.extend(["-d", json.dumps(data)])
+
+        req_timeout = timeout if timeout is not None else self.timeout
+        cmd.extend(["--max-time", str(req_timeout)])
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                # Extra 10s buffer for subprocess overhead beyond curl's timeout
+                timeout=req_timeout + 10,
+            )
+
+            if result.returncode != 0:
+                logger.warning(f"Request failed: {result.stderr}")
+                return None
+
+            # Parse response body and HTTP status code
+            output = result.stdout.strip()
+            if not output:
+                return None
+
+            # Status code is on the last line (added by -w flag)
+            lines = output.rsplit("\n", 1)
+            if len(lines) != 2:
+                # Malformed response - -w flag should always add status code line
+                logger.warning(f"Malformed curl response (no status code): {output[:100]}")
+                return None
+
+            body, status_code = lines
+            if not status_code.isdigit():
+                logger.warning(f"Invalid HTTP status code: {status_code}")
+                return None
+
+            if int(status_code) >= 400:
+                logger.warning(f"HTTP {status_code} from {method} {path}")
+                return None
+
+            if not body:
+                return None
+
+            return json.loads(body)
+        except subprocess.TimeoutExpired:
+            logger.error(f"Request timed out: {method} {path}")
+            return None
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON response: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Request error: {e}")
+            return None
+
+    def health_check(self) -> bool:
+        """
+        Check if the server is healthy.
+
+        Returns:
+            True if server is responding and healthy
+        """
+        response = self._request("GET", "/global/health", timeout=5)
+        return response is not None and response.get("healthy", False)
+
+    def create_session(self, title: Optional[str] = None) -> Optional[str]:
+        """
+        Create a new session.
+
+        Args:
+            title: Optional title for the session
+
+        Returns:
+            Session ID or None on error
+        """
+        data = {}
+        if title:
+            data["title"] = title
+
+        response = self._request("POST", "/session", data=data, timeout=30)
+        if response:
+            session_id = response.get("id")
+            logger.info(f"Created session: {session_id}")
+            return session_id
+        return None
+
+    def get_session(self, session_id: str) -> Optional[Dict]:
+        """
+        Get session details.
+
+        Args:
+            session_id: Session ID to retrieve
+
+        Returns:
+            Session data or None if not found
+        """
+        return self._request("GET", f"/session/{session_id}", timeout=10)
+
+    def session_exists(self, session_id: str) -> bool:
+        """
+        Check if a session exists.
+
+        Args:
+            session_id: Session ID to check
+
+        Returns:
+            True if session exists
+        """
+        session = self.get_session(session_id)
+        return session is not None and "id" in session
+
+    def send_message(
+        self,
+        session_id: str,
+        text: str,
+        timeout: Optional[int] = None,
+    ) -> Optional[MessageResponse]:
+        """
+        Send a message to a session and wait for response.
+
+        Args:
+            session_id: Session to send message to
+            text: Message text
+            timeout: Override default timeout
+
+        Returns:
+            MessageResponse or None on error
+        """
+        data = {
+            "parts": [{"type": "text", "text": text}]
+        }
+
+        response = self._request(
+            "POST",
+            f"/session/{session_id}/message",
+            data=data,
+            timeout=timeout,
+        )
+
+        if not response:
+            return None
+
+        try:
+            info = response.get("info", {})
+            raw_parts = response.get("parts", [])
+
+            parts = []
+            for p in raw_parts:
+                part = MessagePart(type=p.get("type", "unknown"))
+                if p.get("type") == "text":
+                    part.text = p.get("text", "")
+                elif p.get("type") == "tool":
+                    part.tool = p.get("tool")
+                    state = p.get("state", {})
+                    part.tool_input = state.get("input")
+                    part.tool_output = state.get("output")
+                elif p.get("type") == "reasoning":
+                    part.text = p.get("text", "")
+                parts.append(part)
+
+            return MessageResponse(
+                message_id=info.get("id", ""),
+                session_id=info.get("sessionID", session_id),
+                role=info.get("role", "assistant"),
+                parts=parts,
+                tokens=info.get("tokens", {}),
+                finish_reason=info.get("finish"),
+            )
+        except Exception as e:
+            logger.error(f"Failed to parse message response: {e}")
+            return None
+
+    def get_messages(
+        self,
+        session_id: str,
+        limit: Optional[int] = None,
+    ) -> List[Dict]:
+        """
+        Get message history for a session.
+
+        Args:
+            session_id: Session to get messages from
+            limit: Maximum number of messages to retrieve
+
+        Returns:
+            List of message dictionaries
+        """
+        path = f"/session/{session_id}/message"
+        if limit:
+            path += f"?limit={limit}"
+
+        response = self._request("GET", path, timeout=30)
+        return response if isinstance(response, list) else []
+
+
+class OpenCodeServerManager:
+    """
+    Manages OpenCode server instances for worktrees.
+
+    Handles starting, stopping, and connecting to OpenCode servers
+    for different worktree directories.
+    """
+
+    def __init__(self, opencode_binary: str = "opencode"):
+        """
+        Initialize server manager.
+
+        Args:
+            opencode_binary: Path to opencode binary
+        """
+        self.binary = opencode_binary
+        self._servers: Dict[str, ServerInfo] = {}  # worktree path -> server info
+
+    def _parse_port_from_output(self, output: str) -> Optional[int]:
+        """Parse port number from server startup output."""
+        match = re.search(r"listening on http://[^:]+:(\d+)", output)
+        if match:
+            return int(match.group(1))
+        return None
+
+    def start_server(
+        self,
+        worktree: Path,
+        timeout: int = 30,
+    ) -> Optional[ServerInfo]:
+        """
+        Start an OpenCode server for a worktree.
+
+        Args:
+            worktree: Path to the worktree directory
+            timeout: Seconds to wait for server to start
+
+        Returns:
+            ServerInfo or None on failure
+        """
+        worktree_str = str(worktree.resolve())
+
+        # Check if we already have a server for this worktree.
+        # Note: There's a theoretical TOCTOU race between health_check() and using
+        # the server, but Python's GIL + our single-threaded runner make this safe.
+        # If the server dies between check and use, the HTTP call will fail and
+        # the caller can retry, which will start a fresh server.
+        if worktree_str in self._servers:
+            info = self._servers[worktree_str]
+            client = OpenCodeClient(info.port)
+            if client.health_check():
+                logger.info(f"Reusing existing server on port {info.port}")
+                return info
+            else:
+                # Server died or unresponsive - kill stale process and remove from cache
+                logger.warning(f"Server on port {info.port} not responding, killing PID {info.pid}")
+                try:
+                    os.kill(info.pid, signal.SIGTERM)
+                except ProcessLookupError:
+                    pass  # Already dead
+                except Exception as e:
+                    logger.debug(f"Error killing stale server: {e}")
+                del self._servers[worktree_str]
+
+        logger.info(f"Starting OpenCode server for {worktree}")
+
+        # Start server process
+        proc = subprocess.Popen(
+            [self.binary, "serve"],
+            cwd=worktree,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+
+        # Wait for server to output port
+        port = None
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            if proc.poll() is not None:
+                # Process exited
+                output = proc.stdout.read() if proc.stdout else ""
+                logger.error(f"Server exited unexpectedly: {output}")
+                return None
+
+            # Blocking readline is acceptable here because:
+            # 1. OpenCode always outputs the port line quickly on startup
+            # 2. The outer timeout loop + proc.poll() handles hung processes
+            # 3. Non-blocking I/O adds complexity without real benefit
+            if proc.stdout:
+                line = proc.stdout.readline()
+                if line:
+                    logger.debug(f"Server output: {line.strip()}")
+                    port = self._parse_port_from_output(line)
+                    if port:
+                        break
+                    # Warn if we see output but can't parse port (format may have changed)
+                    if "listen" in line.lower():
+                        logger.warning(f"Could not parse port from: {line.strip()}")
+
+            time.sleep(0.1)
+
+        if not port:
+            logger.error("Failed to get server port - check OpenCode version/output format")
+            proc.terminate()
+            return None
+
+        # Close stdout to prevent buffer fill-up since the server runs detached.
+        # The server communicates via HTTP after startup, not stdout, so any
+        # SIGPIPE from further writes is harmless and expected.
+        if proc.stdout:
+            proc.stdout.close()
+
+        # Verify server is responding
+        client = OpenCodeClient(port)
+        if not self._wait_for_health(client, timeout=10):
+            logger.error("Server not responding to health checks")
+            proc.terminate()
+            return None
+
+        info = ServerInfo(port=port, pid=proc.pid, worktree=worktree)
+        self._servers[worktree_str] = info
+        logger.info(f"Server started on port {port} (PID {proc.pid})")
+
+        return info
+
+    def _wait_for_health(self, client: OpenCodeClient, timeout: int = 10) -> bool:
+        """Wait for server to become healthy."""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if client.health_check():
+                return True
+            time.sleep(0.5)
+        return False
+
+    def get_client(self, worktree: Path) -> Optional[OpenCodeClient]:
+        """
+        Get a client for a worktree, starting server if needed.
+
+        Args:
+            worktree: Path to worktree
+
+        Returns:
+            OpenCodeClient or None if server couldn't be started
+        """
+        info = self.start_server(worktree)
+        if info:
+            return OpenCodeClient(info.port)
+        return None
+
+    def stop_server(self, worktree: Path) -> bool:
+        """
+        Stop the server for a worktree.
+
+        Args:
+            worktree: Path to worktree
+
+        Returns:
+            True if server was stopped
+        """
+        worktree_str = str(worktree.resolve())
+
+        if worktree_str not in self._servers:
+            return False
+
+        info = self._servers[worktree_str]
+
+        try:
+            os.kill(info.pid, signal.SIGTERM)
+            logger.info(f"Stopped server on port {info.port} (PID {info.pid})")
+        except ProcessLookupError:
+            logger.debug(f"Server already stopped (PID {info.pid})")
+        except Exception as e:
+            logger.warning(f"Error stopping server: {e}")
+
+        del self._servers[worktree_str]
+        return True
+
+    def stop_all(self) -> None:
+        """Stop all managed servers."""
+        for worktree_str in list(self._servers.keys()):
+            self.stop_server(Path(worktree_str))