portacode 1.5.17.dev4__tar.gz → 1.5.18.dev0__tar.gz

{portacode-1.5.17.dev4 → portacode-1.5.18.dev0}/PKG-INFO

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

{portacode-1.5.17.dev4 → portacode-1.5.18.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.17.dev4'
-__version_tuple__ = version_tuple = (1, 5, 17, 'dev4')
+__version__ = version = '1.5.18.dev0'
+__version_tuple__ = version_tuple = (1, 5, 18, 'dev0')
 
 __commit_id__ = commit_id = None

{portacode-1.5.17.dev4 → portacode-1.5.18.dev0}/portacode/connection/codex_app_server.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import os
 import shutil
 import uuid
 from pathlib import Path
@@ -32,6 +33,7 @@ class CodexAppServer:
         command: Optional[List[str]] = None,
         client_info: Optional[Dict[str, Any]] = None,
         on_notification: Optional[Callable[[str, Dict[str, Any]], Awaitable[None]]] = None,
+        on_unexpected_exit: Optional[Callable[[Optional[int]], Awaitable[None]]] = None,
         _process_factory: Optional[Callable[..., Awaitable[Any]]] = None,
     ) -> None:
         self.command = command or list(DEFAULT_CODEX_COMMAND)
@@ -43,6 +45,7 @@ class CodexAppServer:
             client_info = {"name": "portacode", "version": _portacode_version}
         self.client_info = client_info
         self.on_notification = on_notification
+        self.on_unexpected_exit = on_unexpected_exit
         self._process_factory = _process_factory or asyncio.create_subprocess_exec
 
         self._proc: Optional[asyncio.subprocess.Process] = None
@@ -74,12 +77,6 @@ class CodexAppServer:
 
     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."
-            )
-
         # systemd services do not load shell profile env; merge /etc/portacode/codex.env.
         from portacode.codex_prepare import build_codex_subprocess_env, ensure_codex_home
         from portacode.connection.handlers.runtime_user import (
@@ -93,9 +90,16 @@ class CodexAppServer:
         # (e.g. bishoy), not as the root agent process.
         runtime_user = get_default_runtime_user()
         runtime_home = get_runtime_user_home()
+        exe = self._resolve_command_path(self.command[0], runtime_home)
+        if not exe:
+            raise CodexAppServerError(
+                f"{self.command[0]} not found for runtime user {runtime_user}. "
+                "Run `portacode prepare codex` on this device."
+            )
         child_env["HOME"] = runtime_home
         child_env["USER"] = runtime_user
         child_env["LOGNAME"] = runtime_user
+        self._prepend_executable_directory(child_env, exe)
         try:
             child_env["CODEX_HOME"] = str(ensure_codex_home())
         except Exception:
@@ -123,7 +127,7 @@ class CodexAppServer:
             "no_proxy",
         ]
         spawn_cmd = wrap_argv_for_user(
-            self.command,
+            [exe, *self.command[1:]],
             runtime_user,
             preserve_env_names=preserve,
             login=False,
@@ -382,6 +386,11 @@ class CodexAppServer:
                 )
                 return
             LOGGER.warning("Codex app-server process exited (code %s); restarting", self._proc.returncode)
+            if self.on_unexpected_exit is not None:
+                try:
+                    await self.on_unexpected_exit(self._proc.returncode)
+                except Exception:
+                    LOGGER.exception("Codex app-server exit handler failed")
             await self._kill_locked()
         try:
             await self.start()
@@ -415,19 +424,69 @@ class CodexAppServer:
         return self._initialized.is_set()
 
     @staticmethod
