brow-cli 0.1.0__tar.gz

brow_cli-0.1.0/.gitignore

@@ -0,0 +1,27 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.venv/
+venv/
+ENV/
+env/
+.pytest_cache/
+.coverage
+htmlcov/

brow_cli-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: brow-cli
+Version: 0.1.0
+Summary: Standalone Playwright CLI for agent browser automation
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.104
+Requires-Dist: httpx>=0.25
+Requires-Dist: playwright>=1.40
+Requires-Dist: typer>=0.9
+Requires-Dist: uvicorn>=0.24
+Provides-Extra: dev
+Requires-Dist: httpx>=0.25; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'

brow_cli-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "brow-cli"
+version = "0.1.0"
+description = "Standalone Playwright CLI for agent browser automation"
+requires-python = ">=3.11"
+dependencies = [
+    "playwright>=1.40",
+    "fastapi>=0.104",
+    "uvicorn>=0.24",
+    "typer>=0.9",
+    "httpx>=0.25",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.23",
+    "httpx>=0.25",
+]
+
+[project.scripts]
+brow = "brow.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/brow"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

brow_cli-0.1.0/src/brow/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

brow_cli-0.1.0/src/brow/__main__.py

@@ -0,0 +1,6 @@
+import sys
+from brow.daemon import run_daemon
+
+if __name__ == "__main__":
+    port = int(sys.argv[sys.argv.index("--port") + 1]) if "--port" in sys.argv else None
+    run_daemon(port=port)

brow_cli-0.1.0/src/brow/cli.py

