portacode 2.2.20.dev2__tar.gz → 2.2.20.dev4__tar.gz

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 2.2.20.dev2
+Version: 2.2.20.dev4
 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.dev2 → portacode-2.2.20.dev4}/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.dev2'
-__version_tuple__ = version_tuple = (2, 2, 20, 'dev2')
+__version__ = version = '2.2.20.dev4'
+__version_tuple__ = version_tuple = (2, 2, 20, 'dev4')
 
 __commit_id__ = commit_id = None

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/portacode/browser_cli.py

@@ -2,17 +2,33 @@
 from __future__ import annotations
 
 import json
+import os
 import re
 import time
 from pathlib import Path
 
 import click
 
+from .connection.handlers.browser_handlers import load_browser_config, update_browser_config
+
+
+_MANAGED_BROWSERS_PATH = Path("/opt/ms-playwright")
+
+
+def _configure_managed_browser_path() -> None:
+    if _MANAGED_BROWSERS_PATH.is_dir():
+        os.environ.setdefault("PLAYWRIGHT_BROWSERS_PATH", str(_MANAGED_BROWSERS_PATH))
+
 
 def run_browser_script(*, url: str, script: str, output_dir: Path, record_video: bool,
-                       width: int, height: int, timeout_ms: int) -> dict:
+                       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"]
+
     output_dir.mkdir(parents=True, exist_ok=True)
     shots: list[str] = []
     values: list[object] = []