-    def get_binary_path() -> Optional[str]:
-        return shutil.which("codex")
+    def get_binary_path(runtime_home: Optional[str] = None) -> Optional[str]:
+        """Find Codex for the service's configured runtime user.
+
+        A systemd agent normally has a deliberately small PATH.  That should
+        not hide a Codex CLI installed by the runtime user through nvm or a
+        local npm prefix, which is common on developer machines.
+        """
+        from portacode.connection.handlers.runtime_user import get_runtime_user_home
+
+        return CodexAppServer._resolve_command_path(
+            "codex", runtime_home or get_runtime_user_home()
+        )
+
+    @staticmethod
+    def _resolve_command_path(command: str, runtime_home: Optional[str] = None) -> Optional[str]:
+        if not command:
+            return None
+        resolved = shutil.which(command)
+        if resolved:
+            return resolved
+
+        candidate = Path(command).expanduser()
+        if candidate.is_absolute() or candidate.parent != Path("."):
+            if candidate.is_file() and os.access(str(candidate), os.X_OK):
+                return str(candidate)
+            return None
+        if command not in {"codex", "codex.cmd"}:
+            return None
+
+        home = Path(runtime_home or Path.home()).expanduser()
+        candidates = [
+            home / ".local" / "bin" / command,
+            home / ".npm" / "bin" / command,
+        ]
+        nvm_root = home / ".nvm" / "versions" / "node"
+        if nvm_root.is_dir():
+            candidates.extend(sorted(nvm_root.glob("*/bin/" + command), reverse=True))
+        for candidate in candidates:
+            if candidate.is_file() and os.access(str(candidate), os.X_OK):
+                return str(candidate)
+        return None
+
+    @staticmethod
+    def _prepend_executable_directory(env: Dict[str, str], executable: str) -> None:
+        """Make the Node interpreter beside an npm launcher available to env."""
+        executable_dir = str(Path(executable).parent)
+        current_path = env.get("PATH") or os.defpath
+        entries = current_path.split(os.pathsep)
+        if executable_dir not in entries:
+            env["PATH"] = os.pathsep.join([executable_dir, current_path])
 
     @staticmethod
     def version() -> Optional[str]:
         import subprocess
 
-        exe = shutil.which("codex")
+        exe = CodexAppServer.get_binary_path()
         if not exe:
             return None
         try:
+            env = dict(os.environ)
+            CodexAppServer._prepend_executable_directory(env, exe)
             result = subprocess.run(
-                [exe, "--version"], capture_output=True, text=True, timeout=10
+                [exe, "--version"], capture_output=True, text=True, timeout=10, env=env
             )
             return result.stdout.strip() or None
         except Exception:

{portacode-1.5.17.dev4 → portacode-1.5.18.dev0}/portacode/connection/handlers/codex_handlers.py

@@ -87,17 +87,23 @@ class _SessionAwareSender:
         self.control_channel = control_channel
         self.context = context
 
-    async def send(self, payload: Dict[str, Any], project_id: Optional[str] = None) -> None:
+    async def send(
+        self,
+        payload: Dict[str, Any],
+        project_id: Optional[str] = None,
+        explicit_sessions: Optional[List[str]] = None,
+    ) -> None:
+        target_sessions = set(explicit_sessions or [])
         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
+            target_sessions.update(client_session_manager.get_target_sessions(project_id))
             reply_channel = client_session_manager.get_reply_channel_for_compatibility()
             if reply_channel:
                 payload = dict(payload)
                 payload["reply_channel"] = reply_channel
+        if target_sessions:
+            payload = dict(payload)
+            payload["client_sessions"] = sorted(target_sessions)
 
         await self.control_channel.send(payload)
 
@@ -107,14 +113,46 @@ class CodexChatManager:
 
     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.bridge = CodexAppServer(
+            on_notification=self._on_notification,
+            on_unexpected_exit=self._on_bridge_exit,
+        )
         self._thread_project: Dict[str, str] = {}
         self._cwd_project: Dict[str, str] = {}
+        self._thread_active_turn: Dict[str, str] = {}
+        self._thread_sessions: Dict[str, set[str]] = {}
         # Survives page reloads via codex_status so the IDE can restore UI.
         self._prepare_running = False
         self._prepare_step: Optional[str] = None
         self._prepare_error: Optional[str] = None
 
