portacode 1.5.14.dev1__tar.gz → 1.5.14.dev3__tar.gz

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

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

{portacode-1.5.14.dev1 → portacode-1.5.14.dev3}/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.dev3}/portacode/connection/handlers/codex_handlers.py

@@ -86,20 +86,122 @@ def _project_id(message: Dict[str, Any]) -> Optional[str]:
     return message.get("project_id")
 
 
-class CodexStatusHandler(AsyncHandler):
+def _thread_from_result(result: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalize thread/start|resume|read results to a thread object.
+
+    Current app-server returns `{ "thread": { "id": ... } }`. Older fakes /
+    builds may return the thread fields at the top level.
+    """
+    if not isinstance(result, dict):
+        return {}
+    thread = result.get("thread")
+    if isinstance(thread, dict):
+        return thread
+    return result
+
+
+def _thread_id_from_result(result: Dict[str, Any]) -> Optional[str]:
+    thread = _thread_from_result(result)
+    return thread.get("id") or result.get("id") or result.get("threadId")
+
+
+def _threads_from_list_result(result: Dict[str, Any]) -> tuple[list, Optional[str]]:
+    """Normalize thread/list results.
+
+    Current app-server returns `{ "data": [...], "nextCursor": ... }`.
+    """
+    if not isinstance(result, dict):
+        return [], None
+    threads = result.get("data")
+    if threads is None:
+        threads = result.get("threads")
+    if not isinstance(threads, list):
+        threads = []
+    return threads, result.get("nextCursor")
+
+
+def _items_from_read_result(result: Dict[str, Any]) -> list:
+    """Extract conversation items from thread/read (or legacy shapes)."""
+    if not isinstance(result, dict):
+        return []
+    if isinstance(result.get("items"), list):
+        return result["items"]
+    if isinstance(result.get("messages"), list):
+        return result["messages"]
+
+    thread = _thread_from_result(result)
+    turns = thread.get("turns") or result.get("turns") or []
+    items: list = []
+    if isinstance(turns, list):
+        for turn in turns:
+            if not isinstance(turn, dict):
+                continue
+            turn_items = turn.get("items")
+            if isinstance(turn_items, list):
+                items.extend(turn_items)
+    return items
+
+
+def _turn_from_result(result: Dict[str, Any]) -> Dict[str, Any]:
+    if not isinstance(result, dict):
+        return {}
+    turn = result.get("turn")
+    if isinstance(turn, dict):
+        return turn
+    return result
+
+
+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 +223,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"
 
@@ -135,19 +238,23 @@ class CodexThreadListHandler(AsyncHandler):
         manager = _get_manager(self)
         await manager.ensure_started()
 
-        params: Dict[str, Any] = {"cwd": cwd, "useStateDbOnly": True}
-        limit = message.get("limit")
+        # Default sourceKinds is cli+vscode only; include appServer so IDE chats appear.
+        # Avoid useStateDbOnly:true — it has returned empty lists in some Codex builds.
+        params: Dict[str, Any] = {
+            "cwd": cwd,
+            "sourceKinds": ["cli", "vscode", "appServer"],
+            "limit": message.get("limit") if message.get("limit") is not None else 50,
+        }
         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)
+        threads, next_cursor = _threads_from_list_result(result)
         payload = {
             "event": "codex_thread_list",
-            "threads": result.get("threads", []),
-            "nextCursor": result.get("nextCursor"),
+            "threads": threads,
+            "nextCursor": next_cursor,
         }
         project_id = _project_id(message)
         if project_id:
@@ -155,9 +262,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"
 
@@ -178,7 +286,8 @@ class CodexThreadStartHandler(AsyncHandler):
             params["modelProvider"] = message["modelProvider"]
 
         result = await manager.bridge.call("thread/start", params)
-        thread_id = result.get("id") or result.get("threadId")
+        thread = _thread_from_result(result)
+        thread_id = _thread_id_from_result(result)
         if not thread_id:
             raise CodexAppServerError("thread/start did not return a thread id")
 
@@ -187,16 +296,17 @@ class CodexThreadStartHandler(AsyncHandler):
         payload = {
             "event": "codex_thread_started",
             "threadId": thread_id,
-            "thread": result,
+            "thread": thread,
         }
         if project_id:
             payload["project_id"] = project_id
         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"
 
@@ -215,8 +325,11 @@ class CodexThreadResumeHandler(AsyncHandler):
             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", []))
+        read_result = await manager.bridge.call(
+            "thread/read",
+            {"threadId": thread_id, "includeTurns": True},
+        )
+        items = _items_from_read_result(read_result)
 
         if cwd and project_id:
             manager.record_thread(thread_id, cwd, project_id)
@@ -231,9 +344,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"
 
@@ -264,16 +378,17 @@ class CodexTurnStartHandler(AsyncHandler):
         payload = {
             "event": "codex_turn_started",
             "threadId": thread_id,
-            "turn": result,
+            "turn": _turn_from_result(result),
         }
         if project_id:
             payload["project_id"] = project_id
         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 +409,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 +417,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.dev3}/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.dev3}/portacode/tests/test_codex_handlers.py

@@ -43,11 +43,20 @@ class FakeBridge:
     def __init__(self) -> None:
         self.calls: list[tuple[str, dict]] = []
         self.responses: dict[str, Any] = {
-            "thread/start": {"id": "th-1", "name": "New chat"},
-            "thread/list": {"threads": [{"id": "th-1", "name": "Existing chat"}], "nextCursor": None},
-            "thread/resume": {},
-            "thread/read": {"items": [{"id": "msg-1", "role": "user", "text": "hello"}]},
-            "turn/start": {"id": "turn-1", "threadId": "th-1"},
+            # Match current Codex app-server response shapes.
+            "thread/start": {"thread": {"id": "th-1", "name": "New chat"}},
+            "thread/list": {
+                "data": [{"id": "th-1", "name": "Existing chat", "preview": "hi"}],
+                "nextCursor": None,
+            },
+            "thread/resume": {"thread": {"id": "th-1"}},
+            "thread/read": {
+                "thread": {
+                    "id": "th-1",
+                    "turns": [{"id": "turn-1", "items": [{"id": "msg-1", "role": "user", "text": "hello"}]}],
+                }
+            },
+            "turn/start": {"turn": {"id": "turn-1", "threadId": "th-1"}},
             "turn/interrupt": {},
         }
 
@@ -103,6 +112,11 @@ async def test_codex_thread_list():
     assert payload["event"] == "codex_thread_list"
     assert payload["threads"][0]["id"] == "th-1"
     assert payload["project_id"] == "p-1"
+    list_call = manager.bridge.calls[-1]
+    assert list_call[0] == "thread/list"
+    assert list_call[1]["cwd"] == "/tmp/proj"
+    assert "appServer" in list_call[1]["sourceKinds"]
+    assert "useStateDbOnly" not in list_call[1]
 
 
 @pytest.mark.asyncio
@@ -138,6 +152,8 @@ async def test_codex_thread_resume():
     assert payload["event"] == "codex_thread_resumed"
     assert payload["items"][0]["text"] == "hello"
     assert manager._thread_project["th-1"] == "p-1"
+    read_call = next(c for c in manager.bridge.calls if c[0] == "thread/read")
+    assert read_call[1]["includeTurns"] is True
 
 
 @pytest.mark.asyncio

{portacode-1.5.14.dev1 → portacode-1.5.14.dev3}/portacode.egg-info/PKG-INFO

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