portacode 1.5.14.dev0__tar.gz → 1.5.14.dev2__tar.gz

{portacode-1.5.14.dev0 → portacode-1.5.14.dev2}/PKG-INFO

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

{portacode-1.5.14.dev0 → portacode-1.5.14.dev2}/portacode/_version.py

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

{portacode-1.5.14.dev0 → portacode-1.5.14.dev2}/portacode/connection/codex_app_server.py

@@ -34,7 +34,13 @@ class CodexAppServer:
         _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"}
+        if client_info is None:
+            try:
+                from portacode import __version__ as _portacode_version
+            except Exception:
+                _portacode_version = "dev"
+            client_info = {"name": "portacode", "version": _portacode_version}
+        self.client_info = client_info
         self.on_notification = on_notification
         self._process_factory = _process_factory or asyncio.create_subprocess_exec
 
@@ -120,8 +126,12 @@ class CodexAppServer:
     # JSON-RPC I/O
     # ------------------------------------------------------------------
     async def _initialize(self) -> None:
-        """Send the initialize handshake and wait for its response."""
-        response = await self._request(
+        """Send the initialize handshake and wait for its response.
+
+        Uses `_request_on_running_proc` so we do not re-enter `start()` while
+        `start()` already holds `_lock` (asyncio.Lock is not reentrant).
+        """
+        response = await self._request_on_running_proc(
             "initialize",
             {
                 "clientInfo": self.client_info,
@@ -137,12 +147,18 @@ class CodexAppServer:
     ) -> Dict[str, Any]:
         """Send a JSON-RPC request and return the response object."""
         await self.start()
+        return await self._request_on_running_proc(method, params, timeout=timeout)
+
+    async def _request_on_running_proc(
+        self, method: str, params: Dict[str, Any], timeout: float = 60.0
+    ) -> Dict[str, Any]:
+        """Write a JSON-RPC request to an already-spawned app-server process."""
         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)
+        payload = json.dumps(message, ensure_ascii=False, separators=(",", ":"))
 
         loop = asyncio.get_running_loop()
         future: asyncio.Future = loop.create_future()
@@ -166,7 +182,7 @@ class CodexAppServer:
         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)
+        payload = json.dumps(message, ensure_ascii=False, separators=(",", ":"))
         self._proc.stdin.write((payload + "\n").encode("utf-8"))
         await self._proc.stdin.drain()
 
