portacode 1.5.13.dev3__tar.gz → 1.5.14.dev0__tar.gz

{portacode-1.5.13.dev3 → portacode-1.5.14.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.13.dev3
+Version: 1.5.14.dev0
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.5.13.dev3 → portacode-1.5.14.dev0}/portacode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.13.dev3'
-__version_tuple__ = version_tuple = (1, 5, 13, 'dev3')
+__version__ = version = '1.5.14.dev0'
+__version_tuple__ = version_tuple = (1, 5, 14, 'dev0')
 
 __commit_id__ = commit_id = None

{portacode-1.5.13.dev3 → portacode-1.5.14.dev0}/portacode/codex_prepare.py

@@ -67,9 +67,14 @@ def _sudo_prefix() -> list[str]:
 
 
 def _authorize_sudo_if_needed() -> None:
-    """Prompt before captured installer output would otherwise hide sudo's prompt."""
+    """Use passwordless sudo when available before prompting interactively."""
     if platform.system().lower() not in {"linux", "darwin"} or not _sudo_prefix():
         return
+    non_interactive = subprocess.run(
+        ["sudo", "-n", "true"], text=True, capture_output=True
+    )
+    if non_interactive.returncode == 0:
+        return
     result = subprocess.run(["sudo", "-v"], text=True)
     if result.returncode:
         raise CodexPreparationError("Administrator authorization is required to prepare Codex.")

portacode-1.5.14.dev0/portacode/connection/codex_app_server.py

