browser-agent-server 1.0.4__tar.gz → 1.0.5__tar.gz

browser_agent_server-1.0.5/.github/dependabot.yml

@@ -0,0 +1,17 @@
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: "/"
+    schedule:
+      interval: weekly
+    groups:
+      python-deps:
+        patterns: ["*"]
+
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly
+    groups:
+      github-actions:
+        patterns: ["*"]

browser_agent_server-1.0.5/.github/workflows/ci.yml

@@ -0,0 +1,56 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  schedule:
+    - cron: "17 5 * * 1"   # Mondays 05:17 UTC — catch bit-rotting deps early
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  python:
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.12", "3.13"]
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      # setup-uv restores the uv cache (keyed on uv.lock/pyproject.toml); never pass
+      # --no-cache here — it defeats that restore. `uv sync` installs the project
+      # itself (editable) together with the `dev` group, so `uv run pytest` resolves
+      # to the venv's interpreter rather than silently falling back to a system one.
+      - name: Install
+        run: uv sync --python ${{ matrix.python }}
+      # Lint is Python-version independent: run it once, on one leg, instead of
+      # duplicating it (and a second install) on every leg.
+      - name: Ruff
+        if: matrix.python == '3.13'
+        run: uv run ruff check src tests
+      - name: Tests
+        run: uv run pytest -q
+
+  gitleaks:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      # GITHUB_TOKEN is required to scan pull_request events: the action posts
+      # findings as PR comments and refuses to run without it. Without this env
+      # the check fails on every PR while still passing on pushes to main, which
+      # is exactly the "green on main, red on the PR" split that hides problems.
+      - uses: gitleaks/gitleaks-action@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{browser_agent_server-1.0.4 → browser_agent_server-1.0.5}/.github/workflows/release.yml

@@ -15,8 +15,7 @@ jobs:
           python-version: "3.12"
       - name: Verify
         run: |
-          uv venv
-          uv pip install -e ".[dev]" --no-cache
+          uv sync
           uv run ruff check src tests
           uv run pytest -q
       - name: Build

{browser_agent_server-1.0.4 → browser_agent_server-1.0.5}/AGENTS.md

@@ -6,7 +6,7 @@
 
 - PyPI dist: `browser-agent-server` · import: `browser_agent` · CLI: `browser-agent`
 - Python ≥ 3.12, src-layout, hatchling, **one runtime dependency** (`trafilatura`). That is deliberate (1 GB RAM target hosts) — do not add deps without an issue discussion.
-- Toolchain: `uv` (`uv pip install -e ".[dev]"`), ruff (E/F/I/UP/B, line 100), pytest.
+- Toolchain: `uv` (`uv sync` builds the venv, installs the project itself editable and the `dev` group; then `uv run pytest` / `uv run ruff`), ruff (E/F/I/UP/B, line 100), pytest.
 - Tests: unit only in CI (`pytest`); real-Chrome tests are opt-in: `BROWSER_AGENT_IT=1 pytest -m integration`.
 
 ## Invariants — do not break these

{browser_agent_server-1.0.4 → browser_agent_server-1.0.5}/CHANGELOG.md

@@ -3,7 +3,45 @@
 All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
-## [Unreleased]
+## [1.0.5] - 2026-10-10
+
+### Fixed
+
+- `stop()` no longer globs `/tmp/Crashpad*` and deletes it. That directory is shared by
+  every Chrome on the host, so stopping one session wiped other sessions' crash dumps.
+- Malformed action payloads are now rejected *before* the browser is launched. A `goto`
+  without a `url`, a `move` without coordinates, a `click` with only one of `x`/`y`, a `key`
+  without a `key` or a `scroll` with a bad `direction` previously paid the full Chrome/Xvfb
+  startup and then failed with a browser error that hid the real cause.
+- GET and POST routing strips the query string, so `GET /status?verbose=1` and
+  `POST /action?x=1` no longer return 404.
+- `browser-agent doctor` now reports the state dir it actually probes: `STATE_HOME` comes
+  from `default_state_dir()` and therefore honours `BROWSER_AGENT_STATE_DIR` and
+  `XDG_STATE_HOME` instead of silently ignoring both.
+- The X-lock check in `doctor` derives the display from `DEFAULT_DISPLAY` rather than a
+  hardcoded `:99`, so the check cannot drift from the display the daemon actually uses.
+
+### Changed
+
+- HTTP responses are HTTP/1.1 with keep-alive. Every response already sent an accurate
+  `Content-Length`, so the connection-per-request (and thread-per-connection) cost was
+  avoidable.
+- `_default_state_dir()` is public `default_state_dir()` — the CLI needs the same source of
+  truth as the daemon.
+
+### CI
+
+- `ci.yml` gained `concurrency` cancellation and per-job `timeout-minutes`, so superseded
+  runs stop consuming runners and hung checks cannot block the queue.
+- `--no-cache` removed from the `uv pip install` step — it was defeating the uv cache that
+  `astral-sh/setup-uv` restores (keyed on `uv.lock`/`pyproject.toml`).
+- `ruff check` now runs once, on a single matrix leg, instead of being duplicated on every
+  Python version; the lint result cannot differ per version, and a second install step was
+  avoided by not splitting it into its own job.
+
+### Added
+
+- `.github/dependabot.yml` — weekly grouped updates for pip and github-actions.
 
 ## [1.0.4] - 2026-10-10
 

