portacode 2.2.20.dev8__tar.gz → 2.2.22.dev0__tar.gz

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 2.2.20.dev8
+Version: 2.2.22.dev0
 Summary: Device agent for the AI platform that builds, tests, deploys, and operates real software
 Home-page: https://portacode.com/
 Author: Meena Erian

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.20.dev8'
-__version_tuple__ = version_tuple = (2, 2, 20, 'dev8')
+__version__ = version = '2.2.22.dev0'
+__version_tuple__ = version_tuple = (2, 2, 22, 'dev0')
 
 __commit_id__ = commit_id = None

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode/browser_cli.py

@@ -9,22 +9,24 @@ from pathlib import Path
 
 import click
 
+from .browser_runtime import (
+    MANAGED_BROWSER_CACHE,
+    configure_browser_cache_environment,
+    open_browser_page,
+)
 from .connection.handlers.browser_handlers import load_browser_config, update_browser_config
 
 
-_MANAGED_BROWSERS_PATH = Path("/opt/ms-playwright")
+_MANAGED_BROWSERS_PATH = MANAGED_BROWSER_CACHE
 
 
 def _configure_managed_browser_path() -> None:
-    if _MANAGED_BROWSERS_PATH.is_dir():
-        os.environ.setdefault("PLAYWRIGHT_BROWSERS_PATH", str(_MANAGED_BROWSERS_PATH))
+    configure_browser_cache_environment(os.environ)
 
 
 def run_browser_script(*, url: str, script: str, output_dir: Path, record_video: bool,
                        width: int | None, height: int | None, timeout_ms: int) -> dict:
     _configure_managed_browser_path()
-    from playwright.sync_api import sync_playwright
-
     browser_config = load_browser_config()
     width = width or browser_config["viewport"]["width"]
     height = height or browser_config["viewport"]["height"]
