portacode 1.5.29.dev0__tar.gz → 1.5.31.dev0__tar.gz

{portacode-1.5.29.dev0 → portacode-1.5.31.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.29.dev0
+Version: 1.5.31.dev0
 Summary: Connect real machines to the Portacode AI development environment
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.5.29.dev0 → portacode-1.5.31.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.29.dev0'
-__version_tuple__ = version_tuple = (1, 5, 29, 'dev0')
+__version__ = version = '1.5.31.dev0'
+__version_tuple__ = version_tuple = (1, 5, 31, 'dev0')
 
 __commit_id__ = commit_id = None

{portacode-1.5.29.dev0 → portacode-1.5.31.dev0}/portacode/codex_prepare.py

@@ -343,6 +343,12 @@ def ensure_codex_home() -> Path:
     sessions_dir = codex_home / "sessions"
     sessions_dir.mkdir(parents=True, exist_ok=True)
 
+    # The Portacode service may run as root even though Codex is launched as
+    # the requested runtime user. Repair the two directories we create here
+    # unconditionally so a root service cannot leave Codex unable to save
+    # threads. Keep this non-recursive to avoid touching live session files.
+    _repair_codex_home_ownership(codex_home, sessions_dir)
+
     root_codex = Path("/root/.codex")
     root_sessions = root_codex / "sessions"
     seeded_paths: list[Path] = []
@@ -405,6 +411,20 @@ def ensure_codex_home() -> Path:
     return codex_home
 
 
+def _repair_codex_home_ownership(codex_home: Path, sessions_dir: Path) -> None:
+    try:
+        from portacode.connection.handlers.runtime_user import (
+            chown_path_if_possible,
+            get_default_runtime_user,
+        )
+
+        owner = get_default_runtime_user()
+        chown_path_if_possible(codex_home, owner)
+        chown_path_if_possible(sessions_dir, owner)
+    except Exception:
+        pass
+
+
 def apply_codex_env_to_mapping(
     env: MutableMapping[str, str],
     path: Optional[Path] = None,

{portacode-1.5.29.dev0 → portacode-1.5.31.dev0}/portacode/connection/handlers/browser_handlers.py

@@ -12,6 +12,7 @@ from pathlib import Path
 from typing import Any, Dict
 
 from .base import AsyncHandler
+from .chunked_content import create_chunked_response, should_chunk_content
 from .runtime_user import get_default_runtime_user, get_runtime_user_home, mkdir_with_owner, wrap_argv_for_user
 
 
@@ -21,6 +22,7 @@ _WORKERS_LOCK: asyncio.Lock | None = None
 _NODE_PATH: str | None = None
 _NODE_PATH_LOCK: asyncio.Lock | None = None
 _WORKER_IDLE_SECONDS = 300.0
+_MAX_WORKER_RESPONSE_BYTES = 16 * 1024 * 1024
 logger = logging.getLogger(__name__)
 _RUNNER = r"""
 const fs = require('fs');
@@ -33,7 +35,7 @@ const locator = (p,s) => {
   else if (s.text) l=p.getByText(s.text, {exact:!!s.exact});
   else if (s.testid) l=p.getByTestId(s.testid);
   else l=p.locator(s.css || s.selector);
-  return s.nth === undefined ? l : l.nth(s.nth);
+  return s.nth == null ? l : l.nth(s.nth);
 };
 let context=null, page=null;
 const closeContext = async () => {
@@ -92,11 +94,15 @@ const run = async cfg => {
  return out;
 };
 const rl=readline.createInterface({input:process.stdin,crlfDelay:Infinity});
+const writeResult = out => {
+ const payload=JSON.stringify(out);
+ process.stdout.write(Buffer.byteLength(payload,'utf8')+'\n'+payload);
+};
 rl.on('line', line => {
  rl.pause();
  (async()=>run(JSON.parse(line)))()
-  .then(out=>process.stdout.write(JSON.stringify(out)+'\n'))
-  .catch(e=>process.stdout.write(JSON.stringify({ok:false,error:String(e)})+'\n'))
+  .then(writeResult)
+  .catch(e=>writeResult({ok:false,error:String(e)}))
   .finally(()=>rl.resume());
 });
 rl.on('close', async()=>{await closeContext(); process.exit(0);});
@@ -188,15 +194,32 @@ class _BrowserWorker:
             try:
                 self.process.stdin.write((json.dumps(config) + "\n").encode())
                 await self.process.stdin.drain()
-                line = await asyncio.wait_for(self.process.stdout.readline(), timeout=timeout)
-                if not line:
+                header = await asyncio.wait_for(self.process.stdout.readline(), timeout=timeout)
+                if not header:
                     detail = bytes(self.stderr_tail).decode(errors="replace")[-500:]
                     await self._stop_locked()
                     raise RuntimeError(
                         f"Playwright worker exited unexpectedly: {detail}"
                     )
-                result = json.loads(line)
-            except (asyncio.TimeoutError, BrokenPipeError, json.JSONDecodeError) as exc:
+                try:
+                    response_size = int(header)
+                except ValueError as exc:
+                    raise ValueError("invalid Playwright worker response frame") from exc
+                if response_size < 0 or response_size > _MAX_WORKER_RESPONSE_BYTES:
+                    raise ValueError(
+                        f"Playwright worker response exceeds {_MAX_WORKER_RESPONSE_BYTES} bytes"
+                    )
+                payload = await asyncio.wait_for(
+                    self.process.stdout.readexactly(response_size), timeout=timeout
+                )
+                result = json.loads(payload)
+            except (
+                asyncio.TimeoutError,
+                asyncio.IncompleteReadError,
+                BrokenPipeError,
+                ValueError,
+                json.JSONDecodeError,
+            ) as exc:
                 await self._stop_locked()
                 if isinstance(exc, asyncio.TimeoutError):
                     raise RuntimeError("Browser run exceeded its bounded execution time") from exc
@@ -239,6 +262,26 @@ class BrowserRunHandler(AsyncHandler):
     def command_name(self) -> str:
         return "browser_run"
 
+    async def send_response(self, payload, reply_channel=None, project_id=None):
+        """Chunk large browser results while preserving the normal response envelope."""
+        if payload.get("event") == "browser_run_response":
+            serialized = json.dumps(payload, separators=(",", ":"))
+            if should_chunk_content(serialized):
+                base_response = {
+                    "event": "browser_run_response",
+                    "success": bool(payload.get("success")),
+                    "browser_chunked": True,
+                }
+                for key in ("request_id", "trace"):
+                    if key in payload:
+                        base_response[key] = payload[key]
+                for chunk in create_chunked_response(
+                    base_response, "chunk_content", serialized
+                ):
+                    await super().send_response(chunk, reply_channel, project_id)
+                return
+        await super().send_response(payload, reply_channel, project_id)
+
     async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
         session_id = str(message.get("session_id") or "default")
         if not _SAFE_ID.fullmatch(session_id):

{portacode-1.5.29.dev0 → portacode-1.5.31.dev0}/portacode/connection/handlers/test_browser_handlers.py

@@ -1,5 +1,8 @@
 import unittest
-from unittest.mock import AsyncMock, patch
+import asyncio
+import json
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock, patch
 
 from . import browser_handlers
 from .browser_handlers import BrowserRunHandler
@@ -60,3 +63,54 @@ class BrowserRunHandlerTests(unittest.IsolatedAsyncioTestCase):
         self.assertIsNot(first, other_user)
         self.assertIsNot(first, other_session)
         browser_handlers._WORKERS.clear()
+
+    async def test_worker_reads_large_length_prefixed_response(self):
+        payload = {"ok": True, "screenshots": [{"data": "a" * 200_000}]}
+        encoded = json.dumps(payload).encode()
+        stdout = asyncio.StreamReader()
+        stdout.feed_data(str(len(encoded)).encode() + b"\n" + encoded)
+        stdout.feed_eof()
+
+        class Stdin:
+            def write(self, _value):
+                return None
+
+            async def drain(self):
+                return None
+
+        worker = browser_handlers._BrowserWorker(
+            user="tester", session_id="large", argv=["node"], env={}
+        )
+        worker.process = SimpleNamespace(
+            stdin=Stdin(), stdout=stdout, returncode=None
+        )
+        worker._start = AsyncMock()
+        worker._schedule_idle_close = Mock()
+
+        self.assertEqual(await worker.run({}, timeout=1), payload)
+
+    async def test_large_browser_response_uses_existing_chunk_format(self):
+        channel = AsyncMock()
+        handler = BrowserRunHandler(channel, {})
+        payload = {
+            "event": "browser_run_response",
+            "request_id": "request-1",
+            "success": True,
+            "screenshots": [{"data": "a" * 300_000}],
+        }
+
+        await handler.send_response(payload)
+
+        sent = [call.args[0] for call in channel.send.await_args_list]
+        self.assertGreater(len(sent), 1)
+        self.assertTrue(all(item["browser_chunked"] for item in sent))
+        self.assertEqual(
+            {item["transfer_id"] for item in sent}, {sent[0]["transfer_id"]}
+        )
+        self.assertEqual(
+            "".join(item["chunk_content"] for item in sent),
+            json.dumps(payload, separators=(",", ":")),
+        )
+
+    def test_null_nth_is_treated_as_omitted(self):
+        self.assertIn("s.nth == null ? l : l.nth(s.nth)", browser_handlers._RUNNER)

{portacode-1.5.29.dev0 → portacode-1.5.31.dev0}/portacode/tests/test_codex_prepare.py

@@ -9,6 +9,7 @@ from portacode.codex_prepare import (
     CodexPreparationError,
     _run,
     _install_node_if_needed,
+    ensure_codex_home,
     install_codex_dependencies,
     resolve_codex_home,
     write_codex_config,
@@ -133,3 +134,19 @@ def test_write_codex_config_forces_local_proxy(tmp_path, monkeypatch):
     assert "openai_base_url" in text
     assert '[projects."/home/bishoy/souldesign_container"]' in text
     assert 'trust_level = "trusted"' in text
+
+
+def test_ensure_codex_home_repairs_runtime_user_directory_ownership(tmp_path, monkeypatch):
+    home = tmp_path / ".codex"
+    ownership_calls = []
+    monkeypatch.setattr("portacode.codex_prepare.resolve_codex_home", lambda: home)
+    monkeypatch.setattr("portacode.codex_prepare._persist_codex_home_env", lambda path: None)
+    monkeypatch.setattr("portacode.codex_prepare.write_codex_config", lambda path: path / "config.toml")
+    monkeypatch.setitem(
+        ensure_codex_home.__globals__,
+        "_repair_codex_home_ownership",
+        lambda codex_home, sessions_dir: ownership_calls.append((codex_home, sessions_dir)),
+    )
+
+    assert ensure_codex_home() == home
+    assert ownership_calls == [(home, home / "sessions")]

{portacode-1.5.29.dev0 → portacode-1.5.31.dev0}/portacode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.29.dev0
+Version: 1.5.31.dev0
 Summary: Connect real machines to the Portacode AI development environment
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian