portacode 2.2.20.dev8__tar.gz → 2.2.22__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 2.2.20.dev8
+Version: 2.2.22
 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}/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'
+__version_tuple__ = version_tuple = (2, 2, 22)
 
 __commit_id__ = commit_id = None

{portacode-2.2.20.dev8 → portacode-2.2.22}/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/portacode/browser_prepare.py

@@ -0,0 +1,117 @@
+"""Idempotent browser preparation for managed provisioning guests."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from .browser_runtime import MANAGED_BROWSER_CACHE, find_system_browser
+
+
+PACKAGE_MANAGERS = ("apt", "apk", "dnf", "yum", "zypper", "pacman")
+_SMOKE_SCRIPT = """
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from portacode.browser_runtime import open_browser_page
+
+with TemporaryDirectory(prefix='portacode-browser-check-') as directory:
+    options = {'viewport': {'width': 320, 'height': 240},
+               'record_video_dir': directory,
+               'record_video_size': {'width': 320, 'height': 240}}
+    with open_browser_page(options) as (browser, context, page):
+        page.set_content('<button onclick="this.textContent=\\'Ready\\'">Test</button>')
+        page.get_by_role('button').click()
+        assert page.get_by_role('button').inner_text() == 'Ready'
+        page.wait_for_timeout(300)
+        image = Path(directory) / 'screenshot.png'
+        page.screenshot(path=str(image))
+        video = page.video
+        context.close()
+        if not image.stat().st_size or video is None or not Path(video.path()).stat().st_size:
+            raise RuntimeError('Browser screenshot/video verification failed')
+"""
+
+
+def _probe_browser(environment: dict[str, str]) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [sys.executable, "-c", _SMOKE_SCRIPT], env=environment,
+        text=True, capture_output=True, timeout=120,
+    )
+
+
+def _require_browser(environment: dict[str, str]) -> None:
+    result = _probe_browser(environment)
+    if result.returncode:
+        detail = (result.stderr or result.stdout or "No diagnostic output")[-4000:]
+        raise RuntimeError(f"Browser screenshot/video verification failed:\n{detail}")
+
+
+def _install_alpine_ffmpeg(cache: Path) -> None:
+    import playwright
+
+    package = Path(playwright.__file__).resolve().parent / "driver" / "package"
+    browsers = json.loads((package / "browsers.json").read_text())["browsers"]
+    ffmpeg = next(browser for browser in browsers if browser["name"] == "ffmpeg")
+    executable = shutil.which("ffmpeg")
+    if not executable:
+        raise RuntimeError("Alpine's ffmpeg package did not provide an executable")
+    target = cache / f"ffmpeg-{ffmpeg['revision']}" / "ffmpeg-linux"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    if target.is_symlink() or target.exists():
+        target.unlink()
+    target.symlink_to(executable)
+
+
+def prepare_browser(package_manager: str, *, check_only: bool = False) -> None:
+    """Install only missing guest assets, using this interpreter's Playwright."""
+    if package_manager not in PACKAGE_MANAGERS:
+        raise ValueError(f"Unsupported package manager: {package_manager}")
+    environment = {**os.environ, "PLAYWRIGHT_BROWSERS_PATH": str(MANAGED_BROWSER_CACHE)}
+    if check_only:
+        _require_browser(environment)
+        return
+    MANAGED_BROWSER_CACHE.mkdir(parents=True, exist_ok=True)
+
+    def run(*command: str) -> None:
+        subprocess.run(command, env=environment, check=True)
+
+    run("chmod", "-R", "a+rX", str(MANAGED_BROWSER_CACHE))
+    if _probe_browser(environment).returncode == 0:
+        return
+
+    if package_manager == "apt":
+        run(sys.executable, "-m", "playwright", "install", "--with-deps", "chromium", "ffmpeg")
+    elif package_manager == "apk":
+        run("apk", "add", "--no-cache", "chromium", "nss", "freetype", "harfbuzz",
+            "ca-certificates", "font-freefont", "ffmpeg")
+        _install_alpine_ffmpeg(MANAGED_BROWSER_CACHE)
+    else:
+        if not find_system_browser():
+            if package_manager in {"dnf", "yum"}:
+                release = Path("/etc/os-release").read_text().lower()
+                if "centos" in release:
+                    run(package_manager, "install", "-y", "epel-release")
+                run(package_manager, "install", "-y", "chromium")
+            elif package_manager == "zypper":
+                run("zypper", "--non-interactive", "install", "-y", "chromium")
+            elif package_manager == "pacman":
+                run("pacman", "-S", "--noconfirm", "--needed", "chromium")
+        run(sys.executable, "-m", "playwright", "install", "ffmpeg")
+    run("chmod", "-R", "a+rX", str(MANAGED_BROWSER_CACHE))
+    _require_browser(environment)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--package-manager", required=True, choices=PACKAGE_MANAGERS)
+    parser.add_argument("--check", action="store_true")
+    arguments = parser.parse_args()
+    prepare_browser(arguments.package_manager, check_only=arguments.check)
+
+
+if __name__ == "__main__":
+    main()