@@ -0,0 +1,326 @@
+"""JSON-RPC bridge to the Codex CLI app-server over stdio."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import shutil
+import uuid
+from typing import Any, Awaitable, Callable, Dict, List, Optional
+
+LOGGER = logging.getLogger(__name__)
+
+DEFAULT_CODEX_COMMAND = ["codex", "app-server", "--listen", "stdio://"]
+
+
+class CodexAppServerError(RuntimeError):
+    """Raised when the Codex app-server cannot be started or is unhealthy."""
+
+
+class CodexAppServer:
+    """Thin asyncio JSON-RPC 2.0 client for `codex app-server --listen stdio://`.
+
+    One instance per device agent is enough: the app-server can host multiple
+    threads/cwds, so we keep it alive for the lifetime of the connection and
+    lazily spawn it on the first command.
+    """
+
+    def __init__(
+        self,
+        command: Optional[List[str]] = None,
+        client_info: Optional[Dict[str, Any]] = None,
+        on_notification: Optional[Callable[[str, Dict[str, Any]], Awaitable[None]]] = None,
+        _process_factory: Optional[Callable[..., Awaitable[Any]]] = None,
+    ) -> None:
+        self.command = command or list(DEFAULT_CODEX_COMMAND)
+        self.client_info = client_info or {"name": "portacode", "version": "1.5.13"}
+        self.on_notification = on_notification
+        self._process_factory = _process_factory or asyncio.create_subprocess_exec
+
+        self._proc: Optional[asyncio.subprocess.Process] = None
+        self._reader_task: Optional[asyncio.Task] = None
+        self._stderr_task: Optional[asyncio.Task] = None
+        self._next_id = 1
+        self._pending: Dict[int, asyncio.Future] = {}
+        self._lock = asyncio.Lock()
+        self._initialized = asyncio.Event()
+        self._closed = False
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+    async def start(self) -> None:
+        """Start the app-server if it is not already running."""
+        if self._closed:
+            raise CodexAppServerError("CodexAppServer has been closed")
+        async with self._lock:
+            if self._proc is not None and self._proc.returncode is None:
+                return
+            await self._spawn()
+
+    async def stop(self) -> None:
+        """Stop the app-server and cancel background tasks."""
+        async with self._lock:
+            self._closed = True
+            await self._kill_locked()
+
+    async def _spawn(self) -> None:
+        """Spawn the subprocess and perform the JSON-RPC initialize handshake."""
+        exe = shutil.which(self.command[0]) or self.command[0]
+        if not shutil.which(self.command[0]):
+            raise CodexAppServerError(
+                f"{self.command[0]} not found on PATH. Run `portacode prepare codex` on this device."
+            )
+
+        LOGGER.info("Spawning Codex app-server: %s", " ".join(self.command))
+        try:
+            self._proc = await self._process_factory(
+                *self.command,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env=None,  # Inherit the environment where `prepare codex` set OPENAI_API_KEY
+            )
+        except Exception as exc:
+            raise CodexAppServerError(f"Failed to spawn codex app-server: {exc}") from exc
+
+        self._reader_task = asyncio.create_task(self._read_loop(), name="codex-app-server-stdout")
+        self._stderr_task = asyncio.create_task(self._stderr_loop(), name="codex-app-server-stderr")
+
+        await self._initialize()
+
+    async def _kill_locked(self) -> None:
+        """Tear down the subprocess and reader tasks."""
+        for future in list(self._pending.values()):
+            if not future.done():
+                future.set_exception(CodexAppServerError("Codex app-server stopped"))
+        self._pending.clear()
+
+        if self._reader_task is not None:
+            self._reader_task.cancel()
+            self._reader_task = None
+        if self._stderr_task is not None:
+            self._stderr_task.cancel()
+            self._stderr_task = None
+
+        if self._proc is not None and self._proc.returncode is None:
+            try:
+                self._proc.terminate()
+                await asyncio.wait_for(self._proc.wait(), timeout=3.0)
+            except asyncio.TimeoutError:
+                self._proc.kill()
+                await self._proc.wait()
+            except ProcessLookupError:
+                pass
+        self._proc = None
+        self._initialized.clear()
+
+    # ------------------------------------------------------------------
+    # JSON-RPC I/O
+    # ------------------------------------------------------------------
+    async def _initialize(self) -> None:
+        """Send the initialize handshake and wait for its response."""
+        response = await self._request(
+            "initialize",
+            {
+                "clientInfo": self.client_info,
+                "capabilities": {"streaming": True},
+            },
+            timeout=10.0,
+        )
+        LOGGER.info("Codex app-server initialized: %s", response.get("result", {}))
+        self._initialized.set()
+
+    async def _request(
+        self, method: str, params: Dict[str, Any], timeout: float = 60.0
+    ) -> Dict[str, Any]:
+        """Send a JSON-RPC request and return the response object."""
+        await self.start()
+        assert self._proc is not None and self._proc.stdin is not None
+
+        request_id = self._next_id
+        self._next_id += 1
+        message = {"jsonrpc": "2.0", "id": request_id, "method": method, "params": params}
+        payload = json.dumps(message, ensure_ascii=False)
+
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future = loop.create_future()
+        self._pending[request_id] = future
+
+        try:
+            self._proc.stdin.write((payload + "\n").encode("utf-8"))
+            await self._proc.stdin.drain()
+        except Exception as exc:
+            self._pending.pop(request_id, None)
+            raise CodexAppServerError(f"Failed to write to codex app-server: {exc}") from exc
+
+        try:
+            return await asyncio.wait_for(future, timeout=timeout)
+        except asyncio.TimeoutError as exc:
+            self._pending.pop(request_id, None)
+            raise CodexAppServerError(f"codex app-server request timed out: {method}") from exc
+
+    async def _send_notification(self, method: str, params: Dict[str, Any]) -> None:
+        """Fire a JSON-RPC notification (no response expected)."""
+        await self.start()
+        assert self._proc is not None and self._proc.stdin is not None
+        message = {"jsonrpc": "2.0", "method": method, "params": params}
+        payload = json.dumps(message, ensure_ascii=False)
+        self._proc.stdin.write((payload + "\n").encode("utf-8"))
+        await self._proc.stdin.drain()
+
+    async def _send_error_response(self, request_id: Any, code: int, message: str) -> None:
+        """Reply to a server->client request with a JSON-RPC error."""
+        assert self._proc is not None and self._proc.stdin is not None
+        response = {"jsonrpc": "2.0", "id": request_id, "error": {"code": code, "message": message}}
+        payload = json.dumps(response, ensure_ascii=False)
+        self._proc.stdin.write((payload + "\n").encode("utf-8"))
+        await self._proc.stdin.drain()
+
+    # ------------------------------------------------------------------
+    # Reading loops
+    # ------------------------------------------------------------------
+    async def _read_loop(self) -> None:
+        """Read newline-delimited JSON-RPC messages from app-server stdout."""
+        assert self._proc is not None and self._proc.stdout is not None
+        try:
+            while True:
+                line = await self._proc.stdout.readline()
+                if not line:
+                    break
+                line = line.decode("utf-8", errors="replace").strip()
+                if not line:
+                    continue
+                try:
+                    message = json.loads(line)
+                except json.JSONDecodeError as exc:
+                    LOGGER.warning("Ignoring non-JSON line from codex app-server: %r (%s)", line, exc)
+                    continue
+                await self._dispatch_message(message)
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            LOGGER.exception("codex app-server read loop failed")
+        finally:
+            # Process exited; schedule a restart if not closed.
+            if not self._closed:
+                asyncio.create_task(self._on_reader_exit())
+
+    async def _stderr_loop(self) -> None:
+        """Forward app-server stderr lines to the logger."""
+        assert self._proc is not None and self._proc.stderr is not None
+        try:
+            while True:
+                line = await self._proc.stderr.readline()
+                if not line:
+                    break
+                text = line.decode("utf-8", errors="replace").rstrip()
+                if text:
+                    LOGGER.debug("codex app-server stderr: %s", text)
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            LOGGER.exception("codex app-server stderr loop failed")
+
+    async def _dispatch_message(self, message: Dict[str, Any]) -> None:
+        """Route a single JSON-RPC message to pending response, notification, or request handler."""
+        request_id = message.get("id")
+        has_result = "result" in message
+        has_error = "error" in message
+        method = message.get("method")
+        params = message.get("params", {})
+
+        if has_result or has_error:
+            if request_id is not None and request_id in self._pending:
+                future = self._pending.pop(request_id)
+                if not future.done():
+                    future.set_result(message)
+            return
+
+        if request_id is not None and method is not None:
+            # The server sent us a request. We currently auto-decline/unsupported everything
+            # because the portacode config sets approval_policy="never" and danger-full-access.
+            LOGGER.debug("Declining codex app-server request: %s", method)
+            await self._send_error_response(request_id, -32601, f"Method not supported by portacode: {method}")
+            return
+
+        if method is not None:
+            # Notification from app-server.
+            LOGGER.debug("codex app-server notification: %s", method)
+            if self.on_notification is not None:
+                try:
+                    await self.on_notification(method, params)
+                except Exception:
+                    LOGGER.exception("codex notification handler failed for %s", method)
+            return
+
+        LOGGER.debug("Ignoring unexpected codex app-server message: %s", message)
+
+    async def _on_reader_exit(self) -> None:
+        """Restart the app-server once after an unexpected exit."""
+        async with self._lock:
+            if self._closed or self._proc is None:
+                return
+            LOGGER.warning("Codex app-server process exited (code %s); restarting", self._proc.returncode)
+            await self._kill_locked()
+        try:
+            await self.start()
+        except Exception:
+            LOGGER.exception("Failed to restart codex app-server")
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    async def call(
+        self, method: str, params: Optional[Dict[str, Any]] = None, timeout: float = 60.0
+    ) -> Dict[str, Any]:
+        """Call a Codex app-server method and return the `result` field."""
+        params = params or {}
+        response = await self._request(method, params, timeout)
+        if "error" in response:
+            error = response["error"]
+            raise CodexAppServerError(
+                f"codex app-server error ({method}): {error.get('message', error)}"
+            )
+        return response.get("result", {})
+
+    async def notify(self, method: str, params: Optional[Dict[str, Any]] = None) -> None:
+        """Send a JSON-RPC notification."""
+        await self._send_notification(method, params or {})
+
+    async def healthy(self) -> bool:
+        """Return True if the app-server is initialized and the process is alive."""
+        if self._proc is None or self._proc.returncode is not None:
+            return False
+        return self._initialized.is_set()
+
+    @staticmethod
+    def get_binary_path() -> Optional[str]:
+        return shutil.which("codex")
+
+    @staticmethod
+    def version() -> Optional[str]:
+        import subprocess
+
+        exe = shutil.which("codex")
+        if not exe:
+            return None
+        try:
+            result = subprocess.run(
+                [exe, "--version"], capture_output=True, text=True, timeout=10
+            )
+            return result.stdout.strip() or None
+        except Exception:
+            return None
+
+    def get_running_thread_id(self, turn_id: Optional[str] = None) -> Optional[str]:
+        """Hook for the manager to resolve turn_id -> thread_id if needed."""
+        return None
+
+    def __del__(self) -> None:
+        if self._proc is not None and self._proc.returncode is None:
+            try:
+                self._proc.kill()
+            except Exception:
+                pass

{portacode-1.5.13.dev3 → portacode-1.5.14.dev0}/portacode/connection/handlers/__init__.py

@@ -61,6 +61,14 @@ from .automation_v2_handlers import (
     AutomationV2StateHandler,
     AutomationV2CancelHandler,
 )
+from .codex_handlers import (
+    CodexStatusHandler,
+    CodexThreadListHandler,
+    CodexThreadStartHandler,
+    CodexThreadResumeHandler,
+    CodexTurnStartHandler,
+    CodexTurnInterruptHandler,
+)
 
 __all__ = [
     "BaseHandler",
@@ -112,4 +120,11 @@ __all__ = [
     "AutomationV2StartHandler",
     "AutomationV2StateHandler",
     "AutomationV2CancelHandler",
+    # Codex chat handlers
+    "CodexStatusHandler",
+    "CodexThreadListHandler",
+    "CodexThreadStartHandler",
+    "CodexThreadResumeHandler",
+    "CodexTurnStartHandler",
+    "CodexTurnInterruptHandler",
 ]

portacode-1.5.14.dev0/portacode/connection/handlers/codex_handlers.py

@@ -0,0 +1,293 @@
+"""Device-side command handlers for the Codex chat UI."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional
+
+from portacode.connection.codex_app_server import CodexAppServer, CodexAppServerError
+from portacode.connection.handlers.base import AsyncHandler
+
+LOGGER = logging.getLogger(__name__)
+
+
+class _SessionAwareSender:
+    """Helper to push events to the browser sessions interested in a project."""
+
+    def __init__(self, control_channel: Any, context: Dict[str, Any]) -> None:
+        self.control_channel = control_channel
+        self.context = context
+
+    async def send(self, payload: Dict[str, Any], project_id: Optional[str] = None) -> None:
+        client_session_manager = self.context.get("client_session_manager")
+        if client_session_manager and client_session_manager.has_interested_clients():
+            target_sessions = client_session_manager.get_target_sessions(project_id)
+            if target_sessions:
+                payload = dict(payload)
+                payload["client_sessions"] = target_sessions
+            reply_channel = client_session_manager.get_reply_channel_for_compatibility()
+            if reply_channel:
+                payload = dict(payload)
+                payload["reply_channel"] = reply_channel
+
+        await self.control_channel.send(payload)
+
+
+class CodexChatManager:
+    """Owns one CodexAppServer bridge and routes its events to Portacode client sessions."""
+
+    def __init__(self, control_channel: Any, context: Dict[str, Any]) -> None:
+        self.sender = _SessionAwareSender(control_channel, context)
+        self.bridge = CodexAppServer(on_notification=self._on_notification)
+        self._thread_project: Dict[str, str] = {}
+        self._cwd_project: Dict[str, str] = {}
+
+    async def _on_notification(self, method: str, params: Dict[str, Any]) -> None:
+        project_id = self._resolve_project_id(params)
+        event_payload = {
+            "event": "codex_event",
+            "notification": {"method": method, "params": params},
+        }
+        if project_id:
+            event_payload["project_id"] = project_id
+        await self.sender.send(event_payload, project_id=project_id)
+
+    def _resolve_project_id(self, params: Dict[str, Any]) -> Optional[str]:
+        # Most notifications contain a threadId. Try that first.
+        thread_id = params.get("threadId") or (params.get("thread") or {}).get("id")
+        if thread_id and thread_id in self._thread_project:
+            return self._thread_project[thread_id]
+
+        # Some notifications include cwd directly; fall back to the cwd map.
+        cwd = params.get("cwd") or (params.get("thread") or {}).get("cwd")
+        if cwd and cwd in self._cwd_project:
+            return self._cwd_project[cwd]
+
+        return None
+
+    def record_thread(self, thread_id: str, cwd: str, project_id: str) -> None:
+        self._thread_project[thread_id] = project_id
+        self._cwd_project[cwd] = project_id
+
+    async def ensure_started(self) -> None:
+        await self.bridge.start()
+
+
+# A single manager is stored per device agent context.
+def _get_manager(handler: AsyncHandler) -> CodexChatManager:
+    context = handler.context
+    if "codex_manager" not in context:
+        context["codex_manager"] = CodexChatManager(handler.control_channel, context)
+    return context["codex_manager"]
+
+
+def _project_id(message: Dict[str, Any]) -> Optional[str]:
+    return message.get("project_id")
+
+
+class CodexStatusHandler(AsyncHandler):
+    """Report whether Codex is installed and the app-server is healthy."""
+
+    def command_name(self) -> str:
+        return "codex_status"
+
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        installed = bool(CodexAppServer.get_binary_path())
+        version = CodexAppServer.version()
+        ready = False
+        error_message: Optional[str] = None
+
+        if installed:
+            try:
+                manager = _get_manager(self)
+                await manager.ensure_started()
+                ready = await manager.bridge.healthy()
+            except Exception as exc:
+                LOGGER.debug("codex_status: app-server not healthy: %s", exc)
+                error_message = str(exc)
+
+        payload = {
+            "event": "codex_status",
+            "installed": installed,
+            "version": version,
+            "ready": ready,
+        }
+        if error_message:
+            payload["error_message"] = error_message
+        project_id = _project_id(message)
+        if project_id:
+            payload["project_id"] = project_id
+        return payload
+
+
+class CodexThreadListHandler(AsyncHandler):
+    """List Codex threads for a given project cwd."""
+
+    def command_name(self) -> str:
+        return "codex_thread_list"
+
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        cwd = message.get("cwd")
+        if not cwd:
+            raise ValueError("cwd is required")
+
+        manager = _get_manager(self)
+        await manager.ensure_started()
+
+        params: Dict[str, Any] = {"cwd": cwd, "useStateDbOnly": True}
+        limit = message.get("limit")
+        cursor = message.get("cursor")
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+
+        result = await manager.bridge.call("thread/list", params)
+        payload = {
+            "event": "codex_thread_list",
+            "threads": result.get("threads", []),
+            "nextCursor": result.get("nextCursor"),
+        }
+        project_id = _project_id(message)
+        if project_id:
+            payload["project_id"] = project_id
+        return payload
+
+
+class CodexThreadStartHandler(AsyncHandler):
+    """Start a new Codex thread in the project directory."""
+
+    def command_name(self) -> str:
+        return "codex_thread_start"
+
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        cwd = message.get("cwd")
+        project_id = _project_id(message)
+        if not cwd:
+            raise ValueError("cwd is required")
+
+        manager = _get_manager(self)
+        await manager.ensure_started()
+
+        params = {"cwd": cwd}
+        # Optional overrides from the UI (e.g. model picker later).
+        if message.get("model"):
+            params["model"] = message["model"]
+        if message.get("modelProvider"):
+            params["modelProvider"] = message["modelProvider"]
+
+        result = await manager.bridge.call("thread/start", params)
+        thread_id = result.get("id") or result.get("threadId")
+        if not thread_id:
+            raise CodexAppServerError("thread/start did not return a thread id")
+
+        manager.record_thread(thread_id, cwd, project_id or cwd)
+
+        payload = {
+            "event": "codex_thread_started",
+            "threadId": thread_id,
+            "thread": result,
+        }
+        if project_id:
+            payload["project_id"] = project_id
+        return payload
+
+
+class CodexThreadResumeHandler(AsyncHandler):
+    """Resume a Codex thread and return its history."""
+
+    def command_name(self) -> str:
+        return "codex_thread_resume"
+
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        thread_id = message.get("threadId")
+        cwd = message.get("cwd")
+        project_id = _project_id(message)
+        if not thread_id:
+            raise ValueError("threadId is required")
+
+        manager = _get_manager(self)
+        await manager.ensure_started()
+
+        resume_params: Dict[str, Any] = {"threadId": thread_id}
+        if cwd:
+            resume_params["cwd"] = cwd
+        await manager.bridge.call("thread/resume", resume_params)
+
+        read_result = await manager.bridge.call("thread/read", {"threadId": thread_id})
+        items = read_result.get("items", read_result.get("messages", []))
+
+        if cwd and project_id:
+            manager.record_thread(thread_id, cwd, project_id)
+
+        payload = {
+            "event": "codex_thread_resumed",
+            "threadId": thread_id,
+            "items": items,
+        }
+        if project_id:
+            payload["project_id"] = project_id
+        return payload
+
+
+class CodexTurnStartHandler(AsyncHandler):
+    """Send a user turn to a Codex thread."""
+
+    def command_name(self) -> str:
+        return "codex_turn_start"
+
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        thread_id = message.get("threadId")
+        text = message.get("text")
+        if not thread_id:
+            raise ValueError("threadId is required")
+        if text is None or text == "":
+            raise ValueError("text is required")
+
+        manager = _get_manager(self)
+        await manager.ensure_started()
+
+        params = {
+            "threadId": thread_id,
+            "input": [{"type": "text", "text": text}],
+        }
+        # Optional reasoning controls.
+        if message.get("effort"):
+            params["effort"] = message["effort"]
+        if message.get("summary"):
+            params["summary"] = message["summary"]
+
+        result = await manager.bridge.call("turn/start", params)
+        project_id = _project_id(message)
+
+        payload = {
+            "event": "codex_turn_started",
+            "threadId": thread_id,
+            "turn": result,
+        }
+        if project_id:
+            payload["project_id"] = project_id
+        return payload
+
+
+class CodexTurnInterruptHandler(AsyncHandler):
+    """Interrupt a running Codex turn."""
+
+    def command_name(self) -> str:
+        return "codex_turn_interrupt"
+
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        thread_id = message.get("threadId")
+        turn_id = message.get("turnId")
+        if not thread_id or not turn_id:
+            raise ValueError("threadId and turnId are required")
+
+        manager = _get_manager(self)
+        await manager.ensure_started()
+        await manager.bridge.call("turn/interrupt", {"threadId": thread_id, "turnId": turn_id})
+
+        project_id = _project_id(message)
+        payload = {"event": "codex_turn_interrupted", "threadId": thread_id, "turnId": turn_id}
+        if project_id:
+            payload["project_id"] = project_id
+        return payload