@@ -29,7 +45,8 @@ def run_browser_script(*, url: str, script: str, output_dir: Path, record_video:
         context_args = {"viewport": {"width": width, "height": height}}
         if record_video:
             context_args.update(record_video_dir=str(video_dir), record_video_size={
-                "width": min(width, 1280), "height": min(height, 720),
+                "width": browser_config["video"]["width"],
+                "height": browser_config["video"]["height"],
             })
         context = browser.new_context(**context_args)
         page = context.new_page()
@@ -90,8 +107,8 @@ def browser_group():
 @click.option("--output-dir", type=click.Path(file_okay=False, path_type=Path),
               default=Path("./portacode-browser-artifacts"), show_default=True)
 @click.option("--record-video/--no-record-video", default=False)
-@click.option("--width", default=1280, type=click.IntRange(320, 1920))
-@click.option("--height", default=720, type=click.IntRange(240, 1080))
+@click.option("--width", default=None, type=click.IntRange(240, 1920), help="Override saved viewport width.")
+@click.option("--height", default=None, type=click.IntRange(240, 1920), help="Override saved viewport height.")
 @click.option("--timeout-ms", default=10000, type=click.IntRange(250, 60000))
 def browser_run(url, script, script_file, output_dir, record_video, width, height, timeout_ms):
     """Execute SCRIPT with page, context, screenshot(), dom(), and emit()."""
@@ -104,3 +121,26 @@ def browser_run(url, script, script_file, output_dir, record_video, width, heigh
     click.echo(json.dumps(result, indent=2, default=str))
     if not result["ok"]:
         raise click.exceptions.Exit(1)
+
+
+@browser_group.command("config")
+@click.option("--viewport-width", type=click.IntRange(240, 1920))
+@click.option("--viewport-height", type=click.IntRange(240, 1920))
+@click.option("--video-width", type=click.IntRange(240, 1920))
+@click.option("--video-height", type=click.IntRange(240, 1920))
+def browser_config(viewport_width, viewport_height, video_width, video_height):
+    """Show or persist default browser viewport and recording dimensions."""
+    updates = {
+        "viewport": {
+            key: value for key, value in {
+                "width": viewport_width, "height": viewport_height,
+            }.items() if value is not None
+        },
+        "video": {
+            key: value for key, value in {
+                "width": video_width, "height": video_height,
+            }.items() if value is not None
+        },
+    }
+    config = update_browser_config(updates) if any(updates.values()) else load_browser_config()
+    click.echo(json.dumps(config, indent=2))

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/portacode/connection/handlers/__init__.py

@@ -16,7 +16,7 @@ from .terminal_handlers import (
 )
 from .git_handlers import GitActionHandler
 from .system_handlers import SystemInfoHandler
-from .browser_handlers import BrowserRunHandler
+from .browser_handlers import BrowserRunHandler, BrowserConfigHandler
 from .update_handler import UpdatePortacodeHandler
 from .file_handlers import (
     FileReadHandler,
@@ -103,6 +103,7 @@ __all__ = [
     "GitActionHandler",
     "SystemInfoHandler",
     "BrowserRunHandler",
+    "BrowserConfigHandler",
     "ConfigureProxmoxInfraHandler",
     "CreateProxmoxContainerHandler",
     "ResizeProxmoxContainerHandler",

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/portacode/connection/handlers/browser_handlers.py

@@ -9,6 +9,7 @@ import os
 import re
 import shutil
 import sys
+import tempfile
 import time
 from pathlib import Path
 from typing import Any, Dict
@@ -25,7 +26,81 @@ _NODE_PATH: str | None = None
 _NODE_PATH_LOCK: asyncio.Lock | None = None
 _WORKER_IDLE_SECONDS = 300.0
 _MAX_WORKER_RESPONSE_BYTES = 16 * 1024 * 1024
+_BROWSER_CONFIG_NAME = "browser.json"
 logger = logging.getLogger(__name__)
+
+_DEFAULT_BROWSER_CONFIG = {
+    "viewport": {"width": 1280, "height": 720},
+    "video": {"width": 1280, "height": 720},
+}
+
+
+def _browser_config_path(message: dict | None = None) -> Path:
+    home = Path(get_runtime_user_home(message or {}))
+    return home / ".config" / "portacode" / _BROWSER_CONFIG_NAME
+
+
+def _validated_dimension(section: str, key: str, value: Any) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"{section}.{key} must be an integer") from exc
+    if not 240 <= parsed <= 1920:
+        raise ValueError(f"{section}.{key} must be between 240 and 1920")
+    return parsed
+
+
+def load_browser_config(message: dict | None = None) -> dict:
+    path = _browser_config_path(message)
+    config = json.loads(json.dumps(_DEFAULT_BROWSER_CONFIG))
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        for section in ("viewport", "video"):
+            for key in ("width", "height"):
+                config[section][key] = _validated_dimension(
+                    section, key, data.get(section, {}).get(key, config[section][key])
+                )
+    except (OSError, ValueError, TypeError, json.JSONDecodeError):
+        pass
+    return config
+
+
+def save_browser_config(config: dict, message: dict | None = None) -> dict:
+    path = _browser_config_path(message)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, temp = tempfile.mkstemp(prefix="browser-", dir=path.parent)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(config, handle, indent=2)
+            handle.write("\n")
+        os.replace(temp, path)
+    finally:
+        try:
+            os.unlink(temp)
+        except FileNotFoundError:
+            pass
+    return config
+
+
+def update_browser_config(updates: dict, message: dict | None = None) -> dict:
+    if not isinstance(updates, dict):
+        raise ValueError("config must be an object")
+    unknown = set(updates) - {"viewport", "video"}
+    if unknown:
+        raise ValueError(f"unsupported browser config fields: {', '.join(sorted(unknown))}")
+    config = load_browser_config(message)
+    for section in ("viewport", "video"):
+        values = updates.get(section, {})
+        if not isinstance(values, dict):
+            raise ValueError(f"{section} must be an object")
+        unknown_dimensions = set(values) - {"width", "height"}
+        if unknown_dimensions:
+            raise ValueError(f"unsupported {section} fields: {', '.join(sorted(unknown_dimensions))}")
+        for key, value in values.items():
+            config[section][key] = _validated_dimension(section, key, value)
+    return save_browser_config(config, message)
+
+
 _RUNNER = r"""
 const fs = require('fs');
 const readline = require('readline');
@@ -293,6 +368,19 @@ async def _worker_for(*, user: str, session_id: str, argv: list[str], env: dict[
         return worker
 
 
+class BrowserConfigHandler(AsyncHandler):
+    @property
+    def command_name(self) -> str:
+        return "browser_config"
+
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        config = load_browser_config(message)
+        updates = message.get("config")
+        if updates is not None:
+            config = update_browser_config(updates, message)
+        return {"event": "browser_config_response", "config": config}
+
+
 class BrowserRunHandler(AsyncHandler):
     @property
     def command_name(self) -> str:
@@ -330,9 +418,14 @@ class BrowserRunHandler(AsyncHandler):
             raise ValueError("browser action payload is too large")
         if sum(1 for step in steps if isinstance(step, dict) and step.get("op") == "screenshot") > 4:
             raise ValueError("at most four explicit screenshots are allowed per run")
+        configured = load_browser_config(message)
         timeout_ms = min(max(int(message.get("timeout_ms") or 10_000), 250), 30_000)
-        width = min(max(int((message.get("viewport") or {}).get("width", 960)), 320), 1920)
-        height = min(max(int((message.get("viewport") or {}).get("height", 540)), 240), 1080)
+        viewport = {**configured["viewport"], **(message.get("viewport") or {})}
+        width = _validated_dimension("viewport", "width", viewport["width"])
+        height = _validated_dimension("viewport", "height", viewport["height"])
+        video = {**configured["video"], **(message.get("video") or {})}
+        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"
         profile = root / "profiles" / session_id
@@ -345,7 +438,7 @@ class BrowserRunHandler(AsyncHandler):
         executable = "/usr/bin/chromium-browser" if Path("/usr/bin/chromium-browser").exists() else None
         config = {
             "session_id": session_id, "profile_dir": str(profile), "video_dir": str(video_dir) if video_dir else None,
-            "video_size": {"width": min(width, 854), "height": min(height, 480)},
+            "video_size": {"width": video_width, "height": video_height},
             "viewport": {"width": width, "height": height}, "executable_path": executable,
             "start_url": message.get("start_url"), "steps": steps, "timeout_ms": timeout_ms,
             "deadline_ms": 45_000 if video_dir else None,

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/portacode/connection/handlers/system_handlers.py

@@ -25,6 +25,7 @@ except ImportError:  # pragma: no cover - py<3.8
 
 from .base import SyncHandler
 from .proxmox_infra import get_infra_snapshot
+from .browser_handlers import load_browser_config
 from .runtime_user import get_default_runtime_user, get_runtime_user_home
 from portacode.tunneling.forwarding_state import load_forwarding_state
 from portacode.connection.codex_app_server import CodexAppServer
@@ -630,6 +631,7 @@ class SystemInfoHandler(SyncHandler):
         info["os_info"] = _get_os_info()
         info["user_context"] = _get_user_context()
         info["playwright"] = _get_playwright_info()
+        info["browser_config"] = load_browser_config()
         info["proxmox"] = _get_proxmox_info()
         info["cloudflare_tunnel"] = _get_cloudflare_tunnel_state()
         info["cloudflare_forwarding"] = _get_cloudflare_forwarding_state()

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/portacode/connection/handlers/test_browser_handlers.py

@@ -2,11 +2,12 @@ import unittest
 import asyncio
 import json
 import os
+import tempfile
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, Mock, patch
 
 from . import browser_handlers
-from .browser_handlers import BrowserRunHandler
+from .browser_handlers import BrowserConfigHandler, BrowserRunHandler
 
 
 class BrowserRunHandlerTests(unittest.IsolatedAsyncioTestCase):
@@ -215,3 +216,58 @@ class BrowserRunHandlerTests(unittest.IsolatedAsyncioTestCase):
     def test_bounded_dom_operation_is_available(self):
         self.assertIn("op==='dom'", browser_handlers._RUNNER)
         self.assertIn("20000", browser_handlers._RUNNER)
+
+    async def test_persistent_mobile_config_controls_viewport_and_video(self):
+        worker = AsyncMock()
+        worker.run.return_value = {"ok": True, "steps": [], "screenshots": []}
+        with (
+            tempfile.TemporaryDirectory() as home,
+            patch.object(browser_handlers, "get_default_runtime_user", return_value="tester"),
+            patch.object(browser_handlers, "get_runtime_user_home", return_value=home),
+            patch.object(browser_handlers, "mkdir_with_owner"),
+            patch.object(browser_handlers, "wrap_argv_for_user", return_value=["node"]),
+            patch.object(browser_handlers, "_node_path", AsyncMock(return_value="/modules")),
+            patch.object(browser_handlers, "_node_executable", return_value="/bundled/node"),
+            patch.object(browser_handlers, "_playwright_js_package", return_value=None),
+            patch.object(browser_handlers, "_worker_for", AsyncMock(return_value=worker)),
+        ):
+            configured = await BrowserConfigHandler(None, {}).execute({
+                "config": {
+                    "viewport": {"width": 390, "height": 844},
+                    "video": {"width": 390, "height": 844},
+                }
+            })
+            await self.handler.execute({
+                "session_id": "mobile", "steps": [], "record_video": True,
+                "final_screenshot": False,
+            })
+            saved = json.loads(
+                open(os.path.join(home, ".config", "portacode", "browser.json"), encoding="utf-8").read()
+            )
+        self.assertEqual(configured["config"], saved)
+        run_config = worker.run.await_args.args[0]
+        self.assertEqual(run_config["viewport"], {"width": 390, "height": 844})
+        self.assertEqual(run_config["video_size"], {"width": 390, "height": 844})
+
+    async def test_per_run_dimensions_override_saved_config(self):
+        worker = AsyncMock()
+        worker.run.return_value = {"ok": True, "steps": [], "screenshots": []}
+        saved = {"viewport": {"width": 390, "height": 844}, "video": {"width": 390, "height": 844}}
+        with (
+            patch.object(browser_handlers, "load_browser_config", return_value=saved),
+            patch.object(browser_handlers, "get_default_runtime_user", return_value="tester"),
+            patch.object(browser_handlers, "get_runtime_user_home", return_value="/tmp"),
+            patch.object(browser_handlers, "mkdir_with_owner"),
+            patch.object(browser_handlers, "wrap_argv_for_user", return_value=["node"]),
+            patch.object(browser_handlers, "_node_path", AsyncMock(return_value="/modules")),
+            patch.object(browser_handlers, "_node_executable", return_value="/bundled/node"),
+            patch.object(browser_handlers, "_playwright_js_package", return_value=None),
+            patch.object(browser_handlers, "_worker_for", AsyncMock(return_value=worker)),
+        ):
+            await self.handler.execute({
+                "session_id": "override", "steps": [], "record_video": True,
+                "viewport": {"width": 430}, "video": {"height": 932},
+            })
+        run_config = worker.run.await_args.args[0]
+        self.assertEqual(run_config["viewport"], {"width": 430, "height": 844})
+        self.assertEqual(run_config["video_size"], {"width": 390, "height": 932})

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/portacode/connection/terminal.py

@@ -46,6 +46,7 @@ from .handlers import (
     GitActionHandler,
     SystemInfoHandler,
     BrowserRunHandler,
+    BrowserConfigHandler,
     FileReadHandler,
     ImageReadHandler,
     DirectoryListHandler,
@@ -575,6 +576,7 @@ class TerminalManager:
         self._command_registry.register(GitActionHandler)
         self._command_registry.register(SystemInfoHandler)
         self._command_registry.register(BrowserRunHandler)
+        self._command_registry.register(BrowserConfigHandler)
         # File operation handlers
         self._command_registry.register(FileReadHandler)
         self._command_registry.register(ImageReadHandler)

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/portacode/tests/test_browser_cli.py

@@ -1,10 +1,12 @@
 import json
+import os
 from pathlib import Path
 from unittest.mock import patch
 
 from click.testing import CliRunner
 
 from portacode.cli import cli
+from portacode import browser_cli
 
 
 def test_browser_run_accepts_inline_python_and_returns_json(tmp_path):
@@ -29,3 +31,21 @@ def test_browser_run_propagates_failure_exit_code(tmp_path):
     with patch("portacode.browser_cli.run_browser_script", return_value={"ok": False, "error": "boom"}):
         result = CliRunner().invoke(cli, ["browser", "run", "--script", "raise Exception()"])
     assert result.exit_code == 1
+
+
+def test_managed_browser_cache_is_used_when_available(monkeypatch):
+    monkeypatch.delenv("PLAYWRIGHT_BROWSERS_PATH", raising=False)
+    monkeypatch.setattr(Path, "is_dir", lambda self: True)
+
+    browser_cli._configure_managed_browser_path()
+
+    assert os.environ["PLAYWRIGHT_BROWSERS_PATH"] == "/opt/ms-playwright"
+
+
+def test_explicit_browser_cache_is_preserved(monkeypatch):
+    monkeypatch.setenv("PLAYWRIGHT_BROWSERS_PATH", "/custom/browsers")
+    monkeypatch.setattr(Path, "is_dir", lambda self: True)
+
+    browser_cli._configure_managed_browser_path()
+
+    assert os.environ["PLAYWRIGHT_BROWSERS_PATH"] == "/custom/browsers"

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/portacode/tests/test_system_handlers.py

@@ -19,3 +19,18 @@ def test_system_info_includes_codex_installation_capability(monkeypatch):
         "app_server_supported": True,
         "ready": True,
     }
+
+
+def test_system_info_includes_persistent_browser_config(monkeypatch):
+    expected = {
+        "viewport": {"width": 390, "height": 844},
+        "video": {"width": 390, "height": 844},
+    }
+    monkeypatch.setattr(
+        "portacode.connection.handlers.system_handlers.load_browser_config",
+        lambda: expected,
+    )
+
+    payload = SystemInfoHandler(None, {}).execute({})
+
+    assert payload["info"]["browser_config"] == expected

{portacode-2.2.20.dev2 → portacode-2.2.20.dev4}/portacode.egg-info/PKG-INFO

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