portacode-2.2.22/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}/portacode/codex_prepare.py

@@ -179,12 +179,7 @@ def _install_node_if_needed() -> None:
             packages = ["npm"] if node_ready else ["nodejs", "npm"]
             _run([*_sudo_prefix(), "apk", "add", "--no-cache", *packages])
         else:
-            if not shutil.which("curl") and any(name in release for name in ("debian", "ubuntu")):
-                # Exit 100 is common on Proxmox when an optional enterprise
-                # repository is unavailable; the required Ubuntu/Debian
-                # packages can still be installed from the remaining mirrors.
-                _run([*_sudo_prefix(), "apt-get", "update"], ok_returncodes=(0, 100))
-                _run([*_sudo_prefix(), "apt-get", "install", "-y", "ca-certificates", "curl"])
+            _install_linux_node_prerequisites()
             _install_node_with_nvm()
     elif system == "darwin":
         _install_node_with_nvm()
@@ -210,6 +205,26 @@ def _install_node_if_needed() -> None:
         raise CodexPreparationError("Node.js installation completed but npm is not available in this session.")
 
 
+def _install_linux_node_prerequisites() -> None:
+    if shutil.which("bash") and shutil.which("curl"):
+        return
+    packages = ["ca-certificates", "bash", "curl"]
+    commands = {
+        "apt-get": ["apt-get", "install", "-y", *packages],
+        "dnf": ["dnf", "install", "-y", *packages],
+        "yum": ["yum", "install", "-y", *packages],
+        "zypper": ["zypper", "--non-interactive", "install", "-y", *packages],
+        "pacman": ["pacman", "-S", "--noconfirm", "--needed", *packages],
+    }
+    for manager, command in commands.items():
+        if shutil.which(manager):
+            if manager == "apt-get":
+                _run([*_sudo_prefix(), manager, "update"], ok_returncodes=(0, 100))
+            _run([*_sudo_prefix(), *command])
+            return
+    raise CodexPreparationError("Installing Node.js requires bash and curl; no supported package manager was found.")
+
+
 def _install_codex() -> None:
     existing = _codex_path()
     if existing and _codex_works(existing):

{portacode-2.2.20.dev8 → portacode-2.2.22}/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,24 +328,30 @@ 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)
+    bundled = _playwright_js_package()
+    if bundled and bundled not in candidates:
+        candidates.append(bundled)
     managed = Path("/opt/portacode-playwright/node_modules/playwright")
     if (managed / "package.json").is_file():
         candidates.append(str(managed))
     candidates.append("playwright")
-    bundled = _playwright_js_package()
-    if bundled and bundled not in candidates:
-        candidates.append(bundled)
     return candidates
 
 
 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)