@@ -174,7 +190,7 @@ class CodexAppServer:
         """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)
+        payload = json.dumps(response, ensure_ascii=False, separators=(",", ":"))
         self._proc.stdin.write((payload + "\n").encode("utf-8"))
         await self._proc.stdin.drain()
 

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

@@ -68,6 +68,7 @@ from .codex_handlers import (
     CodexThreadResumeHandler,
     CodexTurnStartHandler,
     CodexTurnInterruptHandler,
+    CodexPrepareHandler,
 )
 
 __all__ = [
@@ -127,4 +128,5 @@ __all__ = [
     "CodexThreadResumeHandler",
     "CodexTurnStartHandler",
     "CodexTurnInterruptHandler",
+    "CodexPrepareHandler",
 ]

{portacode-1.5.14.dev0 → portacode-1.5.14.dev2}/portacode/connection/handlers/codex_handlers.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import Any, Dict, Optional
 
@@ -85,20 +86,57 @@ def _project_id(message: Dict[str, Any]) -> Optional[str]:
     return message.get("project_id")
 
 
-class CodexStatusHandler(AsyncHandler):
+class CodexAsyncHandler(AsyncHandler):
+    """AsyncHandler that replies to `source_client_session` per WEBSOCKET_PROTOCOL.md."""
+
+    async def handle(self, message: Dict[str, Any], reply_channel: Optional[str] = None) -> None:
+        try:
+            response = await self.execute(message)
+            if response is None:
+                return
+            if "request_id" in message and "request_id" not in response:
+                response["request_id"] = message["request_id"]
+
+            source_client_session = message.get("source_client_session")
+            project_id = response.get("project_id") or _project_id(message)
+            if project_id and "project_id" not in response:
+                response["project_id"] = project_id
+
+            if source_client_session:
+                payload = dict(response)
+                payload["client_sessions"] = [source_client_session]
+                await self.control_channel.send(payload)
+                return
+
+            await self.send_response(response, reply_channel, project_id)
+        except Exception as exc:
+            LOGGER.exception("handler: Error in codex handler %s: %s", self.command_name, exc)
+            await self.send_error(
+                str(exc),
+                reply_channel,
+                _project_id(message),
+                request_id=message.get("request_id"),
+            )
+
+
+class CodexStatusHandler(CodexAsyncHandler):
     """Report whether Codex is installed and the app-server is healthy."""
 
+    @property
     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()
+        # Avoid blocking the asyncio loop with a sync subprocess during status.
+        version = None
         ready = False
         error_message: Optional[str] = None
 
         if installed:
             try:
+                loop = asyncio.get_running_loop()
+                version = await loop.run_in_executor(None, CodexAppServer.version)
                 manager = _get_manager(self)
                 await manager.ensure_started()
                 ready = await manager.bridge.healthy()
@@ -120,9 +158,10 @@ class CodexStatusHandler(AsyncHandler):
         return payload
 
 
-class CodexThreadListHandler(AsyncHandler):
+class CodexThreadListHandler(CodexAsyncHandler):
     """List Codex threads for a given project cwd."""
 
+    @property
     def command_name(self) -> str:
         return "codex_thread_list"
 
@@ -154,9 +193,10 @@ class CodexThreadListHandler(AsyncHandler):
         return payload
 
 
-class CodexThreadStartHandler(AsyncHandler):
+class CodexThreadStartHandler(CodexAsyncHandler):
     """Start a new Codex thread in the project directory."""
 
+    @property
     def command_name(self) -> str:
         return "codex_thread_start"
 
@@ -193,9 +233,10 @@ class CodexThreadStartHandler(AsyncHandler):
         return payload
 
 
-class CodexThreadResumeHandler(AsyncHandler):
+class CodexThreadResumeHandler(CodexAsyncHandler):
     """Resume a Codex thread and return its history."""
 
+    @property
     def command_name(self) -> str:
         return "codex_thread_resume"
 
@@ -230,9 +271,10 @@ class CodexThreadResumeHandler(AsyncHandler):
         return payload
 
 
-class CodexTurnStartHandler(AsyncHandler):
+class CodexTurnStartHandler(CodexAsyncHandler):
     """Send a user turn to a Codex thread."""
 
+    @property
     def command_name(self) -> str:
         return "codex_turn_start"
 
@@ -270,9 +312,10 @@ class CodexTurnStartHandler(AsyncHandler):
         return payload
 
 
-class CodexTurnInterruptHandler(AsyncHandler):
+class CodexTurnInterruptHandler(CodexAsyncHandler):
     """Interrupt a running Codex turn."""
 
+    @property
     def command_name(self) -> str:
         return "codex_turn_interrupt"
 
@@ -291,3 +334,53 @@ class CodexTurnInterruptHandler(AsyncHandler):
         if project_id:
             payload["project_id"] = project_id
         return payload
+
+
+class CodexPrepareHandler(CodexAsyncHandler):
+    """Run `portacode prepare codex` on the device in the background.
+
+    Streams progress as `codex_prepare_progress` events and finishes with a
+    `codex_prepare_done` event so the chat UI can react (re-check status or
+    show manual instructions when sudo is required).
+    """
+
+    @property
+    def command_name(self) -> str:
+        return "codex_prepare"
+
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        project_id = _project_id(message)
+        manager = _get_manager(self)
+        if getattr(manager, "_prepare_running", False):
+            payload = {"event": "codex_prepare_started", "already_running": True}
+            if project_id:
+                payload["project_id"] = project_id
+            return payload
+
+        manager._prepare_running = True
+        asyncio.create_task(self._run_prepare(manager, project_id))
+
+        payload = {"event": "codex_prepare_started"}
+        if project_id:
+            payload["project_id"] = project_id
+        return payload
+
+    async def _run_prepare(self, manager: CodexChatManager, project_id: Optional[str]) -> None:
+        from portacode.codex_prepare import CodexPreparationError, prepare_codex
+
+        try:
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, prepare_codex)
+            payload = {"event": "codex_prepare_done", "success": True}
+        except CodexPreparationError as exc:
+            LOGGER.warning("codex_prepare failed: %s", exc)
+            payload = {"event": "codex_prepare_done", "success": False, "error": str(exc)}
+        except Exception as exc:  # pragma: no cover - defensive
+            LOGGER.exception("codex_prepare crashed")
+            payload = {"event": "codex_prepare_done", "success": False, "error": str(exc)}
+        finally:
+            manager._prepare_running = False
+
+        if project_id:
+            payload["project_id"] = project_id
+        await manager.sender.send(payload, project_id=project_id)

{portacode-1.5.14.dev0 → portacode-1.5.14.dev2}/portacode/connection/terminal.py

@@ -74,6 +74,7 @@ from .handlers import (
     CodexThreadResumeHandler,
     CodexTurnStartHandler,
     CodexTurnInterruptHandler,
+    CodexPrepareHandler,
 )
 from .handlers.project_aware_file_handlers import (
     ProjectAwareFileWriteHandler,
@@ -559,6 +560,7 @@ class TerminalManager:
         self._command_registry.register(CodexThreadResumeHandler)
         self._command_registry.register(CodexTurnStartHandler)
         self._command_registry.register(CodexTurnInterruptHandler)
+        self._command_registry.register(CodexPrepareHandler)
 
     # ---------------------------------------------------------------------
     # Control loop – receives commands from gateway

{portacode-1.5.14.dev0 → portacode-1.5.14.dev2}/portacode/tests/test_codex_app_server.py

@@ -11,11 +11,14 @@ from portacode.connection.codex_app_server import CodexAppServer, CodexAppServer
 
 
 class FakeWriteStream:
-    def __init__(self) -> None:
+    def __init__(self, process: "FakeProcess | None" = None) -> None:
         self.written: list[bytes] = []
+        self._process = process
 
     def write(self, data: bytes) -> None:
         self.written.append(data)
+        if self._process is not None:
+            self._process._maybe_auto_respond(data)
 
     async def drain(self) -> None:
         pass
@@ -41,13 +44,38 @@ class FakeReadStream:
 class FakeProcess:
     returncode: int | None = None
 
-    def __init__(self, responses: list[dict] | None = None) -> None:
+    def __init__(
+        self,
+        responses: list[dict] | None = None,
+        *,
+        auto_initialize: bool = False,
+    ) -> None:
         self.queue: asyncio.Queue[bytes] = asyncio.Queue()
         for response in responses or []:
-            self.queue.put_nowait((json.dumps(response) + "\n").encode("utf-8"))
-        self.stdin = FakeWriteStream()
+            self.queue.put_nowait(
+                (json.dumps(response, separators=(",", ":")) + "\n").encode("utf-8")
+            )
+        self.stdin = FakeWriteStream(self if auto_initialize else None)
         self.stdout = FakeReadStream(self.queue)
         self.stderr = FakeReadStream(asyncio.Queue())
+        self._auto_initialize = auto_initialize
+
+    def _maybe_auto_respond(self, data: bytes) -> None:
+        if not self._auto_initialize:
+            return
+        try:
+            message = json.loads(data.decode("utf-8").strip())
+        except Exception:
+            return
+        if message.get("method") != "initialize":
+            return
+        request_id = message.get("id")
+        if request_id is None:
+            return
+        self.queue.put_nowait((json.dumps(
+            {"jsonrpc": "2.0", "id": request_id, "result": {"protocolVersion": "v2"}},
+            separators=(",", ":"),
+        ) + "\n").encode("utf-8"))
 
     async def wait(self) -> int:
         return self.returncode or 0
@@ -85,12 +113,28 @@ async def test_initialize_handshake():
 
 @pytest.mark.asyncio
 async def test_request_response_correlation():
+    # Only preload the initialize response. Queuing the call response early can
+    # race the reader ahead of the pending-future registration.
     proc = FakeProcess([
         {"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": "v2"}},
-        {"jsonrpc": "2.0", "id": 2, "result": {"id": "th-abc", "name": "test"}},
     ])
     bridge = CodexAppServer(_process_factory=_factory_for(proc))
+    await bridge.start()
+
+    async def _respond_to_thread_start() -> None:
+        # Wait until the request is written, then enqueue the matching response.
+        for _ in range(50):
+            if any(b'"method":"thread/start"' in chunk for chunk in proc.stdin.written):
+                break
+            await asyncio.sleep(0.01)
+        proc.queue.put_nowait((json.dumps(
+            {"jsonrpc": "2.0", "id": 2, "result": {"id": "th-abc", "name": "test"}},
+            separators=(",", ":"),
+        ) + "\n").encode("utf-8"))
+
+    respond_task = asyncio.create_task(_respond_to_thread_start())
     result = await bridge.call("thread/start", {"cwd": "/tmp/proj"})
+    await respond_task
 
     assert result["id"] == "th-abc"
     assert any(b'"method":"thread/start"' in chunk and b'/tmp/proj' in chunk for chunk in proc.stdin.written)
@@ -148,7 +192,8 @@ async def test_missing_binary_raises():
 @pytest.mark.asyncio
 async def test_restart_after_crash():
     first = FakeProcess([{"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": "v2"}}])
-    second = FakeProcess([{"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": "v2"}}])
+    # Auto-echo initialize with whatever request id the restarted bridge uses.
+    second = FakeProcess(auto_initialize=True)
 
     bridge = CodexAppServer(_process_factory=_factory_for(first, second))
     await bridge.start()

{portacode-1.5.14.dev0 → portacode-1.5.14.dev2}/portacode.egg-info/PKG-INFO

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

{portacode-1.5.14.dev0 → portacode-1.5.14.dev2}/portacode.egg-info/SOURCES.txt

@@ -340,6 +340,7 @@ portacode/connection/handlers/project_state/models.py
 portacode/connection/handlers/project_state/test_handlers.py
 portacode/connection/handlers/project_state/utils.py
 portacode/link_capture/__init__.py
+portacode/link_capture/__pycache__/__init__.cpython-311.pyc
 portacode/link_capture/bin/elinks
 portacode/link_capture/bin/gio-open
 portacode/link_capture/bin/gnome-open