portacode 2.2.20.dev3__tar.gz → 2.2.20.dev5__tar.gz

{portacode-2.2.20.dev3 → portacode-2.2.20.dev5}/PKG-INFO

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

{portacode-2.2.20.dev3 → portacode-2.2.20.dev5}/portacode/browser_cli.py

@@ -9,6 +9,8 @@ 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")
 
@@ -19,10 +21,14 @@ def _configure_managed_browser_path() -> None:
 
 
 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] = []
@@ -39,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()
@@ -100,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()."""
@@ -114,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.dev3 → portacode-2.2.20.dev5}/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.dev3 → portacode-2.2.20.dev5}/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,11 +26,86 @@ _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');
 const { chromium } = require(process.env.PORTACODE_PLAYWRIGHT_JS || 'playwright');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 const locator = (p,s) => {
   let l;
   if (s.role) l=p.getByRole(s.role, s.name === undefined ? {} : {name:s.name, exact:!!s.exact});
@@ -44,6 +120,39 @@ const closeContext = async () => {
  if(context) await context.close().catch(()=>{});
  context=null; page=null;
 };
+const installDemoLayer = async page => page.evaluate(() => {
+ if (document.querySelector('#__portacode_demo_cursor')) return;
+ const style=document.createElement('style'); style.id='__portacode_demo_style';
+ style.textContent=`#__portacode_demo_cursor{position:fixed;left:0;top:0;width:22px;height:22px;z-index:2147483647;pointer-events:none;filter:drop-shadow(0 2px 3px #0008);transform:translate(-3px,-2px);transition:opacity .2s}#__portacode_demo_cursor:before{content:'';display:block;width:0;height:0;border-top:19px solid #fff;border-right:12px solid transparent;filter:drop-shadow(0 0 1px #111)}.__portacode_demo_focus{position:fixed;z-index:2147483645;pointer-events:none;border:3px solid #32d583;border-radius:12px;box-shadow:0 0 0 5px #32d58333,0 8px 30px #0004;opacity:0;transition:all .28s ease,opacity .18s}.__portacode_demo_ripple{position:fixed;z-index:2147483646;pointer-events:none;width:18px;height:18px;margin:-9px;border:3px solid #32d583;border-radius:50%;animation:__pcRipple .55s ease-out forwards}@keyframes __pcRipple{to{transform:scale(3.4);opacity:0}}`;
+ document.documentElement.appendChild(style);
+ const cursor=document.createElement('div');cursor.id='__portacode_demo_cursor';document.documentElement.appendChild(cursor);
+ const focus=document.createElement('div');focus.className='__portacode_demo_focus';document.documentElement.appendChild(focus);
+ window.__pcDemo={x:Math.min(innerWidth-30,32),y:Math.min(innerHeight-30,80)};
+ cursor.style.transform=`translate(${window.__pcDemo.x}px,${window.__pcDemo.y}px)`;
+});
+const demoMove = async (page, locator, cfg, zoom=true) => {
+ if (!cfg.demo) return;
+ await locator.scrollIntoViewIfNeeded().catch(()=>{}); await sleep(250);
+ const box=await locator.boundingBox(); if(!box) return;
+ const point={x:box.x+box.width/2,y:box.y+box.height/2};
+ await page.evaluate(({box,point,desktopZoom}) => new Promise(resolve => {
+  const cursor=document.querySelector('#__portacode_demo_cursor'), focus=document.querySelector('.__portacode_demo_focus');
+  const from=window.__pcDemo||{x:30,y:80}, started=performance.now(), duration=Math.min(900,Math.max(420,Math.hypot(point.x-from.x,point.y-from.y)*1.35));
+  focus.style.left=`${box.x-5}px`;focus.style.top=`${box.y-5}px`;focus.style.width=`${box.width+10}px`;focus.style.height=`${box.height+10}px`;focus.style.opacity='1';
+  if(desktopZoom){document.body.style.transformOrigin=`${point.x}px ${point.y}px`;document.body.style.transition='transform 520ms cubic-bezier(.2,.8,.2,1)';document.body.style.transform='scale(1.055)';}
+  const tick=now=>{const t=Math.min(1,(now-started)/duration),e=1-Math.pow(1-t,3);const x=from.x+(point.x-from.x)*e,y=from.y+(point.y-from.y)*e;cursor.style.transform=`translate(${x}px,${y}px)`;if(t<1)requestAnimationFrame(tick);else{window.__pcDemo=point;resolve();}};requestAnimationFrame(tick);
+ }), {box,point,desktopZoom:zoom&&cfg.viewport.width>=900});
+ await sleep(260);
+};
+const demoClick = async (page, locator, cfg) => {
+ if(!cfg.demo) return;
+ const box=await locator.boundingBox(); if(!box)return;
+ await page.evaluate(({x,y})=>{const r=document.createElement('div');r.className='__portacode_demo_ripple';r.style.left=`${x}px`;r.style.top=`${y}px`;document.documentElement.appendChild(r);setTimeout(()=>r.remove(),700);},{x:box.x+box.width/2,y:box.y+box.height/2});
+};
+const demoRelease = async (page,cfg,hold=620) => {
+ if(!cfg.demo)return; await sleep(hold);
+ await page.evaluate(()=>{const f=document.querySelector('.__portacode_demo_focus');if(f)f.style.opacity='0';document.body.style.transform='scale(1)';}); await sleep(380);
+};
 const ensureContext = async cfg => {
  if(context && cfg.video_dir) await closeContext();
  if(!context) {
@@ -56,6 +165,7 @@ const ensureContext = async cfg => {
  }
  if(!page || page.isClosed()) {const pages=context.pages();page=pages[0] || await context.newPage();}
  await page.setViewportSize(cfg.viewport);
+ if(cfg.demo) await installDemoLayer(page);
  return page;
 };
 const run = async cfg => {
@@ -71,13 +181,13 @@ const run = async cfg => {
    const s=cfg.steps[i], op=s.op; let value=null;
    try {
     const l = ['click','fill','press','select','check','uncheck','assert','read'].includes(op) ? locator(page,s) : null;
-    if(op==='goto') await page.goto(s.url,{waitUntil:s.wait_until||'domcontentloaded'});
-    else if(op==='click') await l.click();
-    else if(op==='fill') await l.fill(String(s.value??''));
-    else if(op==='press') await l.press(s.key);
-    else if(op==='select') value=await l.selectOption(s.value);
-    else if(op==='check') await l.check();
-    else if(op==='uncheck') await l.uncheck();
+    if(op==='goto') {await page.goto(s.url,{waitUntil:s.wait_until||'domcontentloaded'});if(cfg.demo){await installDemoLayer(page);await sleep(900);}}
+    else if(op==='click') {await demoMove(page,l,cfg);await demoClick(page,l,cfg);await l.click();await demoRelease(page,cfg);}
+    else if(op==='fill') {await demoMove(page,l,cfg,false);if(cfg.demo&&await l.getAttribute('type')!=='password'){await l.click();await l.fill('');await l.pressSequentially(String(s.value??''),{delay:55});}else await l.fill(String(s.value??''));await demoRelease(page,cfg,420);}
+    else if(op==='press') {await demoMove(page,l,cfg,false);await l.press(s.key);await demoRelease(page,cfg,500);}
+    else if(op==='select') {await demoMove(page,l,cfg);value=await l.selectOption(s.value);await demoRelease(page,cfg,650);}
+    else if(op==='check') {await demoMove(page,l,cfg,false);await demoClick(page,l,cfg);await l.check();await demoRelease(page,cfg,450);}
+    else if(op==='uncheck') {await demoMove(page,l,cfg,false);await demoClick(page,l,cfg);await l.uncheck();await demoRelease(page,cfg,450);}
     else if(op==='wait') s.ms ? await page.waitForTimeout(s.ms) : await page.waitForLoadState(s.state||'domcontentloaded');
     else if(op==='assert') { const kind=s.kind||'visible'; if(kind==='visible') await l.waitFor({state:'visible'}); else if(kind==='hidden') await l.waitFor({state:'hidden'}); else if(kind==='text'){const got=await l.textContent();if(!String(got||'').includes(String(s.value)))throw Error(`expected text ${s.value}`); } else if(kind==='url'){if(!page.url().includes(String(s.value)))throw Error(`expected URL ${s.value}`);} else throw Error('unsupported assertion'); }
     else if(op==='read') { if(s.attribute) value=await l.getAttribute(s.attribute); else if(s.kind==='value') value=await l.inputValue(); else if(s.kind==='count') value=await l.count(); else value=(await l.innerText()).slice(0,8000); }
@@ -87,6 +197,7 @@ const run = async cfg => {
     out.steps.push({i,op,ok:true,...(value===null?{}:{value})});
    } catch(e) { out.steps.push({i,op,ok:false,error:String(e.message||e).slice(0,500)}); if(cfg.screenshot_on_failure){const b=await page.screenshot({type:'jpeg',quality:cfg.image_quality});out.screenshots.push({step:i,data:b.toString('base64'),mime_type:'image/jpeg',failure:true});} throw e; }
   }
+  if(cfg.demo) await sleep(1800);
   if(cfg.final_screenshot){const b=await page.screenshot({type:'jpeg',quality:cfg.image_quality});out.screenshots.push({step:'final',data:b.toString('base64'),mime_type:'image/jpeg'});}
   out.ok=true; out.url=page.url(); out.title=await page.title();
  } catch(e) {out.error=String(e.message||e).slice(0,1000);}
@@ -293,6 +404,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 +454,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,10 +474,11 @@ 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,
+            "deadline_ms": 180_000 if video_dir else None,
+            "demo": bool(video_dir),
             "image_quality": min(max(int(message.get("image_quality") or 65), 30), 85),
             "final_screenshot": bool(message.get("final_screenshot", True)),
             "screenshot_on_failure": bool(message.get("screenshot_on_failure", True)),
@@ -362,7 +492,7 @@ class BrowserRunHandler(AsyncHandler):
         worker = await _worker_for(
             user=user, session_id=session_id, argv=argv, env=env,
         )
-        run_limit = min(75 if video_dir else 300, 20 + len(steps) * timeout_ms / 1000)
+        run_limit = min(240 if video_dir else 300, 30 + len(steps) * timeout_ms / 1000)
         result = await worker.run(config, timeout=run_limit)
         result.update({"event": "browser_run_response", "success": bool(result.get("ok"))})
         return result

{portacode-2.2.20.dev3 → portacode-2.2.20.dev5}/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.dev3 → portacode-2.2.20.dev5}/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,85 @@ 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)
+
+    def test_video_demo_layer_has_cursor_zoom_typing_and_click_effects(self):
+        runner = browser_handlers._RUNNER
+        self.assertIn("__portacode_demo_cursor", runner)
+        self.assertIn("desktopZoom", runner)
+        self.assertIn("pressSequentially", runner)
+        self.assertIn("__portacode_demo_ripple", runner)
+        self.assertIn("if(cfg.demo)", runner)
+
+    async def test_demo_presentation_is_enabled_only_for_video(self):
+        worker = AsyncMock()
+        worker.run.return_value = {"ok": True, "steps": [], "screenshots": []}
+        with (
+            patch.object(browser_handlers, "load_browser_config", return_value={"viewport":{"width":390,"height":844},"video":{"width":390,"height":844}}),
+            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":"fast","steps":[],"record_video":False})
+            await self.handler.execute({"session_id":"demo","steps":[],"record_video":True})
+        self.assertFalse(worker.run.await_args_list[0].args[0]["demo"])
+        self.assertTrue(worker.run.await_args_list[1].args[0]["demo"])
+
+    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.dev3 → portacode-2.2.20.dev5}/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.dev3 → portacode-2.2.20.dev5}/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.dev3 → portacode-2.2.20.dev5}/portacode.egg-info/PKG-INFO

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