@@ -36,20 +38,13 @@ def run_browser_script(*, url: str, script: str, output_dir: Path, record_video:
     if record_video:
         video_dir.mkdir(exist_ok=True)
 
-    with sync_playwright() as pw:
-        launch = {"headless": True}
-        alpine = Path("/usr/bin/chromium-browser")
-        if alpine.exists():
-            launch.update(executable_path=str(alpine), args=["--no-sandbox"])
-        browser = pw.chromium.launch(**launch)
-        context_args = {"viewport": {"width": width, "height": height}}
-        if record_video:
-            context_args.update(record_video_dir=str(video_dir), record_video_size={
-                "width": browser_config["video"]["width"],
-                "height": browser_config["video"]["height"],
-            })
-        context = browser.new_context(**context_args)
-        page = context.new_page()
+    context_args = {"viewport": {"width": width, "height": height}}
+    if record_video:
+        context_args.update(record_video_dir=str(video_dir), record_video_size={
+            "width": browser_config["video"]["width"],
+            "height": browser_config["video"]["height"],
+        })
+    with open_browser_page(context_args) as (browser, context, page):
         page.set_default_timeout(timeout_ms)
 
         def screenshot(name="screenshot", full_page=False):

portacode-2.2.22.dev0/portacode/browser_runtime.py

@@ -0,0 +1,111 @@
+"""Browser runtime discovery shared by the CLI and device workers."""
+from __future__ import annotations
+
+import os
+import shutil
+from contextlib import contextmanager, suppress
+from pathlib import Path
+
+
+MANAGED_BROWSER_CACHE = Path("/opt/ms-playwright")
+
+
+def configure_browser_cache_environment(environment: dict[str, str]) -> None:
+    configured = str(environment.get("PLAYWRIGHT_BROWSERS_PATH") or "").strip()
+    if configured == "0":
+        return
+    if configured and Path(configured).is_dir():
+        return
+    environment.pop("PLAYWRIGHT_BROWSERS_PATH", None)
+    if MANAGED_BROWSER_CACHE.is_dir():
+        environment["PLAYWRIGHT_BROWSERS_PATH"] = str(MANAGED_BROWSER_CACHE)
+
+
+def browser_environments(environment: dict[str, str]) -> list[dict[str, str]]:
+    configured = environment.get("PLAYWRIGHT_BROWSERS_PATH")
+    if configured == "0":
+        return [dict(environment)]
+    if configured and Path(configured).is_dir():
+        return [dict(environment)]
+    default = dict(environment)
+    default.pop("PLAYWRIGHT_BROWSERS_PATH", None)
+    candidates = [default]
+    if MANAGED_BROWSER_CACHE.is_dir():
+        managed = {**default, "PLAYWRIGHT_BROWSERS_PATH": str(MANAGED_BROWSER_CACHE)}
+        candidates = [managed, default] if configured else [default, managed]
+    return candidates
+
+
+def find_system_browser() -> str | None:
+    for name in ("chromium-browser", "chromium", "google-chrome-stable", "google-chrome"):
+        executable = shutil.which(name)
+        if executable:
+            return executable
+    for name in ("chromium-browser", "chromium", "google-chrome-stable", "google-chrome"):
+        candidate = Path("/usr/bin") / name
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return str(candidate)
+    return None
+
+
+@contextmanager
+def open_browser_page(context_options: dict):
+    from playwright.sync_api import sync_playwright
+
+    environments = browser_environments(dict(os.environ))
+    system_browser = find_system_browser()
+    alpine = Path("/etc/alpine-release").is_file()
+    original_cache = os.environ.get("PLAYWRIGHT_BROWSERS_PATH")
+    errors = []
+    browser = None
+    context = None
+    driver = None
+    try:
+        for index, environment in enumerate(environments):
+            cache = environment.get("PLAYWRIGHT_BROWSERS_PATH")
+            if cache is None:
+                os.environ.pop("PLAYWRIGHT_BROWSERS_PATH", None)
+            else:
+                os.environ["PLAYWRIGHT_BROWSERS_PATH"] = cache
+            driver = sync_playwright().start()
+            root_args = ["--no-sandbox"] if hasattr(os, "geteuid") and os.geteuid() == 0 else []
+            base = {"headless": True}
+            if root_args:
+                base["args"] = root_args
+            options = [base, {**base, "channel": "chromium"}]
+            if system_browser and (alpine or index == len(environments) - 1):
+                system = {"headless": True, "executable_path": system_browser}
+                if root_args:
+                    system["args"] = root_args
+                options = [system] if alpine else [*options, system]
+            for launch in options:
+                try:
+                    browser = driver.chromium.launch(**launch)
+                    context = browser.new_context(**context_options)
+                    page = context.new_page()
+                except Exception as exc:
+                    errors.append(str(exc))
+                    if browser:
+                        with suppress(Exception):
+                            browser.close()
+                    browser = None
+                    context = None
+                    continue
+                yield browser, context, page
+                return
+            driver.stop()
+            driver = None
+        raise RuntimeError("Unable to launch a browser: " + "\n".join(errors))
+    finally:
+        if context:
+            with suppress(Exception):
+                context.close()
+        if browser:
+            with suppress(Exception):
+                browser.close()
+        if driver:
+            driver.stop()
+        if original_cache is None:
+            os.environ.pop("PLAYWRIGHT_BROWSERS_PATH", None)
+        else:
+            os.environ["PLAYWRIGHT_BROWSERS_PATH"] = original_cache

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode/connection/handlers/browser_handlers.py

@@ -14,6 +14,11 @@ import time
 from pathlib import Path
 from typing import Any, Dict
 
+from ...browser_runtime import (
+    configure_browser_cache_environment as _configure_browser_cache_environment,
+    find_system_browser,
+)
+
 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
@@ -103,15 +108,30 @@ def update_browser_config(updates: dict, message: dict | None = None) -> dict:
 
 _RUNNER = r"""
 const fs = require('fs');
+const path = require('path');
 const readline = require('readline');
 const playwrightCandidates = JSON.parse(process.env.PORTACODE_PLAYWRIGHT_CANDIDATES || '["playwright"]');
 let chromium;
 const playwrightErrors = [];
+const executableExists = executable => {
+ try { return fs.existsSync(executable) && fs.statSync(executable).isFile(); } catch (_) { return false; }
+};
+const browserExecutables = executable => {
+ const candidates = [executable];
+ const browserDirectory = path.dirname(path.dirname(executable));
+ const browserRoot = path.dirname(browserDirectory);
+ const revision = path.basename(browserDirectory).replace(/^chromium-/, '');
+ const platform = path.basename(path.dirname(executable)).replace(/^chrome-/, 'chrome-headless-shell-');
+ if (revision && revision !== path.basename(browserDirectory)) {
+  candidates.push(path.join(browserRoot, `chromium_headless_shell-${revision}`, platform, 'chrome-headless-shell'));
+ }
+ return candidates;
+};
 for (const candidate of playwrightCandidates) {
  try {
   const loaded = require(candidate);
   const executable = loaded.chromium.executablePath();
-  if (process.env.PORTACODE_BROWSER_EXECUTABLE || (fs.existsSync(executable) && fs.statSync(executable).isFile())) {
+  if (process.env.PORTACODE_BROWSER_EXECUTABLE || browserExecutables(executable).some(executableExists)) {
    chromium = loaded.chromium;
    break;
   }
@@ -175,6 +195,7 @@ const ensureContext = async cfg => {
  if(!context) {
   const launch = {headless:true, viewport:cfg.viewport};
   if (cfg.executable_path) launch.executablePath = cfg.executable_path;
+  if (typeof process.getuid === 'function' && process.getuid() === 0) launch.args = ['--no-sandbox'];
   if (cfg.video_dir) launch.recordVideo = {dir:cfg.video_dir, size:cfg.video_size};
   context = await chromium.launchPersistentContext(cfg.profile_dir, launch);
   const pages=context.pages(); page=pages[0] || await context.newPage();
@@ -256,6 +277,9 @@ async def _node_path() -> str:
     async with _NODE_PATH_LOCK:
         if _NODE_PATH is None:
             paths = ["/opt/portacode-playwright/node_modules"]
+            inherited = os.environ.get("NODE_PATH", "")
+            if inherited:
+                paths = inherited.split(os.pathsep) + paths
             if shutil.which("npm"):
                 npm = await asyncio.create_subprocess_exec(
                     "npm", "root", "-g", stdout=asyncio.subprocess.PIPE,
@@ -304,8 +328,11 @@ def _playwright_js_package() -> str | None:
 
 
 def _playwright_js_candidates() -> list[str]:
-    """Return browser packages in managed, Node, then Python-driver order."""
+    """Return browser packages without requiring a fixed install root."""
     candidates = []
+    configured = os.environ.get("PORTACODE_PLAYWRIGHT_JS", "").strip()
+    if configured and (Path(configured) / "package.json").is_file():
+        candidates.append(configured)
     managed = Path("/opt/portacode-playwright/node_modules/playwright")
     if (managed / "package.json").is_file():
         candidates.append(str(managed))
@@ -317,11 +344,14 @@ def _playwright_js_candidates() -> list[str]:
 
 
 class _BrowserWorker:
-    def __init__(self, *, user: str, session_id: str, argv: list[str], env: dict[str, str]):
+    def __init__(
+        self, *, user: str, session_id: str, argv: list[str], env: dict[str, str], cwd: str | None = None
+    ):
         self.user = user
         self.session_id = session_id
         self.argv = argv
         self.env = env
+        self.cwd = cwd
         self.process: asyncio.subprocess.Process | None = None
         self.stderr_task: asyncio.Task | None = None
         self.stderr_tail = bytearray()
@@ -334,7 +364,7 @@ class _BrowserWorker:
             return
         self.process = await asyncio.create_subprocess_exec(
             *self.argv, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE, env=self.env,
+            stderr=asyncio.subprocess.PIPE, env=self.env, cwd=self.cwd,
         )
         self.stderr_task = asyncio.create_task(self._drain_stderr(self.process))
 
@@ -422,14 +452,16 @@ class _BrowserWorker:
             await stderr_task
 
 
-async def _worker_for(*, user: str, session_id: str, argv: list[str], env: dict[str, str]) -> _BrowserWorker:
+async def _worker_for(
+    *, user: str, session_id: str, argv: list[str], env: dict[str, str], cwd: str | None = None
+) -> _BrowserWorker:
     global _WORKERS_LOCK
     _WORKERS_LOCK = _loop_lock(_WORKERS_LOCK)
     async with _WORKERS_LOCK:
         key = (user, session_id)
         worker = _WORKERS.get(key)
         if worker is None or worker.process and worker.process.returncode is not None:
-            worker = _BrowserWorker(user=user, session_id=session_id, argv=argv, env=env)
+            worker = _BrowserWorker(user=user, session_id=session_id, argv=argv, env=env, cwd=cwd)
             _WORKERS[key] = worker
         return worker
 
@@ -493,7 +525,8 @@ class BrowserRunHandler(AsyncHandler):
         video_width = _validated_dimension("video", "width", video["width"])
         video_height = _validated_dimension("video", "height", video["height"])
         user = get_default_runtime_user(message)
-        root = Path(get_runtime_user_home(message)) / ".local" / "share" / "portacode" / "browser"
+        home = get_runtime_user_home(message)
+        root = Path(home) / ".local" / "share" / "portacode" / "browser"
         profile = root / "profiles" / session_id
         video_dir = root / "recordings" / session_id if message.get("record_video") else None
         if not profile.exists():
@@ -501,7 +534,7 @@ class BrowserRunHandler(AsyncHandler):
         if video_dir:
             if not video_dir.exists():
                 mkdir_with_owner(video_dir, user)
-        executable = "/usr/bin/chromium-browser" if Path("/usr/bin/chromium-browser").exists() else None
+        executable = find_system_browser()
         config = {
             "session_id": session_id, "profile_dir": str(profile), "video_dir": str(video_dir) if video_dir else None,
             "video_size": {"width": video_width, "height": video_height},
@@ -514,8 +547,11 @@ class BrowserRunHandler(AsyncHandler):
             "screenshot_on_failure": bool(message.get("screenshot_on_failure", True)),
         }
         env = dict(os.environ)
+        env.update({"HOME": home, "USER": user, "LOGNAME": user})
+        env["XDG_CONFIG_HOME"] = str(Path(home) / ".config")
+        env["XDG_CACHE_HOME"] = str(Path(home) / ".cache")
         env["NODE_PATH"] = await _node_path()
-        env.setdefault("PLAYWRIGHT_BROWSERS_PATH", "/opt/ms-playwright")
+        _configure_browser_cache_environment(env)
         env["PORTACODE_PLAYWRIGHT_CANDIDATES"] = json.dumps(_playwright_js_candidates())
         if executable:
             env["PORTACODE_BROWSER_EXECUTABLE"] = executable
@@ -539,7 +575,7 @@ class BrowserRunHandler(AsyncHandler):
                 "steps": [],
             }
         worker = await _worker_for(
-            user=user, session_id=session_id, argv=argv, env=env,
+            user=user, session_id=session_id, argv=argv, env=env, cwd=home,
         )
         run_limit = min(240 if video_dir else 300, 30 + len(steps) * timeout_ms / 1000)
         result = await worker.run(config, timeout=run_limit)

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode/connection/handlers/proxmox_infra.py

@@ -2593,6 +2593,30 @@ def _cacheable_bootstrap_steps(package_manager: str) -> List[Dict[str, Any]]:
             ),
             "retries": 0,
         })
+    elif package_manager in {"dnf", "yum"}:
+        steps.append({
+            "name": "install_playwright_chromium",
+            "cmd": (
+                "if ! command -v chromium >/dev/null 2>&1 && ! command -v chromium-browser >/dev/null 2>&1; then "
+                f"if grep -qi centos /etc/os-release; then {package_manager} install -y epel-release; fi; "
+                f"{package_manager} install -y chromium; "
+                "fi && "
+                "python3 -m pip install 'playwright>=1.45,<2' && "
+                "chromium_path=$(command -v chromium || command -v chromium-browser) && "
+                "test -x \"$chromium_path\" && "
+                "\"$chromium_path\" --version && "
+                "PORTACODE_BROWSER_EXECUTABLE=\"$chromium_path\" python3 -c "
+                "\"import os; from playwright.sync_api import sync_playwright; "
+                "p=sync_playwright().start(); "
+                "b=p.chromium.launch(headless=True, executable_path=os.environ['PORTACODE_BROWSER_EXECUTABLE'], "
+                "args=['--no-sandbox'] if os.geteuid() == 0 else []); "
+                "page=b.new_page(); page.goto('about:blank'); "
+                "page.screenshot(path='/tmp/portacode-playwright-smoke.png'); "
+                "b.close(); p.stop()\" && "
+                "test -s /tmp/portacode-playwright-smoke.png && rm /tmp/portacode-playwright-smoke.png"
+            ),
+            "retries": 0,
+        })
     return steps
 
 

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode/connection/handlers/test_browser_handlers.py

@@ -106,6 +106,44 @@ class BrowserRunHandlerTests(unittest.IsolatedAsyncioTestCase):
                 ],
             )
 
+    def test_playwright_candidates_accept_configured_package_location(self):
+        with (
+            patch.dict("os.environ", {"PORTACODE_PLAYWRIGHT_JS": "/srv/playwright"}, clear=False),
+            patch.object(browser_handlers.Path, "is_file", side_effect=[True, False, True]),
+            patch.object(browser_handlers, "_playwright_js_package", return_value="/bundled/playwright/package"),
+        ):
+            self.assertEqual(
+                browser_handlers._playwright_js_candidates(),
+                ["/srv/playwright", "playwright", "/bundled/playwright/package"],
+            )
+
+    def test_system_browser_discovery_supports_chromium(self):
+        with patch.object(
+            browser_handlers.shutil,
+            "which",
+            side_effect=lambda name: "/usr/bin/chromium" if name == "chromium" else None,
+        ):
+            self.assertEqual(browser_handlers.find_system_browser(), "/usr/bin/chromium")
+
+    def test_invalid_browser_cache_falls_back_to_managed_cache(self):
+        env = {"PLAYWRIGHT_BROWSERS_PATH": "/missing/browser-cache"}
+        with patch.object(browser_handlers.Path, "is_dir", side_effect=[False, True]):
+            browser_handlers._configure_browser_cache_environment(env)
+        self.assertEqual(env["PLAYWRIGHT_BROWSERS_PATH"], "/opt/ms-playwright")
+
+    async def test_worker_uses_runtime_home_as_subprocess_cwd(self):
+        process = SimpleNamespace(returncode=None, stderr=None)
+        with patch.object(
+            browser_handlers.asyncio,
+            "create_subprocess_exec",
+            AsyncMock(return_value=process),
+        ) as spawn:
+            worker = browser_handlers._BrowserWorker(
+                user="tester", session_id="cwd", argv=["node"], env={}, cwd="/home/tester"
+            )
+            await worker._start()
+        self.assertEqual(spawn.await_args.kwargs["cwd"], "/home/tester")
+
     async def test_reuses_worker_for_same_runtime_user_and_session(self):
         worker = AsyncMock()
         worker.run.return_value = {"ok": True, "steps": [], "screenshots": []}
@@ -135,6 +173,9 @@ class BrowserRunHandlerTests(unittest.IsolatedAsyncioTestCase):
             json.loads(get_worker.await_args_list[0].kwargs["env"]["PORTACODE_PLAYWRIGHT_CANDIDATES"]),
             ["playwright", "/bundled/playwright/package"],
         )
+        self.assertEqual(get_worker.await_args_list[0].kwargs["cwd"], "/tmp")
+        self.assertEqual(get_worker.await_args_list[0].kwargs["env"]["HOME"], "/tmp")
+        self.assertEqual(get_worker.await_args_list[0].kwargs["env"]["USER"], "tester")
 
     async def test_failed_browser_run_is_not_reported_as_successful(self):
         worker = AsyncMock()
@@ -247,6 +288,11 @@ class BrowserRunHandlerTests(unittest.IsolatedAsyncioTestCase):
         self.assertIn("op==='dom'", browser_handlers._RUNNER)
         self.assertIn("20000", browser_handlers._RUNNER)
 
+    def test_runner_accepts_headless_shell_cache_and_disables_root_sandbox(self):
+        self.assertIn("chromium_headless_shell-", browser_handlers._RUNNER)
+        self.assertIn("process.getuid() === 0", browser_handlers._RUNNER)
+        self.assertNotIn("cfg.executable_path && typeof process.getuid", browser_handlers._RUNNER)
+
     def test_video_demo_layer_has_cursor_zoom_typing_and_click_effects(self):
         runner = browser_handlers._RUNNER
         self.assertIn("__portacode_demo_cursor", runner)

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode/connection/handlers/test_proxmox_infra.py

@@ -187,7 +187,7 @@ class ProxmoxInfraHandlerTests(TestCase):
         self.assertEqual(_cache_source_display_name(source), "Alpine 3.17")
         self.assertEqual(
             _cache_template_hostname(source),
-            "cache-alpine-3-17-v2026-08-21-1-4g",
+            "cache-alpine-3-17-v2026-09-18-1-4g",
         )
 
     def test_reconciled_external_deletion_is_not_reinserted_from_local_record(self):

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode/provisioning_cache.py

@@ -5,4 +5,4 @@ the cacheable package/tool layer changes.  It deliberately does not follow the
 package version: most CLI releases do not require rebuilding large LXC images.
 """
 
-PROVISIONING_CACHE_ID = "2026-08-21.1"
+PROVISIONING_CACHE_ID = "2026-09-18.1"

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode/tests/test_browser_cli.py

@@ -49,3 +49,12 @@ def test_explicit_browser_cache_is_preserved(monkeypatch):
     browser_cli._configure_managed_browser_path()
 
     assert os.environ["PLAYWRIGHT_BROWSERS_PATH"] == "/custom/browsers"
+
+
+def test_missing_managed_browser_cache_does_not_invent_an_install_path(monkeypatch):
+    monkeypatch.delenv("PLAYWRIGHT_BROWSERS_PATH", raising=False)
+    monkeypatch.setattr(Path, "is_dir", lambda self: False)
+
+    browser_cli._configure_managed_browser_path()
+
+    assert "PLAYWRIGHT_BROWSERS_PATH" not in os.environ

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 2.2.20.dev8
+Version: 2.2.22.dev0
 Summary: Device agent for the AI platform that builds, tests, deploys, and operates real software
 Home-page: https://portacode.com/
 Author: Meena Erian

{portacode-2.2.20.dev8 → portacode-2.2.22.dev0}/portacode.egg-info/SOURCES.txt

@@ -19,7 +19,6 @@ docs/device-health-alerting-plan.md
 docs/devops-messaging-ab-tests.md
 docs/guest-host-requests-plan.md
 docs/homepage-dashboard-positioning-fixes.md
-docs/template-engineering-roadmap.md
 docs/template-guide.html
 examples/README.md
 examples/simple_device/Dockerfile
@@ -269,6 +268,7 @@ portacode/__init__.py
 portacode/__main__.py
 portacode/_version.py
 portacode/browser_cli.py
+portacode/browser_runtime.py
 portacode/cli.py
 portacode/codex_loopback_proxy.py
 portacode/codex_prepare.py