+    async def _on_bridge_exit(self, returncode: Optional[int]) -> None:
+        """Turn an app-server crash into terminal events for waiting browsers."""
+        active = list(self._thread_active_turn.items())
+        self._thread_active_turn.clear()
+        for thread_id, turn_id in active:
+            project_id = self._thread_project.get(thread_id)
+            if not project_id:
+                continue
+            suffix = f" (exit code {returncode})" if returncode is not None else ""
+            params = {
+                "threadId": thread_id,
+                "turnId": turn_id,
+                "error": {
+                    "message": f"The local Codex app-server stopped unexpectedly{suffix}.",
+                    "additionalDetails": "Portacode is restarting it. Retry the message after it reconnects.",
+                },
+            }
+            await self.sender.send(
+                {
+                    "event": "codex_event",
+                    "notification": {"method": "error", "params": params},
+                    "project_id": project_id,
+                },
+                project_id=project_id,
+                explicit_sessions=list(self._thread_sessions.get(thread_id, set())),
+            )
+
     async def _on_notification(self, method: str, params: Dict[str, Any]) -> None:
         # Attach usage-limit reset timestamp captured by the loopback proxy.
         if method == "error" or (
@@ -131,6 +169,13 @@ class CodexChatManager:
                 params["turn"] = turn
 
         self._remember_thread_from_params(params)
+        thread_id = params.get("threadId") or (params.get("thread") or {}).get("id")
+        turn = params.get("turn") if isinstance(params.get("turn"), dict) else {}
+        turn_id = params.get("turnId") or turn.get("id")
+        if thread_id and method == "turn/started" and turn_id:
+            self._thread_active_turn[str(thread_id)] = str(turn_id)
+        elif thread_id and method == "turn/completed":
+            self._thread_active_turn.pop(str(thread_id), None)
         project_id = self._resolve_project_id(params)
         if not project_id:
             # Unresolved project_id would fan out to every open project tab.
@@ -144,7 +189,11 @@ class CodexChatManager:
             "notification": {"method": method, "params": params},
             "project_id": project_id,
         }
-        await self.sender.send(event_payload, project_id=project_id)
+        await self.sender.send(
+            event_payload,
+            project_id=project_id,
+            explicit_sessions=list(self._thread_sessions.get(str(thread_id), set())) if thread_id else None,
+        )
 
     def _remember_thread_from_params(self, params: Dict[str, Any]) -> None:
         """Opportunistically map threadId → project when cwd is already known."""
@@ -175,6 +224,16 @@ class CodexChatManager:
         if cwd and project_id:
             self._cwd_project[cwd] = project_id
 
+    def subscribe_thread(self, thread_id: str, client_session: Optional[str]) -> None:
+        """Route future thread events to a tab even before session discovery catches up."""
+        if not thread_id or not client_session:
+            return
+        sessions = self._thread_sessions.setdefault(str(thread_id), set())
+        sessions.add(str(client_session))
+        # Avoid an unbounded collection of stale channel names after many reconnects.
+        while len(sessions) > 32:
+            sessions.pop()
+
     async def ensure_started(self) -> None:
         await self.bridge.start()
 
@@ -544,6 +603,7 @@ class CodexThreadStartHandler(CodexAsyncHandler):
             raise CodexAppServerError("thread/start did not return a thread id")
 
         manager.record_thread(thread_id, cwd, project_id or cwd)
+        manager.subscribe_thread(thread_id, message.get("source_client_session"))
 
         payload = {
             "event": "codex_thread_started",
@@ -572,14 +632,17 @@ class CodexThreadResumeHandler(CodexAsyncHandler):
         manager = _get_manager(self)
         await manager.ensure_started()
 
+        # thread/resume can emit notifications before its RPC response. Route
+        # those notifications to the requesting project from the outset.
+        if project_id:
+            manager.record_thread(thread_id, cwd, project_id)
+        manager.subscribe_thread(thread_id, message.get("source_client_session"))
+
         resume_result, items, active_turn = await _resume_thread_history(
             manager, thread_id=thread_id, cwd=cwd
         )
         thread = _thread_from_result(resume_result)
 
-        if project_id:
-            manager.record_thread(thread_id, cwd, project_id)
-
         payload = {
             "event": "codex_thread_resumed",
             "threadId": thread_id,
@@ -588,6 +651,9 @@ class CodexThreadResumeHandler(CodexAsyncHandler):
         }
         if active_turn:
             payload["activeTurn"] = active_turn
+            active_turn_id = active_turn.get("id") or active_turn.get("turnId")
+            if active_turn_id:
+                manager._thread_active_turn[str(thread_id)] = str(active_turn_id)
         if project_id:
             payload["project_id"] = project_id
         return payload
@@ -614,6 +680,15 @@ class CodexTurnStartHandler(CodexAsyncHandler):
         manager = _get_manager(self)
         await manager.ensure_started()
 
+        project_id = _project_id(message)
+        cwd = message.get("cwd")
+        # Codex may emit turn/started, retry, or terminal error notifications
+        # before the turn/start RPC response. Establish routing before the call
+        # so the browser cannot miss the event that clears its streaming state.
+        if project_id:
+            manager.record_thread(thread_id, cwd, project_id)
+        manager.subscribe_thread(thread_id, message.get("source_client_session"))
+
         params = {
             "threadId": thread_id,
             "input": _build_turn_input(text or "", attachments),
@@ -627,15 +702,15 @@ class CodexTurnStartHandler(CodexAsyncHandler):
             params["summary"] = message["summary"]
 
         result = await manager.bridge.call("turn/start", params)
-        project_id = _project_id(message)
-        cwd = message.get("cwd")
-        if project_id:
-            manager.record_thread(thread_id, cwd, project_id)
+        turn = _turn_from_result(result)
+        turn_id = turn.get("id") or turn.get("turnId")
+        if turn_id:
+            manager._thread_active_turn[str(thread_id)] = str(turn_id)
 
         payload = {
             "event": "codex_turn_started",
             "threadId": thread_id,
-            "turn": _turn_from_result(result),
+            "turn": turn,
         }
         if project_id:
             payload["project_id"] = project_id
@@ -652,12 +727,16 @@ class CodexTurnInterruptHandler(CodexAsyncHandler):
     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")
+        if not thread_id:
+            raise ValueError("threadId is required")
 
         manager = _get_manager(self)
+        turn_id = turn_id or manager._thread_active_turn.get(str(thread_id))
+        if not turn_id:
+            raise ValueError("No active turn was found for this thread")
         await manager.ensure_started()
         await manager.bridge.call("turn/interrupt", {"threadId": thread_id, "turnId": turn_id})
+        manager._thread_active_turn.pop(str(thread_id), None)
 
         project_id = _project_id(message)
         payload = {"event": "codex_turn_interrupted", "threadId": thread_id, "turnId": turn_id}

{portacode-1.5.17.dev4 → portacode-1.5.18.dev0}/portacode/connection/handlers/project_state/git_manager.py

@@ -5,6 +5,8 @@ including status checking, diff generation, file content retrieval, and Git comm
 like staging, unstaging, and reverting files.
 """
 
+from __future__ import annotations
+
 import asyncio
 import hashlib
 import logging

{portacode-1.5.17.dev4 → portacode-1.5.18.dev0}/portacode/tests/test_codex_app_server.py

@@ -193,11 +193,40 @@ async def test_spawn_runs_as_runtime_user(tmp_path, monkeypatch):
     await bridge.start()
     assert seen
     assert seen[0][:5] == ("/usr/sbin/runuser", "-u", "bishoy", "--preserve-environment", "--")
-    assert "codex" in seen[0]
+    assert "/usr/bin/codex" in seen[0]
     assert seen_kwargs[0].get("cwd") == str(home)
     await bridge.stop()
 
 
+@pytest.mark.asyncio
+async def test_spawn_finds_nvm_codex_when_service_path_does_not(tmp_path, monkeypatch):
+    """A systemd PATH must not hide a runtime user's nvm-installed Codex."""
+    home = tmp_path / "home"
+    codex_bin = home / ".nvm" / "versions" / "node" / "v24.4.1" / "bin"
+    codex_bin.mkdir(parents=True)
+    codex = codex_bin / "codex"
+    codex.write_text("#!/usr/bin/env node\n", encoding="utf-8")
+    codex.chmod(0o755)
+    monkeypatch.setenv("PATH", "/usr/bin:/bin")
+    monkeypatch.setattr(
+        "portacode.connection.handlers.runtime_user.get_default_runtime_user",
+        lambda message=None: "menas",
+    )
+    monkeypatch.setattr(
+        "portacode.connection.handlers.runtime_user.get_runtime_user_home",
+        lambda message=None: str(home),
+    )
+    monkeypatch.setattr("portacode.codex_prepare.ensure_codex_home", lambda: home / ".codex")
+
+    proc = FakeProcess([{"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": "v2"}}])
+    bridge = CodexAppServer(_process_factory=_factory_for(proc))
+    await bridge.start()
+
+    assert CodexAppServer.get_binary_path(str(home)) == str(codex)
+    assert proc.spawn_kwargs["env"]["PATH"].split(":")[0] == str(codex_bin)
+    await bridge.stop()
+
+
 def test_build_codex_subprocess_env_reads_managed_file(tmp_path):
     from portacode.codex_prepare import build_codex_subprocess_env
 

{portacode-1.5.17.dev4 → portacode-1.5.18.dev0}/portacode/tests/test_codex_handlers.py

@@ -330,6 +330,47 @@ async def test_codex_turn_interrupt():
     assert manager.bridge.calls[-1] == ("turn/interrupt", {"threadId": "th-1", "turnId": "turn-1"})
 
 
+@pytest.mark.asyncio
+async def test_codex_turn_interrupt_resolves_active_turn_when_browser_missed_id():
+    channel = DummyControlChannel()
+    context = _context()
+    manager = CodexChatManager(channel, context)
+    manager.bridge = FakeBridge()
+    manager._thread_active_turn["th-1"] = "turn-active"
+    context["codex_manager"] = manager
+
+    handler = CodexTurnInterruptHandler(channel, context)
+    await handler.handle(
+        {"cmd": "codex_turn_interrupt", "project_id": "p-1", "threadId": "th-1"},
+        reply_channel="rc-1",
+    )
+
+    assert manager.bridge.calls[-1] == (
+        "turn/interrupt",
+        {"threadId": "th-1", "turnId": "turn-active"},
+    )
+    assert "th-1" not in manager._thread_active_turn
+
+
+@pytest.mark.asyncio
+async def test_codex_bridge_exit_terminates_active_browser_turn():
+    channel = DummyControlChannel()
+    context = _context()
+    manager = CodexChatManager(channel, context)
+    manager.record_thread("th-1", "/tmp/proj", "p-1")
+    manager._thread_active_turn["th-1"] = "turn-1"
+
+    await manager._on_bridge_exit(137)
+
+    payload = channel.sent[-1]
+    assert payload["event"] == "codex_event"
+    assert payload["project_id"] == "p-1"
+    assert payload["notification"]["method"] == "error"
+    assert payload["notification"]["params"]["turnId"] == "turn-1"
+    assert "exit code 137" in payload["notification"]["params"]["error"]["message"]
+    assert not manager._thread_active_turn
+
+
 @pytest.mark.asyncio
 async def test_notification_forwarding_targets_project():
     channel = DummyControlChannel()
@@ -346,6 +387,22 @@ async def test_notification_forwarding_targets_project():
     assert payload["client_sessions"] == ["sess-1"]
 
 
+@pytest.mark.asyncio
+async def test_resumed_thread_events_include_new_tab_before_session_registry_updates():
+    channel = DummyControlChannel()
+    context = _context()
+    manager = CodexChatManager(channel, context)
+    manager.record_thread("th-1", "/tmp/proj", "p-1")
+    manager.subscribe_thread("th-1", "new-tab-session")
+
+    await manager._on_notification(
+        "item/agentMessage/delta",
+        {"threadId": "th-1", "delta": "live"},
+    )
+
+    assert channel.sent[-1]["client_sessions"] == ["new-tab-session", "sess-1"]
+
+
 @pytest.mark.asyncio
 async def test_notification_without_project_mapping_is_dropped():
     channel = DummyControlChannel()
@@ -378,6 +435,45 @@ async def test_codex_turn_start_records_thread_mapping():
     assert manager._cwd_project["/tmp/proj"] == "p-1"
 
 
+@pytest.mark.asyncio
+async def test_codex_turn_start_routes_notification_before_rpc_response():
+    channel = DummyControlChannel()
+    context = _context()
+    manager = CodexChatManager(channel, context)
+    manager.bridge = FakeBridge()
+    context["codex_manager"] = manager
+
+    async def call(method: str, params: dict, timeout: float = 60.0):
+        assert method == "turn/start"
+        await manager._on_notification(
+            "error",
+            {
+                "threadId": "th-9",
+                "turnId": "turn-1",
+                "willRetry": False,
+                "error": {"message": "request failed"},
+            },
+        )
+        return {"turn": {"id": "turn-1"}}
+
+    manager.bridge.call = call  # type: ignore[method-assign]
+    handler = CodexTurnStartHandler(channel, context)
+    await handler.handle(
+        {
+            "cmd": "codex_turn_start",
+            "project_id": "p-1",
+            "threadId": "th-9",
+            "cwd": "/tmp/proj",
+            "text": "hi",
+        },
+        reply_channel="rc-1",
+    )
+
+    notification = next(item for item in channel.sent if item.get("event") == "codex_event")
+    assert notification["project_id"] == "p-1"
+    assert notification["notification"]["method"] == "error"
+
+
 @pytest.mark.asyncio
 async def test_codex_thread_resume_includes_active_turn():
     channel = DummyControlChannel()