portacode 1.5.14.dev1__tar.gz → 1.5.14.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.14.dev1
+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.dev1 → 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.dev1'
-__version_tuple__ = version_tuple = (1, 5, 14, 'dev1')
+__version__ = version = '1.5.14.dev2'
+__version_tuple__ = version_tuple = (1, 5, 14, 'dev2')
 
 __commit_id__ = commit_id = None

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

@@ -126,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,
@@ -143,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()
@@ -172,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()
 
@@ -180,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.dev1 → portacode-1.5.14.dev2}/portacode/connection/handlers/codex_handlers.py

@@ -86,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()
@@ -121,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"
 
@@ -155,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"
 
@@ -194,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"
 
@@ -231,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"
 
@@ -271,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"
 
@@ -294,7 +336,7 @@ class CodexTurnInterruptHandler(AsyncHandler):
         return payload
 
 
-class CodexPrepareHandler(AsyncHandler):
+class CodexPrepareHandler(CodexAsyncHandler):
     """Run `portacode prepare codex` on the device in the background.
 
     Streams progress as `codex_prepare_progress` events and finishes with a
@@ -302,6 +344,7 @@ class CodexPrepareHandler(AsyncHandler):
     show manual instructions when sudo is required).
     """
 
+    @property
     def command_name(self) -> str:
         return "codex_prepare"
 

{portacode-1.5.14.dev1 → 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.dev1 → portacode-1.5.14.dev2}/portacode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.14.dev1
+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.dev1 → 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