@@ -0,0 +1,304 @@
+import asyncio
+import subprocess
+import sys
+import time
+from typing import Optional
+
+import typer
+
+from brow.client import BrowClient
+from brow.config import DAEMON_HOST, DAEMON_PORT
+from brow.daemon import daemon_running, stop_daemon
+
+app = typer.Typer(name="brow", no_args_is_help=True)
+daemon_app = typer.Typer(name="daemon", no_args_is_help=True)
+session_app = typer.Typer(name="session", no_args_is_help=True)
+profile_app = typer.Typer(name="profile", no_args_is_help=True)
+state_app = typer.Typer(name="state", no_args_is_help=True)
+page_app = typer.Typer(name="page", no_args_is_help=True)
+
+app.add_typer(daemon_app, name="daemon")
+app.add_typer(session_app, name="session")
+app.add_typer(profile_app, name="profile")
+app.add_typer(state_app, name="state")
+app.add_typer(page_app, name="page")
+
+session_opt = typer.Option(None, "-s", "--session")
+
+def run_async(coro):
+    return asyncio.run(coro)
+
+def _client():
+    return BrowClient()
+
+def _daemon_healthy():
+    import httpx
+    try:
+        r = httpx.get(f"http://{DAEMON_HOST}:{DAEMON_PORT}/status", timeout=1.0)
+        return r.status_code == 200
+    except Exception:
+        return False
+
+def ensure_daemon():
+    if _daemon_healthy():
+        return
+    subprocess.Popen(
+        [sys.executable, "-m", "brow.daemon"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    for _ in range(50):
+        time.sleep(0.3)
+        if _daemon_healthy():
+            return
+    typer.echo("Failed to start daemon", err=True)
+    raise typer.Exit(1)
+
+@daemon_app.command("start")
+def daemon_start(port: int = DAEMON_PORT):
+    if daemon_running():
+        typer.echo("Daemon already running")
+        return
+    subprocess.Popen(
+        [sys.executable, "-m", "brow.daemon", "--port", str(port)],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    typer.echo(f"Daemon starting on {DAEMON_HOST}:{port}")
+
+@daemon_app.command("stop")
+def daemon_stop_cmd():
+    if stop_daemon():
+        typer.echo("Daemon stopped")
+    else:
+        typer.echo("Daemon not running")
+
+@daemon_app.command("status")
+def daemon_status():
+    if not daemon_running():
+        typer.echo("Daemon not running")
+        return
+    c = _client()
+    result = run_async(c.get("/status"))
+    typer.echo(f"Running — {result['sessions']} active sessions")
+
+@session_app.command("new")
+def session_new(profile: str = "default", headed: bool = False):
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.post("/sessions", json={"profile": profile, "headless": not headed}))
+    typer.echo(result["id"])
+
+@session_app.command("list")
+def session_list():
+    ensure_daemon()
+    c = _client()
+    sessions = run_async(c.get("/sessions"))
+    if not sessions:
+        typer.echo("No active sessions")
+        return
+    for s in sessions:
+        typer.echo(f"{s['id']}\t{s['profile']}\t{'headed' if not s['headless'] else 'headless'}\t{s['pages']} pages")
+
+@session_app.command("delete")
+def session_delete(sid: str):
+    ensure_daemon()
+    c = _client()
+    run_async(c.delete(f"/sessions/{sid}"))
+    typer.echo(f"Deleted session {sid}")
+
+@app.command("navigate")
+def navigate(url: str, s: Optional[str] = session_opt, timeout: int = 30000):
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.post(f"/browser/{s}/navigate", json={"url": url, "timeout": timeout}))
+    typer.echo(f"{result['url']} [{result.get('status', '')}]")
+
+@app.command("wait")
+def wait_cmd(selector: Optional[str] = None, load: bool = False, s: Optional[str] = session_opt, timeout: int = 30000):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/wait", json={"selector": selector, "load": load, "timeout": timeout}))
+    typer.echo("Done")
+
+@app.command("snapshot")
+def snapshot_cmd(search: Optional[str] = None, locator: Optional[str] = None, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    params = {}
+    if search:
+        params["search"] = search
+    if locator:
+        params["locator"] = locator
+    result = run_async(c.get(f"/browser/{s}/snapshot", params=params))
+    typer.echo(result["tree"])
+
+@app.command("screenshot")
+def screenshot_cmd(full: bool = False, path: Optional[str] = None, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.post(f"/browser/{s}/screenshot", json={"full": full, "path": path}))
+    typer.echo(result["path"])
+
+@app.command("html")
+def html_cmd(locator: Optional[str] = None, search: Optional[str] = None, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    params = {}
+    if locator:
+        params["locator"] = locator
+    if search:
+        params["search"] = search
+    result = run_async(c.get(f"/browser/{s}/html", params=params))
+    typer.echo(result["html"])
+
+@app.command("url")
+def url_cmd(s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.get(f"/browser/{s}/url"))
+    typer.echo(result["url"])
+
+@app.command("logs")
+def logs_cmd(search: Optional[str] = None, count: int = 50, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    params = {"count": count}
+    if search:
+        params["search"] = search
+    result = run_async(c.get(f"/browser/{s}/logs", params=params))
+    typer.echo(result["logs"])
+
+@app.command("click")
+def click_cmd(selector: str, s: Optional[str] = session_opt, timeout: int = 30000):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/click", json={"selector": selector, "timeout": timeout}))
+
+@app.command("fill")
+def fill_cmd(selector: str, value: str, s: Optional[str] = session_opt, timeout: int = 30000):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/fill", json={"selector": selector, "value": value, "timeout": timeout}))
+
+@app.command("type")
+def type_cmd(text: str, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/type", json={"text": text}))
+
+@app.command("key")
+def key_cmd(key: str, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/key", json={"key": key}))
+
+@app.command("hover")
+def hover_cmd(selector: str, s: Optional[str] = session_opt, timeout: int = 30000):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/hover", json={"selector": selector, "timeout": timeout}))
+
+@app.command("scroll")
+def scroll_cmd(pixels: int = 0, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/scroll", json={"pixels": pixels}))
+
+@app.command("scroll-to")
+def scroll_to_cmd(selector: str, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/scroll", json={"selector": selector}))
+
+@app.command("drag")
+def drag_cmd(source: str, target: str, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/drag", json={"source": source, "target": target}))
+
+@app.command("upload")
+def upload_cmd(selector: str, filepath: str, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/browser/{s}/upload", json={"selector": selector, "filepath": filepath}))
+
+@page_app.command("list")
+def page_list(s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.get(f"/pages/{s}"))
+    for p in result["pages"]:
+        typer.echo(f"{p['index']}\t{p['url']}")
+
+@page_app.command("new")
+def page_new(url: Optional[str] = None, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.post(f"/pages/{s}/new", json={"url": url}))
+    typer.echo(f"Page {result['index']}: {result['url']}")
+
+@page_app.command("close")
+def page_close(index: Optional[int] = None, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post(f"/pages/{s}/close", params={"index": index} if index is not None else {}))
+
+@page_app.command("switch")
+def page_switch(index: int, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.post(f"/pages/{s}/switch", json={"index": index}))
+    typer.echo(f"Switched to page {result['active']}: {result['url']}")
+
+@profile_app.command("list")
+def profile_list():
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.get("/profiles"))
+    for p in result["profiles"]:
+        typer.echo(p)
+
+@profile_app.command("delete")
+def profile_delete(name: str):
+    ensure_daemon()
+    c = _client()
+    run_async(c.delete(f"/profiles/{name}"))
+    typer.echo(f"Deleted profile {name}")
+
+@state_app.command("save")
+def state_save(name: str, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post("/states/save", json={"name": name, "session_id": s}))
+    typer.echo(f"State saved: {name}")
+
+@state_app.command("restore")
+def state_restore(name: str, s: Optional[str] = session_opt):
+    ensure_daemon()
+    c = _client()
+    run_async(c.post("/states/restore", json={"name": name, "session_id": s}))
+    typer.echo(f"State restored: {name}")
+
+@state_app.command("list")
+def state_list():
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.get("/states"))
+    for st in result["states"]:
+        typer.echo(st)
+
+@app.command("eval")
+def eval_cmd(code: str, s: Optional[str] = session_opt, timeout: int = 30000):
+    ensure_daemon()
+    c = _client()
+    result = run_async(c.post(f"/eval/{s}", json={"code": code, "timeout": timeout}))
+    if result.get("stdout"):
+        typer.echo(result["stdout"], nl=False)
+    if result.get("result") is not None:
+        typer.echo(result["result"])
+
+if __name__ == "__main__":
+    app()

brow_cli-0.1.0/src/brow/client.py

@@ -0,0 +1,27 @@
+import httpx
+from brow.config import DAEMON_URL
+
+class BrowClient:
+    def __init__(self, base_url=None):
+        self._client = httpx.AsyncClient(
+            base_url=base_url or DAEMON_URL,
+            timeout=60.0,
+        )
+
+    async def get(self, path, **kwargs):
+        r = await self._client.get(path, **kwargs)
+        r.raise_for_status()
+        return r.json()
+
+    async def post(self, path, **kwargs):
+        r = await self._client.post(path, **kwargs)
+        r.raise_for_status()
+        return r.json()
+
+    async def delete(self, path, **kwargs):
+        r = await self._client.delete(path, **kwargs)
+        r.raise_for_status()
+        return r.json()
+
+    async def close(self):
+        await self._client.aclose()

brow_cli-0.1.0/src/brow/config.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+import os
+
+BROW_HOME = Path(os.environ.get("BROW_HOME", Path.home() / ".brow"))
+PROFILES_DIR = BROW_HOME / "profiles"
+STATES_DIR = BROW_HOME / "states"
+SCREENSHOTS_DIR = BROW_HOME / "screenshots"
+PID_FILE = BROW_HOME / "daemon.pid"
+LOG_FILE = BROW_HOME / "daemon.log"
+
+DAEMON_HOST = "127.0.0.1"
+DAEMON_PORT = int(os.environ.get("BROW_PORT", "19987"))
+DAEMON_URL = f"http://{DAEMON_HOST}:{DAEMON_PORT}"
+
+MAX_SESSIONS = int(os.environ.get("BROW_MAX_SESSIONS", "10"))
+DEFAULT_TIMEOUT = 30000
+
+def ensure_dirs():
+    for d in [BROW_HOME, PROFILES_DIR, STATES_DIR, SCREENSHOTS_DIR]:
+        d.mkdir(parents=True, exist_ok=True)

brow_cli-0.1.0/src/brow/daemon.py

@@ -0,0 +1,82 @@
+import os
+import signal
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI
+from playwright.async_api import async_playwright
+
+from brow.config import DAEMON_HOST, DAEMON_PORT, PID_FILE, ensure_dirs
+from brow.session import SessionManager
+from brow.profiles import ProfileManager
+
+def create_app():
+    manager = SessionManager()
+    profiles = ProfileManager()
+
+    @asynccontextmanager
+    async def lifespan(app):
+        pw = await async_playwright().start()
+        app.state.pw = pw
+        app.state.manager = manager
+        app.state.profiles = profiles
+        yield
+        await manager.close_all()
+        await pw.stop()
+
+    app = FastAPI(lifespan=lifespan)
+
+    from brow.routes.sessions import router as sessions_router
+    from brow.routes.browser import router as browser_router
+    from brow.routes.pages import router as pages_router
+    from brow.routes.profiles import router as profiles_router
+    from brow.routes.eval import router as eval_router
+
+    app.include_router(sessions_router)
+    app.include_router(browser_router)
+    app.include_router(pages_router)
+    app.include_router(profiles_router)
+    app.include_router(eval_router)
+
+    @app.get("/status")
+    async def status():
+        return {"sessions": len(manager.sessions), "status": "running"}
+
+    return app
+
+def run_daemon(host=None, port=None):
+    ensure_dirs()
+    host = host or DAEMON_HOST
+    port = port or DAEMON_PORT
+    PID_FILE.write_text(str(os.getpid()))
+    try:
+        uvicorn.run(create_app(), host=host, port=port, log_level="warning")
+    finally:
+        PID_FILE.unlink(missing_ok=True)
+
+def stop_daemon():
+    if not PID_FILE.exists():
+        return False
+    pid = int(PID_FILE.read_text().strip())
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except ProcessLookupError:
+        pass
+    PID_FILE.unlink(missing_ok=True)
+    return True
+
+def daemon_running():
+    if not PID_FILE.exists():
+        return False
+    pid = int(PID_FILE.read_text().strip())
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        PID_FILE.unlink(missing_ok=True)
+        return False
+
+if __name__ == "__main__":
+    import sys
+    port = int(sys.argv[sys.argv.index("--port") + 1]) if "--port" in sys.argv else None
+    run_daemon(port=port)

brow_cli-0.1.0/src/brow/profiles.py

@@ -0,0 +1,38 @@
+import json
+import shutil
+import brow.config as cfg
+
+class ProfileManager:
+    def __init__(self):
+        cfg.ensure_dirs()
+
+    def get_profile_dir(self, name):
+        p = cfg.PROFILES_DIR / name
+        p.mkdir(parents=True, exist_ok=True)
+        return p
+
+    def list(self):
+        if not cfg.PROFILES_DIR.exists():
+            return []
+        return [d.name for d in cfg.PROFILES_DIR.iterdir() if d.is_dir()]
+
+    def delete(self, name):
+        p = cfg.PROFILES_DIR / name
+        if not p.exists():
+            raise KeyError(f"Profile '{name}' not found")
+        shutil.rmtree(p)
+
+    def save_state(self, name, state):
+        cfg.ensure_dirs()
+        (cfg.STATES_DIR / f"{name}.json").write_text(json.dumps(state, indent=2))
+
+    def load_state(self, name):
+        path = cfg.STATES_DIR / f"{name}.json"
+        if not path.exists():
+            raise FileNotFoundError(f"State '{name}' not found")
+        return json.loads(path.read_text())
+
+    def list_states(self):
+        if not cfg.STATES_DIR.exists():
+            return []
+        return [p.stem for p in cfg.STATES_DIR.glob("*.json")]