{browser_agent_server-1.0.4 → browser_agent_server-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: browser-agent-server
-Version: 1.0.4
+Version: 1.0.5
 Summary: Real headful Chrome on Xvfb with a hardware-level X11 mouse, Cloudflare Turnstile auto-solve and zero-leak CDP. Localhost HTTP API + CLI + Python SDK.
 Project-URL: Homepage, https://github.com/vernikr/browser-agent
 Project-URL: Repository, https://github.com/vernikr/browser-agent
@@ -16,9 +16,6 @@ Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.12
 Requires-Dist: trafilatura<3,>=1.12
-Provides-Extra: dev
-Requires-Dist: pytest>=8.0; extra == 'dev'
-Requires-Dist: ruff>=0.6; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # browser-agent

browser_agent_server-1.0.5/docs/multi-project-cd.md

@@ -0,0 +1,154 @@
+# Multi-project CD: push every release to production from CI
+
+The deploy used for `browser-agent` generalizes to any number of projects on the same
+server. This page is the one-stop playbook — give it (or the prompt at the bottom) to any
+agent to wire up a new project in ~20 minutes.
+
+## Architecture (once per server)
+
+```
+GitHub release.yml (tag push)
+  build → publish (OIDC, no tokens)
+  → deploy job → reusable workflow deploy-ssh.yml
+       └─ ssh <ci-key>@host "deploy <app> <ver>"
+            └─ authorized_keys forced command → /usr/local/bin/deploy-tools
+                 └─ /etc/deploy-tools.d/<app>.conf
+                      └─ install exact version → restart unit → healthcheck → rollback
+```
+
+- **One CI key serves all projects.** The key is pinned by a forced command to the
+  dispatcher; it cannot open a shell, forward ports, or run anything else.
+- **The whitelist of deployable apps is the server itself**: an app exists iff a
+  root-owned `/etc/deploy-tools.d/<app>.conf` exists. Unknown names are rejected.
+- **No public endpoint, no firewall changes** — push arrives over the SSH port that is
+  already open for admin access.
+
+Server-side artifacts (already installed on 38.244.152.2; copy to a new host as-is):
+
+- `/usr/local/bin/deploy-tools` — the generic dispatcher (protocol: `deploy <app> <semver>`;
+  legacy `deploy <semver>` works while exactly one app is configured).
+- `/etc/deploy-tools.d/browser-agent.conf` — the reference app config.
+- backups under `/root/bak/`.
+
+## Step 0 (fallback) — manually, if the agent has no GitHub token / SSH (~5 min)
+
+The agent normally does ALL of this from the prompt below — you hand agents the GitHub token and server SSH anyway (see server-spec), so it can go end-to-end (that is exactly how browser-agent got wired). Do it manually only if you do not want to grant those.
+
+**1. Generate a fresh keypair per repo.** Why not reuse an existing key? GitHub secrets are
+write-only — a private key already stored in another repo cannot be read back, and no local
+copy should survive. A per-repo key is also cleaner to rotate/revoke: drop one
+`authorized_keys` line and that repo loses access.
+
+> Note: for `browser-agent` itself this Step 0 was performed by the setup agent during the
+> initial CD bootstrap (it generated the keypair, installed the pubkey, and created the repo
+> secrets via the GitHub API) — which is exactly why that key is unrecoverable and the rule
+> above exists.
+
+```bash
+ssh-keygen -t ed25519 -f ci-deploy-<app> -N "" -C ci-deploy-<app>
+
+# append the pubkey as ANOTHER line (never touch existing command="..." lines):
+ssh root@<host> "echo 'command=\"/usr/local/bin/deploy-tools\",no-pty,no-port-forwarding,no-agent-forwarding,no-X11-forwarding '$(cat ci-deploy-<app>.pub) >> /root/.ssh/authorized_keys"
+
+# if smoke shows an AUTH failure (asks for password / hangs), the appended line is
+# malformed — remove it by its comment and retry:
+#   ssh root@<host> "sed -i '/ci-deploy-<app>$/d' /root/.ssh/authorized_keys"
+# smoke BEFORE deleting the private key — expect a REJECT, not an auth failure:
+ssh -i ci-deploy-<app> root@<host> "id"   # -> [deploy] ERROR: unsupported command ...
+```
+
+**2. Set three repo secrets** (Settings → Secrets and variables → Actions, or gh CLI, which
+encrypts for you):
+
+```bash
+gh secret set DEPLOY_SSH_KEY --repo vernikr/<repo> < ci-deploy-<app>
+gh secret set DEPLOY_HOST  --repo vernikr/<repo> --body <host>
+gh secret set DEPLOY_USER  --repo vernikr/<repo> --body root
+rm ci-deploy-<app>   # keep no local copy of the private key
+```
+
+## Per-project checklist (~20 min)
+
+Prerequisites: the project is a package published from CI to a registry with OIDC
+trusted publishing (same one-time registry setup as in `docs/publishing.md`), and it runs
+on the server as a systemd unit with some health signal.
+
+1. **Systemd unit** — the service must come up healthy after `systemctl restart`. Health
+   signal: either a JSON endpoint answering `"version": "X.Y.Z"` or a CLI
+   `myapp --version`. No JSON endpoint? Put `HEALTH_CMD=...` in the config.
+2. **Server config** — create `/etc/deploy-tools.d/<app>.conf` (app name: `[a-z0-9-]+`):
+
+   ```bash
+   INSTALLER=uv                 # uv (Python) | npm-global (Node)
+   PKG=<registry package name>  # e.g. my-tool-server / @scope/my-tool
+   BIN=<executable name>        # for uv tools (for --version); optional otherwise
+   UNIT=<systemd unit name>
+   STATUS_URL=http://127.0.0.1:PORT/status   # OR: HEALTH_CMD='...'
+   HEALTH_FIELD=version
+   ```
+
+   Test on the host:
+
+   ```bash
+   SSH_ORIGINAL_COMMAND="deploy <app> <current-version>" /usr/local/bin/deploy-tools
+   # expect: "already on <ver> and healthy — nothing to do"
+   ```
+
+3. **Registry/CI side already solved**: publish from `release.yml` exactly like this repo
+   (`pypi`/`npm` job first, so deploy only installs what already exists in the registry).
+4. **Deploy job** in the project's `release.yml`:
+
+   ```yaml
+   deploy:
+     needs: <publish-job>
+     uses: vernikr/browser-agent/.github/workflows/deploy-ssh.yml@main
+     with:
+       app: <app>
+       tag: ${{ github.ref_name }}
+     secrets: inherit
+   ```
+
+5. **Key and repo secrets** — done by the owner in Step 0 (fresh keypair per repo; existing
+   secret values can't be read back — GitHub secrets are write-only).
+6. **Smoke-release**: tag `vX.Y.Z+1`, watch the Actions tab — deploy should be green and
+   the unit should report the new version on its health endpoint.
+
+Failure semantics: unreadable registry → retries; bad health → automatic reinstall of the
+previous version, restart, re-check, and the CI job turns red. Everything is logged in the
+GitHub job — no `journalctl` digging needed for routine failures.
+
+## Agent prompt (copy-paste; agent needs your GitHub token + server SSH)
+
+> Wire the `<PROJECT>` repo for push-style CD to our production server `38.244.152.2`,
+> per `vernikr/browser-agent/docs/multi-project-cd.md`. Given: a GitHub token (repo secrets
+> write) and SSH root@38.244.152.2 (see server-spec). Do everything end-to-end:
+>
+> **(1) Deploy key.** `ssh-keygen -t ed25519 -f /tmp/ci-deploy-<app> -N "" -C ci-deploy-<app>`
+> (keys ONLY in /tmp — never in project files or git). Append the pubkey as a NEW line in
+> `/root/.ssh/authorized_keys` with forced command
+> `command="/usr/local/bin/deploy-tools",no-pty,no-port-forwarding,no-agent-forwarding,no-X11-forwarding`
+> (back up the file to `/root/bak/` first). Smoke:
+> `ssh -i /tmp/ci-deploy-<app> root@38.244.152.2 "id"` → expect a REJECT
+> ("unsupported command"); on an AUTH failure the line is malformed —
+> `sed -i '/ci-deploy-<app>$/d' /root/.ssh/authorized_keys` and retry.
+>
+> **(2) Repo secrets** in `<PROJECT>`: `DEPLOY_SSH_KEY` (private key contents),
+> `DEPLOY_HOST=38.244.152.2`, `DEPLOY_USER=root` — via `gh secret set` or the Secrets REST API
+> (encrypt with a libsodium sealed box using the repo's public key; never plaintext-commit).
+> Then `rm -f /tmp/ci-deploy-<app>*`.
+>
+> **(3) Server config.** `/etc/deploy-tools.d/<app>.conf`:
+> `INSTALLER=uv|npm-global`, `PKG=<PKG>`, `BIN=<exe>` (uv), `UNIT=<UNIT>`,
+> `STATUS_URL=http://127.0.0.1:<PORT>/status` (or `HEALTH_CMD`), `HEALTH_FIELD=version`.
+> Smoke: `SSH_ORIGINAL_COMMAND="deploy <app> <current-version>" /usr/local/bin/deploy-tools`
+> → "already on … and healthy".
+>
+> **(4) CI job.** In `<PROJECT>`'s `release.yml`: `deploy` needing the publish job, calling
+> `vernikr/browser-agent/.github/workflows/deploy-ssh.yml@main` with
+> `with: { app: <app>, tag: github.ref_name }` and `secrets: inherit`.
+>
+> **(5) Smoke release**: tag a patch → all jobs green → the unit reports the new version.
+>
+> Hard rules: never touch other services, firewall, or VPN units on the server; never write
+> private keys/secrets into git or project files; back up to `/root/bak/` before editing
+> `authorized_keys` or the dispatcher.

{browser_agent_server-1.0.4 → browser_agent_server-1.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "browser-agent-server"
-version = "1.0.4"
+version = "1.0.5"
 description = "Real headful Chrome on Xvfb with a hardware-level X11 mouse, Cloudflare Turnstile auto-solve and zero-leak CDP. Localhost HTTP API + CLI + Python SDK."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -16,7 +16,7 @@ classifiers = [
 ]
 dependencies = ["trafilatura>=1.12,<3"]
 
-[project.optional-dependencies]
+[dependency-groups]
 dev = ["pytest>=8.0", "ruff>=0.6"]
 
 [project.urls]

{browser_agent_server-1.0.4 → browser_agent_server-1.0.5}/src/browser_agent/chrome.py

@@ -33,6 +33,9 @@ CF_CHALLENGE_MARKERS = (
 # Forbidden CDP domains that trigger Cloudflare / DataDome / PerimeterX detection
 FORBIDDEN_CDP_METHODS = frozenset({"Runtime.enable", "Console.enable", "Debugger.enable"})
 
+#: X11 display the daemon starts Xvfb on unless a session overrides it.
+DEFAULT_DISPLAY = ":99"
+
 
 class StealthCDPConnection:
     """Minimal RFC-6455 WebSocket client for Chrome DevTools Protocol without Runtime.enable leaks."""
@@ -180,7 +183,7 @@ def is_cloudflare_challenge(html: str, title: str = "") -> bool:
     return any(m in hay for m in CF_CHALLENGE_MARKERS)
 
 
-def _default_state_dir() -> Path:
+def default_state_dir() -> Path:
     """XDG state directory for the agent (profile, logs). Override with BROWSER_AGENT_STATE_DIR."""
     if os.environ.get("BROWSER_AGENT_STATE_DIR"):
         return Path(os.environ["BROWSER_AGENT_STATE_DIR"])
@@ -205,12 +208,12 @@ class RealChromeSession:
         if user_data_dir is None:
             # Chrome profile with persisted logins. Set BROWSER_AGENT_PROFILE_DIR to keep
             # a pre-existing profile (e.g. /tmp/browser-agent-profile on legacy installs).
-            user_data_dir = os.environ.get("BROWSER_AGENT_PROFILE_DIR") or str(_default_state_dir() / "profile")
+            user_data_dir = os.environ.get("BROWSER_AGENT_PROFILE_DIR") or str(default_state_dir() / "profile")
         self.user_data_dir = Path(user_data_dir)
         self.proxy_url = proxy_url
         self._active_proxy: str | None = None
         self._chrome_proc: subprocess.Popen | None = None
-        self._stderr_path = _default_state_dir() / "chrome.err"
+        self._stderr_path = default_state_dir() / "chrome.err"
         self._stderr_file = None
         self.last_used: float = time.time()
         # Typical Chrome top UI bar height (tabs + address bar) in openbox
@@ -362,8 +365,6 @@ class RealChromeSession:
     def stop(self) -> None:
         self._stop_chrome_only()
         self.x11.stop()
-        for p in Path("/tmp").glob("Crashpad*"):
-            shutil.rmtree(p, ignore_errors=True)
 
     def get_html_and_title(self) -> tuple[str, str, str]:
         """Return (current_url, page_title, outer_html) using DOM.getOuterHTML (zero Runtime.enable)."""

{browser_agent_server-1.0.4 → browser_agent_server-1.0.5}/src/browser_agent/cli.py

@@ -28,13 +28,13 @@ from importlib import resources
 from pathlib import Path
 
 from . import __version__
-from .chrome import find_chrome_binary, is_warp_proxy_ready
+from .chrome import DEFAULT_DISPLAY, default_state_dir, find_chrome_binary, is_warp_proxy_ready
 from .server import API_VERSION, DEFAULT_HOST, DEFAULT_IDLE_TIMEOUT, DEFAULT_PORT, serve
 
 log = logging.getLogger("browser_agent.cli")
 
 APT_PACKAGES = ("xvfb", "openbox", "xdotool", "scrot", "x11vnc")
-STATE_HOME = Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local" / "state")) / "browser-agent"
+STATE_HOME = default_state_dir()
 
 
 # ---------------------------------------------------------------------------
@@ -200,8 +200,13 @@ def cmd_doctor(args: argparse.Namespace) -> int:
     except FileNotFoundError as e:
         checks.append(_check("chrome-binary", False, str(e).split(".")[0]))
 
-    lock = Path("/tmp/.X99-lock")
-    checks.append(_check("display :99 free", not lock.exists(), "stale /tmp/.X99-lock present" if lock.exists() else "no lock", False))
+    lock = Path(f"/tmp/.X{DEFAULT_DISPLAY.lstrip(':')}-lock")
+    checks.append(_check(
+        f"display {DEFAULT_DISPLAY} free",
+        not lock.exists(),
+        f"stale {lock} present" if lock.exists() else "no lock",
+        False,
+    ))
 
     try:
         STATE_HOME.mkdir(parents=True, exist_ok=True)

{browser_agent_server-1.0.4 → browser_agent_server-1.0.5}/src/browser_agent/server.py

@@ -40,6 +40,61 @@ DEFAULT_PORT = int(os.environ.get("BROWSER_AGENT_PORT", "8765"))
 DEFAULT_IDLE_TIMEOUT = int(os.environ.get("BROWSER_AGENT_IDLE_SEC", "60"))
 
 
+_KNOWN_ACTIONS = frozenset(
+    {
+        "goto",
+        "move",
+        "click",
+        "type",
+        "key",
+        "scroll",
+        "screenshot",
+        "html",
+    }
+)
+_SCROLL_DIRECTIONS = frozenset({"up", "down"})
+
+
+def _coord(payload: dict, name: str) -> int | None:
+    raw = payload.get(name)
+    return None if raw is None else int(raw)
+
+
+def _validate_action(act: str, payload: dict) -> None:
+    """Reject a malformed action *before* the browser is asked to start.
+
+    Every failure here is a caller bug: the payload is already known to be
+    unusable, so launching Chrome to fail a few seconds later would only
+    replace the real cause with a "browser failed to start" message. Kept
+    proportional — only the shapes that would otherwise fail silently or
+    deep inside a driver are checked.
+    """
+    if act not in _KNOWN_ACTIONS:
+        raise ValueError(
+            f"Unknown action: {act!r}. Known actions: "
+            + ", ".join(sorted(_KNOWN_ACTIONS | {"stop", "vnc_start", "vnc_stop"}))
+        )
+    if act == "goto" and not str(payload.get("url") or "").strip():
+        raise ValueError("action 'goto' requires a non-empty 'url'")
+    if act == "move" and (payload.get("x") is None or payload.get("y") is None):
+        raise ValueError("action 'move' requires both integer 'x' and 'y'")
+    if (payload.get("x") is None) != (payload.get("y") is None):
+        raise ValueError(
+            f"action {act!r} got only one of 'x'/'y' — pass both to click a point, "
+            "or neither to use the current cursor position"
+        )
+    if act == "key" and not str(payload.get("key") or "").strip():
+        raise ValueError("action 'key' requires a non-empty 'key'")
+    if act == "scroll":
+        if str(payload.get("direction", "down")).strip().lower() not in _SCROLL_DIRECTIONS:
+            raise ValueError(
+                f"action 'scroll' direction must be one of "
+                f"{', '.join(sorted(_SCROLL_DIRECTIONS))}"
+            )
+        if int(payload.get("clicks", 4)) < 1:
+            raise ValueError("action 'scroll' requires 'clicks' >= 1")
+
+
 class BrowserCoordinator:
     """Thread-safe single-tab Chrome + X11 manager with automatic idle hibernation."""
 
@@ -110,6 +165,8 @@ class BrowserCoordinator:
                 self.session.x11.stop_vnc()
                 return {"ok": True}
 
+            _validate_action(act, payload)
+
             self.session.start(use_proxy=payload.get("use_proxy"))
 
             if act == "goto":
@@ -131,8 +188,8 @@ class BrowserCoordinator:
 
             if act == "click":
                 pos = self.session.x11.click(
-                    x=int(payload["x"]) if payload.get("x") is not None else None,
-                    y=int(payload["y"]) if payload.get("y") is not None else None,
+                    x=_coord(payload, "x"),
+                    y=_coord(payload, "y"),
                     button=int(payload.get("button", 1)),
                     double=bool(payload.get("double", False)),
                 )
@@ -150,8 +207,8 @@ class BrowserCoordinator:
                 self.session.x11.scroll(
                     clicks=int(payload.get("clicks", 4)),
                     direction=str(payload.get("direction", "down")),
-                    x=int(payload["x"]) if payload.get("x") is not None else None,
-                    y=int(payload["y"]) if payload.get("y") is not None else None,
+                    x=_coord(payload, "x"),
+                    y=_coord(payload, "y"),
                 )
                 return {"ok": True}
 
@@ -187,9 +244,17 @@ class BrowserCoordinator:
 
 def make_handler(coord: BrowserCoordinator):
     class Handler(BaseHTTPRequestHandler):
+        # Keep-alive: every path already sends an accurate Content-Length, so
+        # HTTP/1.0's connection-per-request (and thread-per-connection) is avoidable.
+        protocol_version = "HTTP/1.1"
+
         def log_message(self, fmt: str, *args) -> None:
             log.info("%s - %s", self.address_string(), fmt % args)
 
+        def _route(self) -> str:
+            """Path without a query string — `curl /status?x=1` must not 404."""
+            return self.path.split("?", 1)[0].rstrip("/")
+
         def _send_json(self, code: int, data: dict) -> None:
             body = json.dumps(data, ensure_ascii=False).encode("utf-8")
             self.send_response(code)
@@ -205,7 +270,7 @@ def make_handler(coord: BrowserCoordinator):
             return json.loads(self.rfile.read(length).decode("utf-8"))
 
         def do_GET(self) -> None:  # noqa: N802
-            if self.path.rstrip("/") in ("", "/health", "/status"):
+            if self._route() in ("", "/health", "/status"):
                 self._send_json(200, coord.status())
             else:
                 self._send_json(404, {"ok": False, "error": "Not found"})
@@ -213,7 +278,7 @@ def make_handler(coord: BrowserCoordinator):
         def do_POST(self) -> None:  # noqa: N802
             try:
                 payload = self._read_json()
-                path = self.path.rstrip("/")
+                path = self._route()
                 if path == "/fetch":
                     self._send_json(200, coord.fetch(payload))
                 elif path == "/action":

browser_agent_server-1.0.5/tests/test_cli_state_home.py

@@ -0,0 +1,63 @@
+"""The CLI's state dir must come from the same source the daemon uses.
+
+`browser-agent doctor` prints the state dir it is about to check. If the CLI
+ever hardcodes a path, doctor reports one location while the daemon writes to
+another — the diagnostic then blames a writable directory for a failure that
+happened somewhere else entirely. One test, reloading the module, keeps the
+two locked together.
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+import subprocess
+import sys
+
+import browser_agent.cli as cli_mod
+
+
+def _reload_cli():
+    return importlib.reload(cli_mod)
+
+
+def test_cli_state_home_tracks_env_override(monkeypatch, tmp_path):
+    home = tmp_path / "custom-state"
+    monkeypatch.setenv("XDG_STATE_HOME", str(home))
+    monkeypatch.delenv("BROWSER_AGENT_STATE_DIR", raising=False)
+    try:
+        mod = _reload_cli()
+        assert mod.STATE_HOME == home / "browser-agent"
+    finally:
+        monkeypatch.delenv("XDG_STATE_HOME")
+        monkeypatch.delenv("BROWSER_AGENT_STATE_DIR", raising=False)
+        _reload_cli()
+
+
+def test_cli_state_home_tracks_explicit_override(monkeypatch, tmp_path):
+    explicit = tmp_path / "elsewhere"
+    monkeypatch.setenv("BROWSER_AGENT_STATE_DIR", str(explicit))
+    try:
+        mod = _reload_cli()
+        assert mod.STATE_HOME == explicit
+    finally:
+        monkeypatch.delenv("BROWSER_AGENT_STATE_DIR")
+        _reload_cli()
+
+
+def test_doctor_reports_the_state_dir_it_checked(tmp_path):
+    """End-to-end: the path in the report is the one that was probed."""
+    env = {
+        **os.environ,
+        "BROWSER_AGENT_STATE_DIR": str(tmp_path / "state"),
+    }
+    proc = subprocess.run(
+        [sys.executable, "-m", "browser_agent.cli", "doctor"],
+        capture_output=True,
+        text=True,
+        timeout=60,
+        env=env,
+    )
+    assert proc.returncode in (0, 1)
+    assert "state dir writable" in proc.stdout + proc.stderr
+    assert str(tmp_path / "state") in proc.stdout + proc.stderr

browser_agent_server-1.0.5/tests/test_http_edges.py

@@ -0,0 +1,104 @@
+"""HTTP contract details: routing, keep-alive, and validation error messages.
+
+Existing coverage lives in test_http_api.py; this file targets the edge cases
+that reach an agent as a confusing failure.
+"""
+from __future__ import annotations
+
+import http.client
+import json
+
+import pytest
+
+from browser_agent.server import (  # noqa: F401
+    API_VERSION,
+    BrowserCoordinator,
+    ThreadingHTTPServer,
+    make_handler,
+)
+
+
+@pytest.fixture()
+def http_server():
+    coord = BrowserCoordinator(idle_timeout_sec=60)
+    srv = ThreadingHTTPServer(("127.0.0.1", 0), make_handler(coord))
+    t = __import__("threading").Thread(target=srv.serve_forever, daemon=True)
+    t.start()
+    host, port = srv.server_address
+    yield host, port, coord
+    srv.shutdown()
+    coord.shutdown()
+
+
+def _conn(host, port) -> http.client.HTTPConnection:
+    return http.client.HTTPConnection(host, port, timeout=10)
+
+
+def _post(conn, path, payload):
+    body = json.dumps(payload)
+    conn.request("POST", path, body=body, headers={"Content-Type": "application/json"})
+    r = conn.getresponse()
+    return r.status, json.loads(r.read().decode())
+
+
+def test_query_string_does_not_break_routing(http_server):
+    host, port, _ = http_server
+    c = _conn(host, port)
+    try:
+        for path in ("/status?verbose=1", "/status/", "/health?x=1", "/?probe=1"):
+            c.request("GET", path)
+            r = c.getresponse()
+            data = json.loads(r.read().decode())
+            assert r.status == 200, f"{path} should route to /status"
+            assert data["api_version"] == API_VERSION
+    finally:
+        c.close()
+
+
+def test_keep_alive_serves_several_requests_on_one_connection(http_server):
+    host, port, _ = http_server
+    c = _conn(host, port)
+    try:
+        for _ in range(4):
+            c.request("GET", "/status")
+            r = c.getresponse()
+            assert r.status == 200
+            assert json.loads(r.read().decode())["ok"] is True
+        # The connection must still be usable — HTTP/1.0 would have closed it.
+        assert c.sock is not None
+    finally:
+        c.close()
+
+
+def test_move_without_coordinates_returns_a_named_error(http_server):
+    host, port, _ = http_server
+    c = _conn(host, port)
+    try:
+        code, data = _post(c, "/action", {"action": "move"})
+        assert code in (400, 500)
+        assert "x" in data["error"] and "y" in data["error"]
+    finally:
+        c.close()
+
+
+def test_goto_without_url_returns_a_named_error(http_server):
+    host, port, _ = http_server
+    c = _conn(host, port)
+    try:
+        for payload in ({"action": "goto"}, {"action": "goto", "url": "   "}):
+            code, data = _post(c, "/action", payload)
+            assert code in (400, 500)
+            assert "url" in data["error"].lower()
+    finally:
+        c.close()
+
+
+def test_unknown_action_still_names_the_action(http_server):
+    host, port, _ = http_server
+    c = _conn(host, port)
+    try:
+        code, data = _post(c, "/action", {"action": "teleport"})
+        assert code in (400, 500)
+        assert "teleport" in data["error"]
+    finally:
+        c.close()

{browser_agent_server-1.0.4 → browser_agent_server-1.0.5}/uv.lock

@@ -13,25 +13,26 @@ wheels = [
 
 [[package]]
 name = "browser-agent-server"
-version = "1.0.4"
+version = "1.0.5"
 source = { editable = "." }
 dependencies = [
     { name = "trafilatura" },
 ]
 
-[package.optional-dependencies]
+[package.dev-dependencies]
 dev = [
     { name = "pytest" },
     { name = "ruff" },
 ]
 
 [package.metadata]
-requires-dist = [
-    { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0" },
-    { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.6" },
-    { name = "trafilatura", specifier = ">=1.12,<3" },
+requires-dist = [{ name = "trafilatura", specifier = ">=1.12,<3" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = ">=8.0" },
+    { name = "ruff", specifier = ">=0.6" },
 ]
-provides-extras = ["dev"]
 
 [[package]]
 name = "certifi"

browser_agent_server-1.0.4/.github/workflows/ci.yml

@@ -1,38 +0,0 @@
-name: ci
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-  schedule:
-    - cron: "17 5 * * 1"   # Mondays 05:17 UTC — catch bit-rotting deps early
-  workflow_dispatch:
-
-jobs:
-  python:
-    strategy:
-      matrix:
-        python: ["3.12", "3.13"]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: astral-sh/setup-uv@v5
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python }}
-      - name: Install
-        run: |
-          uv venv
-          uv pip install -e ".[dev]" --no-cache
-      - name: Ruff
-        run: uv run ruff check src tests
-      - name: Tests
-        run: uv run pytest -q
-
-  gitleaks:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - uses: gitleaks/gitleaks-action@v2

browser_agent_server-1.0.4/docs/multi-project-cd.md

@@ -1,99 +0,0 @@
-# Multi-project CD: push every release to production from CI
-
-The deploy used for `browser-agent` generalizes to any number of projects on the same
-server. This page is the one-stop playbook — give it (or the prompt at the bottom) to any
-agent to wire up a new project in ~20 minutes.
-
-## Architecture (once per server)
-
-```
-GitHub release.yml (tag push)
-  build → publish (OIDC, no tokens)
-  → deploy job → reusable workflow deploy-ssh.yml
-       └─ ssh <ci-key>@host "deploy <app> <ver>"
-            └─ authorized_keys forced command → /usr/local/bin/deploy-tools
-                 └─ /etc/deploy-tools.d/<app>.conf
-                      └─ install exact version → restart unit → healthcheck → rollback
-```
-
-- **One CI key serves all projects.** The key is pinned by a forced command to the
-  dispatcher; it cannot open a shell, forward ports, or run anything else.
-- **The whitelist of deployable apps is the server itself**: an app exists iff a
-  root-owned `/etc/deploy-tools.d/<app>.conf` exists. Unknown names are rejected.
-- **No public endpoint, no firewall changes** — push arrives over the SSH port that is
-  already open for admin access.
-
-Server-side artifacts (already installed on 38.244.152.2; copy to a new host as-is):
-
-- `/usr/local/bin/deploy-tools` — the generic dispatcher (protocol: `deploy <app> <semver>`;
-  legacy `deploy <semver>` works while exactly one app is configured).
-- `/etc/deploy-tools.d/browser-agent.conf` — the reference app config.
-- backups under `/root/bak/`.
-
-## Per-project checklist (~20 min)
-
-Prerequisites: the project is a package published from CI to a registry with OIDC
-trusted publishing (same one-time registry setup as in `docs/publishing.md`), and it runs
-on the server as a systemd unit with some health signal.
-
-1. **Systemd unit** — the service must come up healthy after `systemctl restart`. Health
-   signal: either a JSON endpoint answering `"version": "X.Y.Z"` or a CLI
-   `myapp --version`. No JSON endpoint? Put `HEALTH_CMD=...` in the config.
-2. **Server config** — create `/etc/deploy-tools.d/<app>.conf` (app name: `[a-z0-9-]+`):
-
-   ```bash
-   INSTALLER=uv                 # uv (Python) | npm-global (Node)
-   PKG=<registry package name>  # e.g. my-tool-server / @scope/my-tool
-   BIN=<executable name>        # for uv tools (for --version); optional otherwise
-   UNIT=<systemd unit name>
-   STATUS_URL=http://127.0.0.1:PORT/status   # OR: HEALTH_CMD='...'
-   HEALTH_FIELD=version
-   ```
-
-   Test on the host:
-
-   ```bash
-   SSH_ORIGINAL_COMMAND="deploy <app> <current-version>" /usr/local/bin/deploy-tools
-   # expect: "already on <ver> and healthy — nothing to do"
-   ```
-
-3. **Registry/CI side already solved**: publish from `release.yml` exactly like this repo
-   (`pypi`/`npm` job first, so deploy only installs what already exists in the registry).
-4. **Deploy job** in the project's `release.yml`:
-
-   ```yaml
-   deploy:
-     needs: <publish-job>
-     uses: vernikr/browser-agent/.github/workflows/deploy-ssh.yml@main
-     with:
-       app: <app>
-       tag: ${{ github.ref_name }}
-     secrets: inherit
-   ```
-
-5. **Repo secrets** (Settings → Secrets and variables → Actions): `DEPLOY_SSH_KEY`,
-   `DEPLOY_HOST`, `DEPLOY_USER` — the same values as in this repo (reusing the same
-   single-purpose key across repos is fine and simplifies rotation; rotate by replacing
-   the one `authorized_keys` line + the secret values).
-6. **Smoke-release**: tag `vX.Y.Z+1`, watch the Actions tab — deploy should be green and
-   the unit should report the new version on its health endpoint.
-
-Failure semantics: unreadable registry → retries; bad health → automatic reinstall of the
-previous version, restart, re-check, and the CI job turns red. Everything is logged in the
-GitHub job — no `journalctl` digging needed for routine failures.
-
-## Agent prompt (copy-paste to configure a new project)
-
-> Wire the `<PROJECT>` repo for push-style CD to our production server, following
-> `vernikr/browser-agent/docs/multi-project-cd.md`: (1) on the server create
-> `/etc/deploy-tools.d/<app>.conf` for unit `<UNIT>`, package `<PKG>` (`INSTALLER=uv|npm-global`),
-> health via `STATUS_URL=<...>` or `HEALTH_CMD`, then smoke-test with
-> `SSH_ORIGINAL_COMMAND="deploy <app> <current-version>" /usr/local/bin/deploy-tools`;
-> (2) add a `deploy` job to `<PROJECT>`'s `release.yml` that `needs:` the publish job and
-> calls `vernikr/browser-agent/.github/workflows/deploy-ssh.yml@main` with
-> `with: { app: <app>, tag: github.ref_name }` and `secrets: inherit`;
-> (3) add the repo secrets `DEPLOY_SSH_KEY` / `DEPLOY_HOST` / `DEPLOY_USER` (same values as
-> in `vernikr/browser-agent`); (4) ship a patch release and confirm the deploy job is green
-> and the unit reports the new version. Do not touch other services, firewall, or VPN units
-> on the server; before modifying `authorized_keys` or the dispatcher, back the file up to
-> `/root/bak/`.