feat: add abs alias, refresh extension panel, and bump to 0.16.1-fork.1

- bind MediaQueryList methods when proxied for prefers-color-scheme light patch

- add regression test for addEventListener/removeEventListener

- bump version to 0.14.0-fork.6 and sync Cargo metadata

.changeset/README.md

@@ -0,0 +1,23 @@
+# Changesets
+
+This project uses [Changesets](https://github.com/changesets/changesets) for versioning and changelog generation.
+
+## Adding a changeset
+
+When you make a change that should be released, run:
+
+```bash
+pnpm changeset
+```
+
+This will prompt you to:
+1. Select the type of change (patch, minor, major)
+2. Write a summary of your changes
+
+The changeset file will be committed with your PR.
+
+## Release process
+
+When changesets are merged to `main`, the release workflow will:
+1. Create a "Version Packages" PR that updates version numbers and changelogs
+2. When that PR is merged, packages are automatically published to npm

.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "public",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

.claude-plugin/marketplace.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
   "name": "agent-browser",
-  "description": "Browser automation for AI agents",
+  "description": "Headless browser automation for AI agents",
   "owner": {
     "name": "Vercel",
     "email": "support@vercel.com"

.github/workflows/ci.yml

@@ -18,6 +18,43 @@ jobs:
       - name: Check version sync
         run: node scripts/check-version-sync.js
 
+  typescript:
+    name: TypeScript (Node ${{ matrix.node-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20, 22]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Setup Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Typecheck
+        run: pnpm typecheck
+
+      - name: Format check
+        run: pnpm format:check
+
+      - name: Install Playwright browsers
+        run: pnpm exec playwright install --with-deps chromium
+
+      - name: Run tests
+        run: pnpm test
+
   rust:
     name: Rust
     runs-on: ubuntu-latest
@@ -27,20 +64,12 @@ jobs:
 
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt, clippy
 
       - name: Cache Rust build artifacts
         uses: Swatinem/rust-cache@v2
         with:
           workspaces: cli
 
-      - name: Format check
-        run: cargo fmt --manifest-path cli/Cargo.toml -- --check
-
-      - name: Clippy check
-        run: cargo clippy --manifest-path cli/Cargo.toml -- -D warnings
-
       - name: Run Rust tests
         run: cargo test --profile ci --manifest-path cli/Cargo.toml
 
@@ -55,7 +84,7 @@ jobs:
             target: aarch64-apple-darwin
           - os: macos-latest
             target: x86_64-apple-darwin
-          - os: windows-latest
+          - os: windows-latest-8-cores
             target: x86_64-pc-windows-msvc
 
     steps:
@@ -75,40 +104,27 @@ jobs:
       - name: Run Rust tests
         run: cargo test --profile ci --manifest-path cli/Cargo.toml --target ${{ matrix.target }}
 
-  native-e2e:
-    name: Native E2E Tests
-    if: github.event_name != 'pull_request'
-    runs-on: ubuntu-latest
-    needs: rust
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Cache Rust build artifacts
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: cli
-
-      - name: Install Chrome
-        run: |
-          cargo run --manifest-path cli/Cargo.toml -- install --with-deps
-
-      - name: Run e2e tests
-        run: cargo test --profile ci --manifest-path cli/Cargo.toml e2e -- --ignored --test-threads=1
-
   windows-integration:
     name: Windows Integration Test
     if: github.event_name != 'pull_request'
-    runs-on: windows-latest
+    runs-on: windows-latest-8-cores
     needs: rust-cross
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -122,6 +138,12 @@ jobs:
       - name: Build Rust CLI
         run: cargo build --release --manifest-path cli/Cargo.toml --target x86_64-pc-windows-msvc
 
+      - name: Install npm dependencies
+        run: pnpm install
+
+      - name: Build TypeScript
+        run: pnpm build
+
       - name: Copy CLI binary to bin directory
         run: |
           Copy-Item cli/target/x86_64-pc-windows-msvc/release/agent-browser.exe bin/agent-browser-win32-x64.exe
@@ -139,6 +161,18 @@ jobs:
         shell: pwsh
         timeout-minutes: 10
 
+      - name: Verify Chromium was installed
+        run: |
+          $playwrightPath = "$env:LOCALAPPDATA\ms-playwright"
+          if (Test-Path $playwrightPath) {
+            Write-Host "Playwright browsers installed at: $playwrightPath"
+            Get-ChildItem $playwrightPath -Recurse -Depth 2 | Select-Object -First 20
+          } else {
+            Write-Error "Playwright browsers not found!"
+            exit 1
+          }
+        shell: pwsh
+
       - name: Test daemon lifecycle (open, snapshot, close)
         run: |
           $env:PATH = "$pwd\bin;$env:PATH"
@@ -156,6 +190,37 @@ jobs:
         shell: pwsh
         timeout-minutes: 5
 
+  serverless-chromium:
+    name: Serverless Chromium (@sparticuz/chromium)
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Install @sparticuz/chromium
+        run: pnpm add -D @sparticuz/chromium
+
+      - name: Build TypeScript
+        run: pnpm build
+
+      - name: Run serverless integration test
+        run: pnpm exec vitest run test/serverless.test.ts
+
   global-install:
     name: Global Install (${{ matrix.os }})
     if: github.event_name != 'pull_request'
@@ -170,7 +235,7 @@ jobs:
           - os: macos-latest
             target: aarch64-apple-darwin
             binary: agent-browser-darwin-arm64
-          - os: windows-latest
+          - os: windows-latest-8-cores
             target: x86_64-pc-windows-msvc
             binary: agent-browser-win32-x64.exe
 
@@ -178,10 +243,16 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
           node-version: 22
+          cache: pnpm
 
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -196,6 +267,12 @@ jobs:
       - name: Build Rust CLI
         run: cargo build --release --manifest-path cli/Cargo.toml --target ${{ matrix.target }}
 
+      - name: Install npm dependencies
+        run: pnpm install
+
+      - name: Build TypeScript
+        run: pnpm build
+
       - name: Copy CLI binary to bin directory (Unix)
         if: runner.os != 'Windows'
         run: cp cli/target/${{ matrix.target }}/release/agent-browser bin/${{ matrix.binary }}
@@ -222,7 +299,7 @@ jobs:
             echo "ERROR: Symlink should point to native binary, not JS wrapper"
             exit 1
           fi
-          echo "Symlink correctly points to native binary"
+          echo "✓ Symlink correctly points to native binary"
         shell: bash
 
       - name: Verify shim points to native binary (Windows)
@@ -237,5 +314,5 @@ jobs:
             echo "ERROR: Shim should point to native .exe, not JS wrapper"
             exit 1
           }
-          echo "Shim correctly points to native binary"
+          echo "✓ Shim correctly points to native binary"
         shell: pwsh

.github/workflows/release.yml

@@ -10,40 +10,13 @@ concurrency: ${{ github.workflow }}-${{ github.ref }}
 
 permissions:
   contents: write
+  pull-requests: write
+  id-token: write
 
 jobs:
-  check-release:
-    name: Check for new version
-    runs-on: ubuntu-latest
-    outputs:
-      should_release: ${{ steps.check.outputs.should_release }}
-      version: ${{ steps.check.outputs.version }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Compare package.json version to npm
-        id: check
-        run: |
-          LOCAL_VERSION=$(node -p "require('./package.json').version")
-          echo "Local version: $LOCAL_VERSION"
-
-          NPM_VERSION=$(npm view agent-browser version 2>/dev/null || echo "0.0.0")
-          echo "npm version: $NPM_VERSION"
-
-          if [ "$LOCAL_VERSION" != "$NPM_VERSION" ]; then
-            echo "Version changed: $NPM_VERSION -> $LOCAL_VERSION"
-            echo "should_release=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "Version unchanged, skipping release"
-            echo "should_release=false" >> "$GITHUB_OUTPUT"
-          fi
-          echo "version=$LOCAL_VERSION" >> "$GITHUB_OUTPUT"
-
+  # Build native binaries for all platforms first
   build-binaries:
     name: Build ${{ matrix.name }}
-    needs: check-release
-    if: needs.check-release.outputs.should_release == 'true'
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -59,16 +32,6 @@ jobs:
             target: aarch64-unknown-linux-gnu
             binary: agent-browser-linux-arm64
             use_zigbuild: true
-          - name: Linux musl x64
-            os: ubuntu-latest
-            target: x86_64-unknown-linux-musl
-            binary: agent-browser-linux-musl-x64
-            use_zigbuild: true
-          - name: Linux musl ARM64
-            os: ubuntu-latest
-            target: aarch64-unknown-linux-musl
-            binary: agent-browser-linux-musl-arm64
-            use_zigbuild: true
           - name: Windows x64
             os: ubuntu-latest
             target: x86_64-pc-windows-gnu
@@ -165,13 +128,19 @@ jobs:
           path: artifacts/${{ matrix.binary }}
           retention-days: 7
 
-  publish:
-    name: Publish to npm
-    needs: [check-release, build-binaries]
+  # Create release PR or publish to npm (with binaries)
+  release:
+    name: Release
+    needs: build-binaries
     runs-on: ubuntu-latest
+    outputs:
+      published: ${{ steps.publish_metadata.outputs.published }}
+      publishedPackages: ${{ steps.publish_metadata.outputs.publishedPackages }}
     steps:
-      - name: Checkout repository
+      - name: Checkout Repo
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
       - name: Setup pnpm
         uses: pnpm/action-setup@v4
@@ -183,9 +152,8 @@ jobs:
         with:
           node-version: '22'
           cache: pnpm
-          registry-url: 'https://registry.npmjs.org'
 
-      - name: Install dependencies
+      - name: Install Dependencies
         run: pnpm install --frozen-lockfile
 
       - name: Download all binary artifacts
@@ -207,13 +175,11 @@ jobs:
           EXPECTED_BINARIES=(
             "agent-browser-linux-x64"
             "agent-browser-linux-arm64"
-            "agent-browser-linux-musl-x64"
-            "agent-browser-linux-musl-arm64"
             "agent-browser-win32-x64.exe"
             "agent-browser-darwin-x64"
             "agent-browser-darwin-arm64"
           )
-          MIN_SIZE=100000
+          MIN_SIZE=100000  # Binaries should be at least 100KB
           ERRORS=0
           for binary in "${EXPECTED_BINARIES[@]}"; do
             if [ ! -f "bin/$binary" ]; then
@@ -233,20 +199,69 @@ jobs:
             echo "Error: $ERRORS binary issues found"
             exit 1
           fi
-          echo "All 7 platform binaries present and valid"
+          echo "All 5 platform binaries present and valid"
 
-      - name: Publish to npm
-        run: pnpm publish --no-git-checks
+      - name: Create Release Pull Request or Publish to npm
+        id: changesets
+        uses: changesets/action@v1
+        with:
+          version: pnpm ci:version
+          title: 'chore: version packages'
+          commit: 'chore: version packages'
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_VERCEL_TOKEN_ELEVATED }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Check if publish is needed
+        id: publish_check
+        if: steps.changesets.outputs.hasChangesets == 'false'
+        run: |
+          LOCAL_VERSION=$(node -p "require('./package.json').version")
+          REMOTE_VERSION=$(npm view agent-browser-stealth version 2>/dev/null || echo "")
+          echo "local_version=$LOCAL_VERSION" >> "$GITHUB_OUTPUT"
+          echo "remote_version=$REMOTE_VERSION" >> "$GITHUB_OUTPUT"
+          if [ "$LOCAL_VERSION" != "$REMOTE_VERSION" ]; then
+            echo "needs_publish=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "needs_publish=false" >> "$GITHUB_OUTPUT"
+          fi
+          echo "Local:  $LOCAL_VERSION"
+          echo "Remote: ${REMOTE_VERSION:-<none>}"
+
+      - name: Publish to npm (trusted publishing)
+        id: publish_npm
+        if: steps.changesets.outputs.hasChangesets == 'false' && steps.publish_check.outputs.needs_publish == 'true'
+        env:
+          NODE_AUTH_TOKEN: ""
+          NPM_CONFIG_USERCONFIG: /home/runner/work/_temp/trusted-npmrc
+          NPM_CONFIG_PROVENANCE: "true"
+        run: |
+          npm install -g npm@^11
+          npm --version
+          printf "registry=https://registry.npmjs.org/\n" > "$NPM_CONFIG_USERCONFIG"
+          pnpm ci:publish
+
+      - name: Set release outputs
+        id: publish_metadata
+        run: |
+          if [ "${{ steps.publish_npm.outcome }}" = "success" ]; then
+            echo "published=true" >> "$GITHUB_OUTPUT"
+            echo "publishedPackages=[{\"name\":\"agent-browser-stealth\",\"version\":\"${{ steps.publish_check.outputs.local_version }}\"}]" >> "$GITHUB_OUTPUT"
+          else
+            echo "published=false" >> "$GITHUB_OUTPUT"
+            echo "publishedPackages=[]" >> "$GITHUB_OUTPUT"
+          fi
+
+  # Create GitHub release with binaries after npm publish
   github-release:
     name: Create GitHub Release
-    needs: [check-release, publish]
+    needs: release
+    if: needs.release.outputs.published == 'true'
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout repository
+      - name: Checkout Repo
         uses: actions/checkout@v4
+        with:
+          ref: main
 
       - name: Download all artifacts
         uses: actions/download-artifact@v4
@@ -264,59 +279,28 @@ jobs:
       - name: Verify binaries exist
         run: |
           BINARY_COUNT=$(ls bin/agent-browser-* 2>/dev/null | wc -l)
-          if [ "$BINARY_COUNT" -lt 7 ]; then
-            echo "Error: Expected 7 binaries, found $BINARY_COUNT"
+          if [ "$BINARY_COUNT" -lt 5 ]; then
+            echo "Error: Expected 5 binaries, found $BINARY_COUNT"
             ls -la bin/
             exit 1
           fi
           echo "Found $BINARY_COUNT binaries"
 
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build dashboard
-        run: pnpm --filter dashboard build
-
-      - name: Create dashboard.zip
-        run: cd packages/dashboard/out && zip -r ../../../dashboard.zip .
-
-      - name: Extract changelog entry
-        run: |
-          VERSION="${{ needs.check-release.outputs.version }}"
-          awk '/<!-- release:start -->/{found=1; next} /<!-- release:end -->/{found=0} found{print}' CHANGELOG.md > /tmp/release-notes.md
-
-          LINES=$(wc -l < /tmp/release-notes.md | tr -d ' ')
-          if [ "$LINES" -lt 2 ]; then
-            echo "Error: No release notes found between <!-- release:start --> and <!-- release:end --> markers in CHANGELOG.md"
-            exit 1
-          fi
-          echo "Extracted release notes for $VERSION ($LINES lines)"
-
       - name: Create GitHub Release
         run: |
-          VERSION="${{ needs.check-release.outputs.version }}"
+          VERSION=$(node -p "require('./package.json').version")
           TAG="v$VERSION"
           
+          # Check if release already exists
           if gh release view "$TAG" &>/dev/null; then
-            echo "Release $TAG already exists, uploading assets..."
-            gh release upload "$TAG" bin/agent-browser-* dashboard.zip --clobber
+            echo "Release $TAG already exists, uploading binaries..."
+            gh release upload "$TAG" bin/agent-browser-* --clobber
           else
             echo "Creating release $TAG..."
             gh release create "$TAG" \
               --title "$TAG" \
-              --notes-file /tmp/release-notes.md \
-              bin/agent-browser-* dashboard.zip
+              --generate-notes \
+              bin/agent-browser-*
           fi
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -6,7 +6,6 @@ dist/
 
 # Native binaries (keep the launcher scripts)
 bin/agent-browser-*
-bin/.install-method
 !bin/agent-browser
 !bin/agent-browser.cmd
 
@@ -46,9 +45,6 @@ yarn.lock
 .env
 .env.local
 
-# Windows debug instance config
-scripts/windows-debug/.instance
-
 # opensrc - source code for packages
 opensrc/
 
@@ -60,7 +56,3 @@ docs/package-lock.json
 
 # pnpm
 .pnpm-store/
-
-# next
-.next/
-out/

.husky/pre-commit

@@ -1,2 +1,3 @@
+pnpm lint-staged
 node scripts/sync-version.js
 git add cli/Cargo.toml cli/Cargo.lock

.husky/pre-push

@@ -0,0 +1,8 @@
+if [ "${SKIP_CLAWHUB_SYNC:-0}" = "1" ]; then
+  echo "Skipping ClawHub sync (SKIP_CLAWHUB_SYNC=1)"
+  exit 0
+fi
+
+pnpm run clawhub:sync || {
+  echo "ClawHub sync failed. Push continues. Run 'pnpm run clawhub:sync' manually after fixing login/network."
+}

AGENTS.md

@@ -9,7 +9,6 @@ This project uses **pnpm**. Always use `pnpm` instead of `npm` or `yarn` for ins
 ## Code Style
 
 - Do not use emojis in code, output, or documentation. Unicode symbols (✓, ✗, →, ⚠) are acceptable.
-- In documentation and markdown, never use double hyphens (`--`) as a dash. Use an emdash (—) sparingly when needed. Prefer rewriting the sentence to avoid dashes entirely.
 - CLI colored output uses `cli/src/color.rs`. This module respects the `NO_COLOR` environment variable. Never use hardcoded ANSI color codes.
 - CLI flags must always use kebab-case (e.g., `--auto-connect`, `--allow-file-access`). Never use camelCase for flags (e.g., `--autoConnect` is wrong).
 
@@ -17,80 +16,35 @@ This project uses **pnpm**. Always use `pnpm` instead of `npm` or `yarn` for ins
 
 When adding or changing user-facing features (new flags, commands, behaviors, environment variables, etc.), update **all** of the following:
 
-1. `cli/src/output.rs` — `--help` output (flags list, examples, environment variables)
-2. `README.md` — Options table, relevant feature sections, examples
-3. `skills/agent-browser/SKILL.md` — so AI agents know about the feature
-4. `docs/src/app/` — the Next.js docs site (MDX pages)
+1. `cli/src/output.rs` -- `--help` output (flags list, examples, environment variables)
+2. `README.md` -- Options table, relevant feature sections, examples
+3. `skills/agent-browser/SKILL.md` -- so AI agents know about the feature
+4. `docs/src/app/` -- the Next.js docs site (MDX pages)
 5. Inline doc comments in the relevant source files
 
 This applies to changes that either human users or AI agents would need to know about. Do not skip any of these locations.
 
 In the `docs/src/app/` MDX files, always use HTML `<table>` syntax for tables (not markdown pipe tables). This matches the existing convention across the docs site.
 
-## Dashboard (packages/dashboard)
+## Dual Architecture (Node.js + Native)
 
-- Never use native browser dialogs (`alert`, `confirm`, `prompt`). Use shadcn/ui components (`Dialog`, `AlertDialog`, etc.) instead.
-- Use param-case (kebab-case) for all file and folder names (e.g., `session-tree.tsx`, not `SessionTree.tsx`). The `ui/` directory follows shadcn conventions which already uses param-case.
+The codebase has two daemon implementations:
 
-## Releasing
+- **Node.js/Playwright** (default) -- `src/daemon.ts`, `src/actions.ts`, `src/browser.ts`, and the rest of `src/`
+- **Rust/Native** (experimental, `--native` or `AGENT_BROWSER_NATIVE=1`) -- `cli/src/native/daemon.rs`, `cli/src/native/actions.rs`, `cli/src/native/browser.rs`, and the rest of `cli/src/native/`
 
-Releases are manual, single-PR affairs. There is no changesets automation. The maintainer controls the changelog voice and format.
+When modifying browser automation logic (commands, actions, protocol handling), changes **must** be made in **both** paths:
 
-To prepare a release:
+| Node.js Path | Native Path |
+|---|---|
+| `src/actions.ts` | `cli/src/native/actions.rs` |
+| `src/browser.ts` | `cli/src/native/browser.rs` |
+| `src/daemon.ts` | `cli/src/native/daemon.rs` |
+| `src/protocol.ts` | `cli/src/native/cdp/client.rs` |
+| `src/snapshot.ts` | `cli/src/native/snapshot.rs` |
+| `src/state-utils.ts` | `cli/src/native/state.rs` |
 
-1. Create a branch (e.g. `prepare-v0.24.0`)
-2. Bump `version` in `package.json`
-3. Run `pnpm version:sync` to update `cli/Cargo.toml`, `cli/Cargo.lock`, and `packages/dashboard/package.json`
-4. Write the changelog entry in `CHANGELOG.md` at the top, under a new `## <version>` heading, wrapped in `<!-- release:start -->` and `<!-- release:end -->` markers
-5. Add a matching entry to `docs/src/app/changelog/page.mdx` at the top (below the `# Changelog` heading)
-6. Open a PR and merge to `main`
-
-When the PR merges, CI compares `package.json` version to what's on npm. If it differs, it builds all 7 platform binaries, publishes to npm, and creates the GitHub release automatically. The GitHub release body is extracted from the content between the `<!-- release:start -->` and `<!-- release:end -->` markers in `CHANGELOG.md`.
-
-### Writing the changelog
-
-Review the git log since the last release and write the entry in `CHANGELOG.md`. Follow the existing format and voice. Group changes under `### New Features`, `### Bug Fixes`, `### Improvements`, etc. Bold the feature/fix name, then describe it concisely. Reference PR numbers in parentheses.
-
-Wrap the release notes (everything between the `## <version>` heading and the previous version) in markers so CI can extract them for the GitHub release:
-
-```markdown
-## 0.24.0
-
-<!-- release:start -->
-### New Features
-
-- **Foo command** - Added `foo` command for bar (#1234)
-
-### Bug Fixes
-
-- Fixed **baz** not working when qux is enabled (#1235)
-
-### Contributors
-
-- @ctate
-- @somecontributor
-<!-- release:end -->
-
-## 0.23.3
-```
-
-Include a `### Contributors` section listing the GitHub usernames (with `@` prefix) of everyone who contributed to the release. Check the git log between the previous tag and HEAD to find them.
-
-Do not prefix entries with commit hashes. Do not use the changesets `### Patch Changes` / `### Minor Changes` headings. Use descriptive section names instead.
-
-### Docs changelog
-
-The docs changelog at `docs/src/app/changelog/page.mdx` mirrors `CHANGELOG.md` but uses a slightly different format. Each entry uses:
-
-- A `v` prefix on the version (e.g. `## v0.24.0`)
-- A date line with the full date: `<p className="text-[#888] text-sm">March 30, 2026</p>`
-- A `---` separator between entries
-
-Match the existing style in that file.
-
-## Architecture
-
-This is a Rust codebase. The browser automation daemon lives in `cli/src/native/` (daemon, actions, browser, CDP client, snapshot, state). The `--engine` flag selects Chrome vs Lightpanda. The `install` command downloads Chrome from Chrome for Testing directly.
+New commands must be implemented in both paths, or explicitly stubbed in the native path with a clear `"Not yet implemented: {action}"` error. The goal is eventual full migration to native, but until then both paths must stay in sync.
 
 ## Testing
 
@@ -123,68 +77,6 @@ cd cli && cargo fmt -- --check   # Check formatting
 cd cli && cargo clippy            # Lint
 ```
 
-## Windows Debugging
-
-A remote Windows Server 2022 EC2 instance is available for debugging Windows-specific issues. It uses AWS Systems Manager (SSM) with no SSH or open ports. Commands run via `aws ssm send-command` and return stdout/stderr.
-
-### Prerequisites
-
-The instance must be provisioned first (one-time, by a human):
-
-```bash
-./scripts/windows-debug/provision.sh
-```
-
-Requires: AWS CLI v2 configured with `ec2:*`, `iam:CreateRole`, `iam:AttachRolePolicy`, `ssm:SendCommand`, `ssm:GetCommandInvocation` permissions and a default VPC.
-
-### Usage
-
-Start the instance (if stopped):
-
-```bash
-./scripts/windows-debug/start.sh
-```
-
-Run a command on Windows:
-
-```bash
-./scripts/windows-debug/run.sh "<powershell-command>"
-```
-
-Sync the current git branch and rebuild:
-
-```bash
-./scripts/windows-debug/sync.sh
-```
-
-Stop the instance when done (avoids cost):
-
-```bash
-./scripts/windows-debug/stop.sh
-```
-
-### Common Workflows
-
-Run unit tests on Windows:
-
-```bash
-./scripts/windows-debug/run.sh "cd C:\agent-browser && cargo test --manifest-path cli\Cargo.toml"
-```
-
-Run e2e tests on Windows:
-
-```bash
-./scripts/windows-debug/run.sh "cd C:\agent-browser && cargo test e2e --manifest-path cli\Cargo.toml -- --ignored --test-threads=1"
-```
-
-Check bootstrap progress (first boot only):
-
-```bash
-./scripts/windows-debug/run.sh "Get-Content C:\bootstrap.log"
-```
-
-The repo lives at `C:\agent-browser` on the instance. Rust, Git, and Chrome are pre-installed. The `run.sh` wrapper automatically adds cargo and git to PATH.
-
 <!-- opensrc:start -->
 
 ## Source Code Reference

CHANGELOG.md

@@ -1,525 +1,17 @@
 # agent-browser
 
-## 0.24.0
-
-<!-- release:start -->
-### New Features
-
-- **AWS Bedrock AgentCore provider** - Added AWS Bedrock AgentCore as a cloud browser provider. Connect with `--provider agentcore` or `AGENT_BROWSER_PROVIDER=agentcore`. Uses lightweight manual SigV4 signing for authentication with support for the full AWS credential provider chain (environment variables, AWS CLI, SSO, IAM roles). Configure with `AGENTCORE_REGION`, `AGENTCORE_PROFILE_ID`, and `AGENTCORE_BROWSER_ID` environment variables. Returns session ID and Live View URL in the launch response (#397)
-
-### Documentation
-
-- Added AgentCore provider page to docs site, README options table, SKILL.md, and dashboard provider icons (#1120)
-
-### Contributors
-
-- @ctate
-- @pahud
-<!-- release:end -->
-
-## 0.23.4
-
-### Bug Fixes
-
-- Fixed **daemon hang on Linux** caused by a `waitpid(-1)` race condition in the SIGCHLD handler that stole exit statuses from Rust's `Child` handles, leaving the daemon in a broken state. Replaced the global signal handler with targeted crash detection via the existing drain interval (#1098)
-
-## 0.23.3
-
-### Bug Fixes
-
-- Fixed **drag and drop** not working because `mouseMoved` events during the drag omitted the `buttons` bitmask, causing the browser to see `event.buttons === 0` and never fire `dragstart`/`dragover`/`drop` (#1087)
-
-## 0.23.2
+## 0.15.2-fork.0
 
 ### Patch Changes
 
-- 3c942e2: ### New Features
+- Merge upstream `v0.15.2` updates, including fixes for cookies clear/tab close output, daemon EPERM liveness checks, unnamed element reference matching, and docs/skills refresh.
 
-  - **Dashboard session creation** - Sessions can now be created directly from the dashboard UI. A new session dialog provides a unified selector grid for local engines (Chrome, Lightpanda) and cloud providers (Browserbase, Browserless, Browser Use, Kernel) with async creation, loading state, and error display (#1092)
-  - **Dashboard provider icons** - The session sidebar now shows the provider or engine icon for each session, making it easy to identify which backend a session is using (#1092)
-
-  ### Bug Fixes
-
-  - Fixed **Browser Use** provider using an intermediate API call instead of connecting directly via WSS (`wss://connect.browser-use.com`), which caused connection failures (#1092)
-  - Fixed **Browserbase** provider not sending an explicit JSON body and `Content-Type` header, causing session creation to fail (#1092)
-  - Fixed **provider navigation** hanging because `wait_for_lifecycle` waited for page load events that remote providers may not emit. Navigation with `--provider` now automatically sets `waitUntil=none` (#1092)
-  - Fixed **remote CDP connections** timing out by increasing the CDP connect timeout from 10s to 25s for cloud providers (#1092)
-  - Fixed **zombie daemon processes** not being cleaned up when a provider connection fails during session creation from the dashboard (#1092)
-
-## 0.23.1
+## 0.15.1-fork.11
 
 ### Patch Changes
 
-- fbcab37: ### New Features
-
-  - **Auto-dismissal for alert and beforeunload dialogs** - JavaScript `alert()` and `beforeunload` dialogs are now automatically accepted to prevent the agent from blocking indefinitely. `confirm` and `prompt` dialogs still require explicit `dialog accept/dismiss` commands. Disable with `--no-auto-dialog` flag or `AGENT_BROWSER_NO_AUTO_DIALOG` environment variable (#1075)
-  - **Puppeteer browser cache fallback** - Chrome discovery now searches `~/.cache/puppeteer/chrome/` (or `PUPPETEER_CACHE_DIR`) for Chrome binaries, so users with an existing Puppeteer installation can use agent-browser without a separate install step (#1088)
-  - **Console output improvements** - `console.log` of objects now shows the actual object preview (e.g. `{userId: "abc", count: 42}`) instead of `"Object"`. JSON output includes a raw `args` array for programmatic access (#1040)
-
-  ### Bug Fixes
-
-  - Fixed **same-document navigation** (e.g. SPA hash routing) hanging forever because `wait_for_lifecycle` waited for a `Page.loadEventFired` that never fires on same-document navigations (#1059)
-  - Fixed **save_state** only capturing cookies and localStorage for the current origin, silently dropping cross-domain data (e.g. SSO/CAS auth cookies). Now uses `Network.getAllCookies` and collects localStorage from all visited origins (#1064)
-  - Fixed **externally opened tabs** not appearing in `tab list` when using `--cdp` mode. Tabs opened by the user or another CDP client are now detected and tracked (#1042)
-  - Fixed **dashboard server** not picking up installed files without a restart. `dashboard install` now takes effect immediately on a running server (#1066)
-  - Fixed **Windows Chrome extraction** failing because zip path normalization used forward slashes while the extraction code expected backslashes (#1088)
-
-## 0.23.0
-
-### Minor Changes
-
-- 0f0f300: ### New Features
-
-  - **Observability dashboard** - Added a local web UI (`dashboard`) that shows live browser viewports, command activity feeds, console output, network requests, storage, and extensions for all sessions. Manage it with `dashboard start`, `dashboard stop`, and `dashboard install`. The dashboard runs as a standalone background process and all sessions stream to it automatically (#1034)
-  - **Runtime stream management** - Added `stream enable`, `stream disable`, and `stream status` commands to control WebSocket streaming at runtime. Streaming is now always enabled by default; `AGENT_BROWSER_STREAM_PORT` overrides the port instead of toggling the feature (#951)
-  - **Close all sessions** - Added `close --all` flag to close every active browser session at once
-
-  ### Bug Fixes
-
-  - Fixed **Lightpanda engine** compatibility (#1050)
-  - Fixed **Windows daemon TCP bind** failing when Hyper-V reserves the port by falling back to an OS-assigned port and writing it to a `.port` file (#1041)
-  - Fixed **Windows dashboard relay** using Unix socket instead of TCP (#1038)
-  - Fixed **radio/checkbox elements** being dropped from compact snapshot tree because the `ref=` check required a leading `[` that those elements lack (#1008)
-
-## 0.22.3
-
-### Patch Changes
-
-- eb64ca4: ### Bug Fixes
-
-  - **Re-apply download behavior on recording context** - Fixed an issue where downloads were silently dropped in recording contexts because `Browser.setDownloadBehavior` set at launch only applied to the default context. The download behavior is now re-applied when a new recording context is created (#1019)
-  - **Reap zombie Chrome process and fast-detect crash for auto-restart** - Added a non-blocking process-exit check before attempting CDP connection checks. This prevents a 3-second CDP timeout when Chrome has already crashed or exited, enabling faster detection and auto-restart of the browser (#1023)
-  - **Route keyboard `type` through text input** - Fixed keyboard `type` subaction to correctly route through the text input handler, and added support for an `insertText` subaction using `Input.insertText` (#1014)
-  - **Handle `--clear` flag in `console` command** - Fixed the `console` command to accept and process a `clear` parameter, allowing console event history to be cleared (#1015)
-
-## 0.22.2
-
-### Patch Changes
-
-- a098197: ### New Features
-
-  - **Dialog status command** - Added `dialog status` command to check whether a JavaScript dialog is currently open (#999)
-  - **Dialog warning field** - Command responses now include a `warning` field when a JavaScript dialog is pending, indicating the dialog type and message (#999)
-
-  ### Improvements
-
-  - **Standard proxy environment variables** - The proxy setting now automatically falls back to standard environment variables (`HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY`, and their lowercase variants), with `NO_PROXY`/`no_proxy` respected for bypass rules (#1000)
-  - **Font packages for `--with-deps`** - Installing with `--with-deps` now includes CJK and emoji font packages on Linux (Debian, RPM, and yum-based distros) to prevent missing glyphs when rendering international content (#1002)
-
-  ### Bug Fixes
-
-  - Fixed `state show` always failing with "Missing 'path' parameter" due to a mismatched JSON field name (`filename` → `path`) (#994)
-  - Fixed `console` command returning only `Done` due to a JSON field name mismatch in the response (#986)
-  - Fixed browser-domain CDP events being dropped during downloads due to a `sessionId` mismatch (#998)
-  - Fixed proxy authentication by handling credentials via the CDP `Fetch.authRequired` event rather than passing them inline (#1000)
-
-## 0.22.1
-
-### Patch Changes
-
-- 3a3317b: ### Bug Fixes
-
-  - Fixed **modifier key chords** (e.g. `Control+a`, `Shift+Enter`, `Control+Shift+a`) not being handled correctly when using `press`. Modifier keys (`Alt`, `Control`/`Ctrl`, `Meta`/`Cmd`, `Shift`) are now parsed and forwarded as CDP modifier bitmasks rather than treated as part of the key name (#980)
-  - Fixed **query parameters being dropped** from `--cdp` HTTP URLs (e.g. `http://host:9222?mode=Hello`). Query strings are now preserved and forwarded to the remote CDP endpoint (#982)
-
-## 0.22.0
-
-### Minor Changes
-
-- be30bc9: ### New Features
-
-  - **Cross-origin iframe support** - Added support for snapshots and interactions within cross-origin iframes via `Target.setAutoAttach` (#949)
-  - **Network request detail and filtering** - Added `network request <requestId>` command to view full request/response detail, and new filtering options for `network requests` including `--type` (e.g. `xhr,fetch`), `--method` (e.g. `POST`), and `--status` (e.g. `2xx`, `400-499`) (#935)
-
-  ### Improvements
-
-  - **Snapshot usability** - Reduced AI cognitive load by filtering semantic noise from snapshot output; cursor-interactive elements are now included by default, making the `-C` flag unnecessary (#968)
-  - **Upgrade command** - Improved robustness of installation method detection in the upgrade command (#960)
-  - **Target tracking** - Enhanced target tracking and page information handling for more reliable browser session management (#969)
-
-  ### Bug Fixes
-
-  - Fixed **viewport dimensions** being reported incorrectly in streaming status messages and screencast (#952)
-  - Fixed **`find` command** flags such as `--exact` and `--name` leaking into fill values when used with fill actions (#955)
-  - Fixed **state commands** incorrectly starting the daemon when no `session_name` is provided (#677, #964)
-  - Fixed **auto-connect** triggering when the daemon is already running, preventing duplicate connections (#971)
-  - Fixed **Enter key press** not working by adding a text field to `keyDown` events (#972)
-  - Fixed **download command** to properly handle absolute paths and correctly click target elements (#970)
-
-  ### Breaking Changes
-
-  - The `-C` / `--cursor` flag for `snapshot` is deprecated; cursor-interactive elements are now included by default and the flag has no additional effect (#968)
-
-  ### Documentation
-
-  - Updated `README.md` with new `network requests` filtering options and `network request <requestId>` command usage
-  - Removed references to the deprecated `-C` / `--cursor` snapshot flag from docs and command reference
-
-## 0.21.4
-
-### Patch Changes
-
-- aed466b: ### Bug Fixes
-
-  - **Auth login readiness** - `agent-browser auth login` now navigates with `load`, waits for usable login form selectors, and uses staged username detection (targeted email/username selectors first, then broad text-input fallback). This reduces SPA timing failures, avoids false matches on unrelated text fields, and prevents `networkidle` hangs on pages with continuous background requests.
-
-## 0.21.3
-
-### Patch Changes
-
-- 6daad22: ### Bug Fixes
-
-  - **WebSocket keepalive for remote browsers** - Added WebSocket Ping frames and TCP `SO_KEEPALIVE` to prevent CDP connections from being silently dropped by intermediate proxies (reverse proxies, load balancers, service meshes) during idle periods (#936)
-  - **XPath selector support** - Fixed element resolution to correctly handle the `xpath=` selector prefix (#908)
-
-  ### Performance
-
-  - **Fast-path for identical snapshots** - Short-circuits the Myers diff algorithm when comparing a snapshot to itself, avoiding unnecessary computation in retry and loop workloads where repeated identical snapshots are common (#922)
-
-  ### Documentation
-
-  - Migrated page metadata from MDX files to `layout.tsx` (#904)
-  - Added search functionality and color improvements to docs (#927)
-  - Fixed desktop browser list in the iOS comparison table (#926)
-  - Created a new `providers/` section with dedicated provider pages (#928)
-
-## 0.21.2
-
-### Patch Changes
-
-- 757626f: ### Bug Fixes
-
-  - **Deduplicate text content in snapshots** - Fixed an issue where duplicate text content appeared in page snapshots (#909)
-  - **Native mouse drag state** - Fixed incorrect raw native mouse drag state not being properly tracked across `down`, `move`, and `up` events (#872)
-  - **Chrome headless launch failures** - Fixed browser launch failures caused by the `--enable-unsafe-swiftshader` flag in Chrome headless mode (#915)
-  - **Origin-scoped `--headers` persistence** - Restored correct persistence of origin-scoped headers set via `--headers` across navigation commands (#894)
-  - **Relative URLs in WebSocket domain filter** - Fixed handling of relative URLs in the WebSocket domain filter script (#624)
-
-## 0.21.1
-
-### Patch Changes
-
-- 1e7619d: ### New Features
-
-  - **HAR 1.2 network capture** - Added commands to capture and export network traffic in HAR 1.2 format, including accurate request/response timing, headers, body sizes, and resource types sourced from Chrome DevTools Protocol events (#864)
-  - **Built-in `upgrade` command** - Added `agent-browser upgrade` to self-update the CLI; automatically detects your installation method (npm, Homebrew, or Cargo) and runs the appropriate update command (#898)
-
-  ### Documentation
-
-  - Added `upgrade` command to the README command reference and installation guide
-  - Added a dedicated **Updating** section to the README with usage instructions for `agent-browser upgrade`
-
-## 0.21.0
-
-### Minor Changes
-
-- c6de80b: ### New Features
-
-  - **`batch` command** -- Execute multiple commands from stdin in a single invocation. Accepts a JSON array of string arrays and returns results sequentially. Supports `--bail` to stop on first error and `--json` for structured output (#865)
-  - **iframe support** -- CLI interactions and snapshots now traverse into iframe content, enabling automation of cross-frame pages (#869)
-  - **`network har start/stop` command** -- Capture and export network traffic in HAR 1.2 format (#874)
-  - **WebSocket fallback for CDP discovery** -- When HTTP-based CDP endpoint discovery fails, the CLI now falls back to a WebSocket connection automatically (#873)
-
-  ### Improvements
-
-  - **`--full`/`-f` refactored to command-level flag** -- Moved from a global flag to a per-command flag for clearer scoping (#877)
-  - **Enhanced Chrome launch** -- Added `--user-data-dir` support and configurable launch timeout for more reliable browser startup (#852)
-
-  ### Bug Fixes
-
-  - Fixed `/json/list` fallback when `/json/version` endpoint is unavailable, improving compatibility with non-standard CDP implementations (#861)
-  - Fixed daemon liveness detection for PID namespace isolation (e.g. `unshare`). Uses socket connectivity as the sole liveness check instead of `kill(pid, 0)`, which fails when the caller cannot see the daemon's PID (#879)
-  - Fixed Ubuntu dependency install accidentally removing system packages (#884)
-
-## 0.20.14
-
-### Patch Changes
-
-- c0d4cf6: ### New Features
-
-  - **Idle timeout for daemon auto-shutdown** - Added `--idle-timeout` CLI flag (and `AGENT_BROWSER_IDLE_TIMEOUT_MS` environment variable) to automatically shut down the daemon after a period of inactivity. Accepts human-friendly formats such as `10s`, `3m`, `1h`, or raw milliseconds (#856)
-  - **Cursor-interactive elements in snapshot tree** - Cursor-interactive elements are now embedded directly into the snapshot tree for richer context (#855)
-
-  ### Bug Fixes
-
-  - Fixed **remote host support** in CDP discovery, enabling connection to browsers running on non-local hosts (#854)
-  - Fixed **CDP flag propagation** to the daemon process, ensuring reliable CDP reconnection across sessions (#857)
-  - Fixed **Windows auto-connect profiling** to correctly handle browser connection on Windows (#835, #840)
-  - Fixed **Windows transient error detection** by recognising Windows-specific socket error codes (`os error 10061` connection refused, `os error 10054` connection reset) during daemon reconnection attempts
-
-## 0.20.13
-
-### Patch Changes
-
-- eda956b: ### Bug Fixes
-
-  - **Network idle detection for cached pages** - Fixed an issue where `poll_network_idle` could return immediately when no network events were observed (e.g. pages served from cache). The idle timer is now only satisfied after a consistent **500 ms idle period** has elapsed, preventing false-positive idle detection. The core polling logic has also been extracted into a standalone `poll_network_idle` function to improve testability (#847)
-
-## 0.20.12
-
-### Patch Changes
-
-- 5fa2396: ### Bug Fixes
-
-  - Fixed **`snapshot -C`** and **`screenshot --annotate`** hanging when connected over WSS (WebSocket Secure) due to sequential CDP round-trips per interactive element (#842)
-
-  ### Performance
-
-  - **`snapshot -C` (cursor-interactive mode)** now batches CDP calls instead of issuing N×2 sequential round-trips per cursor-interactive element, preventing timeouts on high-latency WSS connections (#842)
-  - **`screenshot --annotate`** now batches element queries, reducing completion time from potentially 20–40s (e.g. 50+ buttons over WSS) to within expected bounds (#842)
-
-## 0.20.11
-
-### Patch Changes
-
-- 4b5fc78: ### Bug Fixes
-
-  - **Material Design checkbox/radio parity** - Restored Playwright-parity behavior for `check`/`uncheck` actions on Material Design controls. These components hide the native `<input>` off-screen and use overlay elements that intercept coordinate-based clicks; the actions now detect this pattern and fall back to a JS `.click()` to correctly toggle state. Also improves `ischecked` to handle nested hidden inputs and ARIA-only checkboxes (#837)
-  - **Punctuation handling in `type` command** - Fixed incorrect virtual key (VK) codes being used for punctuation characters (e.g. `.`, `@`) in the `type` action, which previously caused those characters to be dropped or mistyped (#836)
-
-## 0.20.10
-
-### Patch Changes
-
-- a3d9662: ### Bug Fixes
-
-  - **Restored WebSocket streaming** - Fixed broken WebSocket streaming in the native daemon by keeping the **StreamServer** instance alive so the broadcast channel remains open, and ensuring CDP session IDs and connection status are correctly propagated to stream clients (#826)
-  - **Filtered internal Chrome targets** - Fixed auto-connect discovery incorrectly attempting to attach to Chrome-internal pages (e.g. `chrome://`, `chrome-extension://`, `devtools://` URLs), which could cause unexpected connection failures (#827)
-
-## 0.20.9
-
-### Patch Changes
-
-- 51d9ab4: ### Bug Fixes
-
-  - **Appium v3 iOS capabilities** - Added `appium:` vendor prefix to iOS capabilities (e.g., `appium:automationName`, `appium:deviceName`, `appium:platformVersion`) to comply with the Appium v3 WebDriver protocol requirements (#810)
-  - **Snapshot `--selector` scoping** - Fixed `snapshot --selector` so that the output is properly scoped to the matched element's subtree rather than returning the full accessibility tree. The selector now resolves the target DOM node's backend IDs and filters the accessibility tree to only include nodes within that subtree (#825)
-
-## 0.20.8
-
-### Patch Changes
-
-- daf7263: ### Bug Fixes
-
-  - Fixed **video duration** being reported incorrectly when using real-time ffmpeg encoding for screen recording (#812)
-  - Removed obsolete **`BrowserManager` TypeScript API** references that no longer reflect the current CLI-based usage model (#821)
-
-  ### Documentation
-
-  - Updated README to replace outdated **`BrowserManager` programmatic API** examples with the current CLI-based approach using `execSync` and `agent-browser` commands (#821)
-  - Removed the **Programmatic API** section covering `BrowserManager` screencast and input injection methods, which are no longer part of the public API (#821)
-
-## 0.20.7
-
-### Patch Changes
-
-- 25a1526: ### New Features
-
-  - **Brave Browser support** - Added auto-discovery of Brave Browser for CDP connections on macOS, Linux, and Windows. The agent will now automatically detect and connect to Brave alongside Chrome, Chromium, and Canary installations (#817)
-
-  ### Improvements
-
-  - **Postinstall message** - The post-install message now detects existing Chrome installations on the system. If a compatible browser is found, it confirms the path and notes it will be used automatically instead of prompting an install. If no browser is detected, the warning is clearer and mentions that installation can be skipped when using `--cdp`, `--provider`, `--engine`, or `--executable-path` (#815)
-
-## 0.20.6
-
-### Patch Changes
-
-- fa91c22: ### Bug Fixes
-
-  - **Stale accessibility tree reference fallback** - Fixed an issue where interacting with an element whose **`backend_node_id`** had become stale (e.g. after the DOM was replaced) would fail with a `Could not compute box model` CDP error. Element resolution now re-queries the accessibility tree using role/name lookup to obtain a fresh node ID before retrying the operation (#806)
-
-## 0.20.5
-
-### Patch Changes
-
-- fc091d2: ### Bug Fixes
-
-  - **Daemon panic on broken stderr pipe** - Replaced all `eprintln!` calls with `writeln!(std::io::stderr(), ...)` wrapped in `let _ =` to silently discard write errors, preventing the daemon from panicking when the parent process drops the stderr pipe during Chrome launch (#802)
-
-## 0.20.4
-
-### Patch Changes
-
-- e2ebde2: ### Bug Fixes
-
-  - **Broadcast channel lag handling** - Fixed an issue where **broadcast channel lag** errors were incorrectly treated as stream closure, causing premature termination of event listeners in reload, response body, download, and navigation wait operations. Lagged messages are now skipped and the loop continues instead of breaking (#797)
-
-  ### Improvements
-
-  - Removed unused **pnpm setup** steps from the `global-install` CI job, simplifying the workflow configuration (#798)
-
-## 0.20.3
-
-### Patch Changes
-
-- e365909: ### Bug Fixes
-
-  - **Chrome launch retry** - Chrome will now retry launching up to 3 times with a 500ms delay between attempts, improving resilience against transient startup failures (#791)
-  - **Remote CDP snapshot hang** - Resolved an issue where snapshots would hang indefinitely over remote CDP (WSS) connections by removing WebSocket message and frame size limits to accommodate large responses (e.g. `Accessibility.getFullAXTree`), accepting binary frames from remote proxies such as Browserless, and immediately clearing pending commands when the connection closes rather than waiting for the 30-second timeout (#792)
-
-## 0.20.2
-
-### Patch Changes
-
-- 944fa01: ### New Features
-
-  - **Linux musl (Alpine) builds** - Added pre-built binaries for **linux-musl** targeting both **x64** and **arm64** architectures, enabling native support for Alpine Linux and other musl-based distributions without requiring glibc (#784)
-
-  ### Improvements
-
-  - **Consecutive `--auto-connect` commands** - Added support for issuing multiple consecutive `--auto-connect` commands without requiring a full browser relaunch; external connections are now correctly identified and reused (#786)
-  - **External browser disconnect behavior** - When using `--auto-connect` or `--cdp`, closing the agent session now disconnects cleanly without shutting down the user's browser process
-
-  ### Bug Fixes
-
-  - **Restored `refs` dict in `--json` snapshot output** - The `refs` map containing role and name metadata for referenced elements is now correctly included in JSON snapshot responses (#787)
-  - Fixed e2e test assertions for `diff_snapshot` and `domain_filter` to correctly reflect expected behavior (#783)
-  - Fixed Chrome temp-dir cleanup test failing on Windows (#766)
-
-## 0.20.1
-
-### Patch Changes
-
-- bd05917: ### Bug Fixes
-
-  - Fixed **AX tree deserialization** to accept integer `nodeId` and `childIds` values for compatibility with Lightpanda, which sends numeric IDs where Chrome sends strings (#775)
-  - Fixed **misleading SIGPIPE comment** to accurately describe the default Rust SIGPIPE behavior and why it is reset to `SIG_DFL` (#776)
-  - Fixed **WebM recording output** to use the VP9 codec (`libvpx-vp9`) instead of H.264, producing valid WebM files; also adds a padding filter to ensure even frame dimensions (#779)
-
-## 0.20.0
-
-### Minor Changes
-
-- 235fa88: ### Full Native Rust
-
-  - **100% native Rust** -- Removed the entire Node.js/Playwright daemon. The Rust native daemon is now the only implementation. No Node.js runtime or Playwright dependency required. (#754)
-  - **99x smaller install** -- Install size reduced from 710 MB to 7 MB by eliminating the Node.js dependency tree.
-  - **18x less memory** -- Daemon memory usage reduced from 143 MB to 8 MB.
-  - **1.6x faster cold start** -- Cold start time reduced from 1002ms to 617ms.
-  - **Benchmarks** -- Added benchmark suite comparing native vs Node.js daemon performance.
-  - **Chromium installer hardened** -- Fixed zip path traversal vulnerability in Chrome for Testing installer.
-
-  ### Bug Fixes
-
-  - Fixed `--headed false` flag not being respected in CLI (#757)
-  - Fixed "not found" error pattern in `to_ai_friendly_error` incorrectly catching non-element errors (#759)
-  - Fixed storage local key lookup parsing and text output (#761)
-  - Fixed Lightpanda engine launch with release binaries (#760)
-  - Hardened Lightpanda startup timeouts (#762)
-
-## 0.19.0
-
-### Minor Changes
-
-- 56bb92b: ### New Features
-
-  - **Browserless.io provider** -- Added browserless.io as a browser provider, supported in both Node.js and native daemon paths. Connect to remote Browserless instances with `--provider browserless` or `AGENT_BROWSER_PROVIDER=browserless`. Configurable via `BROWSERLESS_API_KEY`, `BROWSERLESS_API_URL`, and `BROWSERLESS_BROWSER_TYPE` environment variables. (#502, #746)
-  - **`clipboard` command** -- Read from and write to the browser clipboard. Supports `read`, `write <text>`, `copy` (simulates Ctrl+C), and `paste` (simulates Ctrl+V) operations. (#749)
-  - **Screenshot output configuration** -- New global flags `--screenshot-dir`, `--screenshot-quality`, `--screenshot-format` and corresponding `AGENT_BROWSER_SCREENSHOT_DIR`, `AGENT_BROWSER_SCREENSHOT_QUALITY`, `AGENT_BROWSER_SCREENSHOT_FORMAT` environment variables for persistent screenshot settings. (#749)
-
-  ### Bug Fixes
-
-  - Fixed `wait --text` not working in native daemon path (#749)
-  - Fixed `BrowserManager.navigate()` and package entry point (#748)
-  - Fixed extensions not being loaded from `config.json` (#750)
-  - Fixed scroll on page load (#747)
-  - Fixed HTML retrieval by using `browser.getLocator()` for selector operations (#745)
-
-## 0.18.0
-
-### Minor Changes
-
-- 942b8cd: ### New Features
-
-  - **`inspect` command** - Opens Chrome DevTools for the active page by launching a local proxy server that forwards the DevTools frontend to the browser's CDP WebSocket. Commands continue to work while DevTools is open. Implemented in both Node.js and native paths. (#736)
-  - **`get cdp-url` subcommand** - Retrieve the Chrome DevTools Protocol WebSocket URL for the active page, useful for external debugging tools. (#736)
-  - **Native screenshot annotate** - The `--annotate` flag for screenshots now works in the native Rust daemon, bringing parity with the Node.js path. (#706)
-
-  ### Improvements
-
-  - **KERNEL_API_KEY now optional** - External credential injection no longer requires `KERNEL_API_KEY` to be set, making it easier to use Kernel with pre-configured environments. (#687)
-  - **Browserbase simplified** - Removed the `BROWSERBASE_PROJECT_ID` requirement, reducing setup friction for Browserbase users. (#625)
-
-  ### Bug Fixes
-
-  - Fixed Browserbase API using incorrect endpoint to release sessions (#707)
-  - Fixed CDP connect paths using hardcoded 10s timeout instead of `getDefaultTimeout()` (#704)
-  - Fixed lone Unicode surrogates causing errors by sanitizing with `toWellFormed()` (#720)
-  - Fixed CDP connection failure on IPv6-first systems (#717)
-  - Fixed recordings not inheriting the current viewport settings (#718)
-
-## 0.17.1
-
-### Patch Changes
-
-- 94cd888: Added support for device scale factor (retina display) in the viewport command via an optional scale parameter. Also added webview target type support for better Electron application compatibility, and the pages list now includes target type information.
-
-## 0.17.0
-
-### Minor Changes
-
-- 94521e7: ### New Features
-
-  - **Lightpanda browser engine support** - Added `--engine <name>` flag to select the browser engine (`chrome` by default, or `lightpanda`), implying `--native` mode. Configurable via `AGENT_BROWSER_ENGINE` environment variable (#646)
-  - **Dialog dismiss command** - Added support for `dismiss` subcommand in dialog command parsing (#605)
-
-  ### Improvements
-
-  - **Daemon startup error reporting** - Daemon startup errors are now surfaced directly instead of showing an opaque timeout message (#614)
-  - **CDP port discovery** - Replaced broken hand-rolled HTTP client with `reqwest` for more reliable CDP port discovery (#619)
-  - **Chrome extensions** - Extensions now load correctly by forcing headed mode when extensions are present (#652)
-  - **Google Translate bar suppression** - Suppressed the Google Translate bar in native headless mode to avoid interference (#649)
-  - **Auth cookie persistence** - Auth cookies are now persisted on browser close in native mode (#650)
-
-  ### Bug Fixes
-
-  - Fixed native auth login failing due to incompatible encryption format (#648)
-
-  ### Documentation
-
-  - Improved snapshot usage guidance and added reproducibility check (#630)
-  - Added `--engine` flag to the README options table
-
-  ### Performance
-
-  - Added benchmarks to the CLI codebase (#637)
-
-## 0.16.3
-
-### Patch Changes
-
-- 7d2c895: Fixed an issue where the --native flag was being passed to child processes even when not explicitly specified on the command line. The flag is now only forwarded when the user explicitly provides it, consistent with how other CLI flags like --allow-file-access and --download-path are handled.
-
-## 0.16.2
-
-### Patch Changes
-
-- 01ac557: Added AGENT_BROWSER_HEADED environment variable support for running the browser in headed mode, and improved temporary profile cleanup when launching Chrome directly. Also includes documentation clarification that browser extensions work in both headed and headless modes.
-
-## 0.16.1
-
-### Patch Changes
-
-- c4180c8: Improved Chrome launch reliability by automatically detecting containerized environments (Docker, Podman, Kubernetes) and enabling --no-sandbox when needed. Added support for discovering Playwright-installed Chromium browsers and enhanced error messages with helpful diagnostics when Chrome fails to launch.
-
-## 0.16.0
-
-### Minor Changes
-
-- 05018b3: Added experimental native Rust daemon (`--native` flag, `AGENT_BROWSER_NATIVE=1` env, or `"native": true` in config). The native daemon communicates with Chrome directly via CDP, eliminating Node.js and Playwright dependencies. Supports 150+ commands with full parity to the default Node.js daemon. Includes WebDriver backend for Safari/iOS, CDP protocol codegen, request tracking, frame context management, and comprehensive e2e and parity tests.
-
-## 0.15.3
-
-### Patch Changes
-
-- 62241b5: Fixed Windows compatibility issues including proper handling of extended-length path prefixes from canonicalize(), prevention of MSYS/Git Bash path translation that could mangle arguments, and improved daemon startup reliability. Also added ARM64 Windows support in postinstall shims and expanded CI testing with a full daemon lifecycle test on Windows.
-
-## 0.15.2
-
-### Patch Changes
-
-- 6aea316: Documentation site improvements and internal tooling updates including enhanced code blocks, mobile navigation, and docs chat components. CLI connection and output handling refinements. Skill creator reference documentation and scripts have been reorganized.
+- Auto-attach existing browser more reliably by trying CDP localhost:9333 first, then falling back to auto-discovery before failing.
+  Align daemon behavior and user-facing docs/skill guidance with the same attachment policy.
 
 ## 0.15.1
 
@@ -529,11 +21,13 @@
 
 ## 0.15.0
 
-### Minor Changes
+### Patch Changes
 
-- 2e38882: - Added security hardening: authentication vault, content boundary markers, domain allowlist, action policy, action confirmation, and output length limits.
-  - Added `--download-path` flag (and `AGENT_BROWSER_DOWNLOAD_PATH` env / `downloadPath` config key) to set a default download directory.
-  - Added `--selector` flag to `scroll` command for scrolling within specific container elements.
+- Fix CLI typing delay parsing so `--delay` is treated as an option instead of typed text.
+  - Add `--delay <ms>` parsing for `type` and `keyboard type`
+  - Support `--` to type literal `--delay` text
+  - Add regression tests for parsing and delay behavior
+  - Update CLI help, README, skills, and docs command references
 
 ## 0.14.0
 
@@ -730,7 +224,6 @@
 ### Minor Changes
 
 - 316e649: ## New Features
-
   - **Cloud browser providers** - Connect to Browserbase or Browser Use for remote browser infrastructure via `-p` flag or `AGENT_BROWSER_PROVIDER` env var
   - **Persistent browser profiles** - Store cookies, localStorage, and login sessions across browser restarts with `--profile`
   - **Remote CDP WebSocket URLs** - Connect to remote browser services via WebSocket URL (e.g., `--cdp "wss://..."`)
@@ -739,7 +232,6 @@
   - **Enhanced skills** - Hierarchical structure with references and templates for Claude Code
 
   ## Bug Fixes
-
   - Screenshot command now supports refs and has improved error messages
   - WebSocket URLs work in `connect` command
   - Fixed socket file location (uses `~/.agent-browser` instead of TMPDIR)
@@ -747,7 +239,6 @@
   - State load and path-based actions now show correct output messages
 
   ## Documentation
-
   - Added Claude Code marketplace plugin installation instructions
   - Updated skill documentation with references and templates
   - Improved error documentation

benchmarks/.env.example

@@ -1,4 +0,0 @@
-# Vercel Sandbox credentials
-SANDBOX_VERCEL_TOKEN=
-SANDBOX_VERCEL_TEAM_ID=
-SANDBOX_VERCEL_PROJECT_ID=

benchmarks/.gitignore

@@ -1,2 +0,0 @@
-node_modules/
-results.json

benchmarks/README.md

@@ -1,76 +0,0 @@
-# agent-browser Daemon Benchmarks
-
-Compares command latency and system metrics between the **Node.js daemon** (published npm version) and the **Rust native daemon** (built from source), running inside a [Vercel Sandbox](https://vercel.com/docs/sandbox) microVM.
-
-## What it measures
-
-**Command latency** -- per-scenario timing with warmup, multiple iterations, and stddev:
-
-- `navigate` -- page load round-trip
-- `snapshot` -- accessibility tree generation
-- `screenshot` -- viewport capture
-- `evaluate` -- JavaScript execution
-- `click` -- element interaction
-- `fill` -- form input
-- `agent-loop` -- snapshot/click/snapshot cycle (typical AI agent pattern)
-- `full-workflow` -- realistic 7-command sequence
-
-**System metrics** -- collected while the daemon is running:
-
-- Cold start time (daemon spawn + browser launch)
-- Binary size and total distribution size (including browser download)
-- Daemon RSS and peak RSS (separated from browser process memory)
-- Browser RSS (Chrome processes, same for both daemons)
-- Daemon CPU time
-- Process counts
-
-## Prerequisites
-
-- Node.js 18+
-- pnpm
-- Vercel Sandbox credentials (token, team ID, project ID)
-
-## Setup
-
-```bash
-cd benchmarks
-pnpm install
-cp .env.example .env
-```
-
-Fill in your Vercel Sandbox credentials in `.env`:
-
-```
-SANDBOX_VERCEL_TOKEN=your_token
-SANDBOX_VERCEL_TEAM_ID=your_team_id
-SANDBOX_VERCEL_PROJECT_ID=your_project_id
-```
-
-## Usage
-
-```bash
-pnpm bench                             # 10 iterations, 1 warmup, 8 vCPUs
-pnpm bench -- --iterations 20          # more iterations for tighter stats
-pnpm bench -- --warmup 2               # extra warmup iterations
-pnpm bench -- --json                   # write results.json
-pnpm bench -- --branch main            # build native from a different branch
-pnpm bench -- --vcpus 16               # more vCPUs (faster Rust build)
-```
-
-## How it works
-
-1. Creates a Vercel Sandbox (Amazon Linux, configurable vCPUs)
-2. Installs Chromium system dependencies
-3. **Phase 1 -- Node.js daemon**: installs `agent-browser` from npm (last version with the Node daemon), runs all scenarios, collects metrics
-4. **Phase 2 -- Rust native daemon**: installs Rust toolchain, clones the repo, runs `cargo build --release`, replaces the binary, runs the same scenarios, collects metrics
-5. Prints comparison tables and optionally writes `results.json`
-
-## Interpreting results
-
-**Command latency** is dominated by Chrome (CDP round-trips), not the daemon. Both daemons are thin relays between the CLI and Chrome, so per-command speedups are typically small. The stddev column helps distinguish real differences from noise.
-
-**Where the native daemon wins** is in cold start (no Node.js runtime to boot), daemon memory (single Rust binary vs V8 heap), and distribution size (no Playwright dependency).
-
-The **daemon RSS** metric isolates the daemon process memory from Chrome. This is the apples-to-apples comparison -- both daemons talk to the same Chrome, but Node.js adds ~140 MB of V8 overhead while the Rust daemon uses ~7 MB.
-
-**Distribution size** includes the daemon plus its browser download. The Node version includes the npm package + Playwright's bundled Chromium. The Rust version is just the binary + Chrome for Testing.

benchmarks/bench.ts

@@ -1,900 +0,0 @@
-/**
- * Node.js Daemon vs Rust Native Daemon benchmark.
- *
- * Compares the last published npm version (Node.js daemon) against the
- * Rust-only build from a given branch, running real agent-browser commands
- * inside a Vercel Sandbox.
- *
- * Captures:
- *   - Command latency (per-scenario, with warmup + measured iterations + stddev)
- *   - Cold start time (first launch to daemon ready)
- *   - Daemon memory (RSS, peak RSS) separated from browser memory
- *   - Daemon CPU time
- *   - Process tree (daemon + browser children)
- *   - Binary and distribution size on disk
- *
- * Usage:
- *   pnpm bench                        # default: 10 iterations, 1 warmup
- *   pnpm bench -- --iterations 20     # override iterations
- *   pnpm bench -- --warmup 2          # override warmup count
- *   pnpm bench -- --json              # write results.json
- *   pnpm bench -- --branch my-branch  # override native branch (default: ctate/native-2)
- *   pnpm bench -- --vcpus 8           # sandbox vCPUs (default: 8, higher = faster Rust build)
- */
-
-import { Sandbox } from "@vercel/sandbox";
-import { readFileSync, writeFileSync } from "fs";
-import { scenarios, type Scenario } from "./scenarios.js";
-
-// ---------------------------------------------------------------------------
-// Env
-// ---------------------------------------------------------------------------
-
-function loadEnv() {
-  try {
-    const content = readFileSync(".env", "utf-8");
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eq = trimmed.indexOf("=");
-      if (eq === -1) continue;
-      const key = trimmed.slice(0, eq);
-      let val = trimmed.slice(eq + 1);
-      if (
-        (val.startsWith('"') && val.endsWith('"')) ||
-        (val.startsWith("'") && val.endsWith("'"))
-      ) {
-        val = val.slice(1, -1);
-      }
-      process.env[key] = val;
-    }
-  } catch {}
-}
-loadEnv();
-
-const credentials = {
-  token: process.env.SANDBOX_VERCEL_TOKEN!,
-  teamId: process.env.SANDBOX_VERCEL_TEAM_ID!,
-  projectId: process.env.SANDBOX_VERCEL_PROJECT_ID!,
-};
-
-if (!credentials.token || !credentials.teamId || !credentials.projectId) {
-  console.error(
-    "Missing credentials. Set SANDBOX_VERCEL_TOKEN, SANDBOX_VERCEL_TEAM_ID, SANDBOX_VERCEL_PROJECT_ID in .env",
-  );
-  process.exit(1);
-}
-
-// ---------------------------------------------------------------------------
-// CLI args
-// ---------------------------------------------------------------------------
-
-function parseArgs() {
-  const args = process.argv.slice(2);
-  let iterations = 10;
-  let warmup = 1;
-  let json = false;
-  let branch = "ctate/native-2";
-  let vcpus = 8;
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--iterations" && args[i + 1]) {
-      iterations = parseInt(args[++i], 10);
-    } else if (args[i] === "--warmup" && args[i + 1]) {
-      warmup = parseInt(args[++i], 10);
-    } else if (args[i] === "--json") {
-      json = true;
-    } else if (args[i] === "--branch" && args[i + 1]) {
-      branch = args[++i];
-    } else if (args[i] === "--vcpus" && args[i + 1]) {
-      vcpus = parseInt(args[++i], 10);
-    }
-  }
-
-  return { iterations, warmup, json, branch, vcpus };
-}
-
-const config = parseArgs();
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const TIMEOUT_MS = 30 * 60 * 1000;
-const REPO_URL = "https://github.com/vercel-labs/agent-browser.git";
-
-const CHROMIUM_SYSTEM_DEPS = [
-  "nss",
-  "nspr",
-  "libxkbcommon",
-  "atk",
-  "at-spi2-atk",
-  "at-spi2-core",
-  "libXcomposite",
-  "libXdamage",
-  "libXrandr",
-  "libXfixes",
-  "libXcursor",
-  "libXi",
-  "libXtst",
-  "libXScrnSaver",
-  "libXext",
-  "mesa-libgbm",
-  "libdrm",
-  "mesa-libGL",
-  "mesa-libEGL",
-  "cups-libs",
-  "alsa-lib",
-  "pango",
-  "cairo",
-  "gtk3",
-  "dbus-libs",
-];
-
-// ---------------------------------------------------------------------------
-// Sandbox helpers
-// ---------------------------------------------------------------------------
-
-type SandboxInstance = InstanceType<typeof Sandbox>;
-
-async function run(
-  sandbox: SandboxInstance,
-  cmd: string,
-  args: string[],
-): Promise<string> {
-  const result = await sandbox.runCommand(cmd, args);
-  const stdout = await result.stdout();
-  const stderr = await result.stderr();
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `Command failed (exit ${result.exitCode}): ${cmd} ${args.join(" ")}\n${stderr || stdout}`,
-    );
-  }
-  return stdout;
-}
-
-async function shell(sandbox: SandboxInstance, script: string): Promise<string> {
-  return run(sandbox, "sh", ["-c", script]);
-}
-
-async function shellSafe(sandbox: SandboxInstance, script: string): Promise<string> {
-  const result = await sandbox.runCommand("sh", ["-c", script]);
-  return (await result.stdout()).trim();
-}
-
-// ---------------------------------------------------------------------------
-// Stats
-// ---------------------------------------------------------------------------
-
-interface Stats {
-  avgMs: number;
-  stddevMs: number;
-  minMs: number;
-  maxMs: number;
-  p50Ms: number;
-  samples: number[];
-}
-
-function computeStats(samples: number[]): Stats {
-  const sorted = [...samples].sort((a, b) => a - b);
-  const sum = sorted.reduce((a, b) => a + b, 0);
-  const avg = sum / sorted.length;
-  const variance =
-    sorted.reduce((acc, v) => acc + (v - avg) ** 2, 0) / sorted.length;
-  return {
-    avgMs: Math.round(avg),
-    stddevMs: Math.round(Math.sqrt(variance)),
-    minMs: sorted[0],
-    maxMs: sorted[sorted.length - 1],
-    p50Ms: sorted[Math.floor(sorted.length / 2)],
-    samples: sorted,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Metrics collection
-// ---------------------------------------------------------------------------
-
-interface ProcessMetrics {
-  pid: number;
-  rssKb: number;
-  vszKb: number;
-  cpuPercent: number;
-  memPercent: number;
-  cpuTimeSec: number;
-  command: string;
-}
-
-interface DaemonMetrics {
-  coldStartMs: number;
-  binarySizeBytes: number;
-  distributionSizeBytes: number;
-  daemonProcesses: ProcessMetrics[];
-  browserProcesses: ProcessMetrics[];
-  daemonRssKb: number;
-  browserRssKb: number;
-  daemonPeakRssKb: number;
-  daemonCpuTimeSec: number;
-  totalCpuTimeSec: number;
-}
-
-async function findDaemonPids(
-  sandbox: SandboxInstance,
-  _session: string,
-): Promise<number[]> {
-  // The daemon process name is "agent-browser" but session/daemon flags are
-  // env vars, not command-line args, so we can't grep them from `ps`.
-  // Instead, find all agent-browser processes that look like long-running daemons
-  // (not short-lived CLI invocations -- those exit immediately).
-  const raw = await shellSafe(
-    sandbox,
-    `pgrep -x agent-browser 2>/dev/null || true`,
-  );
-  if (!raw) {
-    // Fallback: broader match on process name
-    const fallback = await shellSafe(
-      sandbox,
-      `pgrep -f 'agent-browser' 2>/dev/null | head -5 || true`,
-    );
-    if (!fallback) return [];
-    return fallback.split("\n").map(Number).filter(Boolean);
-  }
-  return raw.split("\n").map(Number).filter(Boolean);
-}
-
-async function collectProcessMetrics(
-  sandbox: SandboxInstance,
-  pid: number,
-): Promise<ProcessMetrics | null> {
-  const raw = await shellSafe(
-    sandbox,
-    `ps -p ${pid} -o pid=,rss=,vsz=,%cpu=,%mem=,cputime=,comm= 2>/dev/null || true`,
-  );
-  if (!raw) return null;
-
-  const parts = raw.trim().split(/\s+/);
-  if (parts.length < 7) return null;
-
-  // Parse cputime "HH:MM:SS" or "MM:SS" to seconds
-  const timeParts = parts[5].split(":").map(Number);
-  let cpuTimeSec = 0;
-  if (timeParts.length === 3) {
-    cpuTimeSec = timeParts[0] * 3600 + timeParts[1] * 60 + timeParts[2];
-  } else if (timeParts.length === 2) {
-    cpuTimeSec = timeParts[0] * 60 + timeParts[1];
-  }
-
-  return {
-    pid: Number(parts[0]),
-    rssKb: Number(parts[1]),
-    vszKb: Number(parts[2]),
-    cpuPercent: Number(parts[3]),
-    memPercent: Number(parts[4]),
-    cpuTimeSec,
-    command: parts.slice(6).join(" "),
-  };
-}
-
-async function getPeakRssKb(
-  sandbox: SandboxInstance,
-  pid: number,
-): Promise<number> {
-  const raw = await shellSafe(
-    sandbox,
-    `cat /proc/${pid}/status 2>/dev/null | grep VmHWM | awk '{print $2}' || echo 0`,
-  );
-  return Number(raw) || 0;
-}
-
-async function getChildPids(
-  sandbox: SandboxInstance,
-  pid: number,
-): Promise<number[]> {
-  const raw = await shellSafe(
-    sandbox,
-    `pgrep -P ${pid} 2>/dev/null || true`,
-  );
-  if (!raw) return [];
-  return raw.split("\n").map(Number).filter(Boolean);
-}
-
-async function getAllDescendantPids(
-  sandbox: SandboxInstance,
-  pid: number,
-): Promise<number[]> {
-  const all: number[] = [];
-  const queue = [pid];
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    all.push(current);
-    const children = await getChildPids(sandbox, current);
-    queue.push(...children);
-  }
-  return all;
-}
-
-async function collectDaemonMetrics(
-  sandbox: SandboxInstance,
-  session: string,
-  coldStartMs: number,
-  binarySizeBytes: number,
-  distributionSizeBytes: number,
-): Promise<DaemonMetrics> {
-  // Find daemon PIDs -- the agent-browser process itself
-  const daemonPids = await findDaemonPids(sandbox, session);
-
-  // Also find the full process tree (daemon + Chrome children)
-  let allPids: number[] = [];
-  for (const pid of daemonPids) {
-    const descendants = await getAllDescendantPids(sandbox, pid);
-    allPids.push(...descendants);
-  }
-  allPids = [...new Set(allPids)];
-
-  // If no daemon PIDs found via pgrep, fall back to grabbing all
-  // agent-browser and chrome processes for metrics
-  if (allPids.length === 0) {
-    const fallback = await shellSafe(
-      sandbox,
-      `ps -eo pid,comm | grep -E 'agent-browser|chrome' | grep -v grep | awk '{print $1}' || true`,
-    );
-    if (fallback) {
-      allPids = fallback.split("\n").map(Number).filter(Boolean);
-    }
-  }
-
-  const daemonProcs: ProcessMetrics[] = [];
-  const browserProcs: ProcessMetrics[] = [];
-  let daemonPeakRssKb = 0;
-
-  for (const pid of allPids) {
-    const metrics = await collectProcessMetrics(sandbox, pid);
-    if (!metrics) continue;
-
-    const isBrowser = /chrome|chromium/i.test(metrics.command);
-    if (isBrowser) {
-      browserProcs.push(metrics);
-    } else {
-      daemonProcs.push(metrics);
-      const peak = await getPeakRssKb(sandbox, pid);
-      daemonPeakRssKb = Math.max(daemonPeakRssKb, peak);
-    }
-  }
-
-  const daemonRssKb = daemonProcs.reduce((sum, p) => sum + p.rssKb, 0);
-  const browserRssKb = browserProcs.reduce((sum, p) => sum + p.rssKb, 0);
-  const daemonCpuTimeSec = daemonProcs.reduce((sum, p) => sum + p.cpuTimeSec, 0);
-  const allProcs = [...daemonProcs, ...browserProcs];
-  const totalCpuTimeSec = allProcs.reduce((sum, p) => sum + p.cpuTimeSec, 0);
-
-  return {
-    coldStartMs,
-    binarySizeBytes,
-    distributionSizeBytes,
-    daemonProcesses: daemonProcs,
-    browserProcesses: browserProcs,
-    daemonRssKb,
-    browserRssKb,
-    daemonPeakRssKb,
-    daemonCpuTimeSec,
-    totalCpuTimeSec,
-  };
-}
-
-async function getBinarySize(
-  sandbox: SandboxInstance,
-): Promise<number> {
-  // Follow symlinks to get the real binary/script size
-  const raw = await shellSafe(
-    sandbox,
-    `stat -L -c %s "$(readlink -f "$(which agent-browser)")" 2>/dev/null || echo 0`,
-  );
-  return Number(raw) || 0;
-}
-
-async function getDistributionSize(
-  sandbox: SandboxInstance,
-  mode: DaemonMode,
-): Promise<number> {
-  if (mode === "node") {
-    // Total size of the npm package + Playwright browser
-    const npmPkg = await shellSafe(
-      sandbox,
-      `du -sb "$(npm root -g)/agent-browser" 2>/dev/null | awk '{print $1}' || echo 0`,
-    );
-    const pwBrowser = await shellSafe(
-      sandbox,
-      `du -sb "$HOME/.cache/ms-playwright" 2>/dev/null | awk '{print $1}' || echo 0`,
-    );
-    return (Number(npmPkg) || 0) + (Number(pwBrowser) || 0);
-  } else {
-    // Rust binary + Chrome for Testing (checks multiple possible cache paths)
-    const binary = await shellSafe(
-      sandbox,
-      `stat -L -c %s "$(readlink -f "$(which agent-browser)")" 2>/dev/null || echo 0`,
-    );
-    const chrome = await shellSafe(
-      sandbox,
-      [
-        `size=0`,
-        `for d in "$HOME/.cache/agent-browser" "$HOME/.cache/ms-playwright" "$HOME/.agent-browser/chrome"; do`,
-        `  if [ -d "$d" ]; then size=$(du -sb "$d" 2>/dev/null | awk '{print $1}'); break; fi`,
-        `done`,
-        `echo $size`,
-      ].join("; "),
-    );
-    return (Number(binary) || 0) + (Number(chrome) || 0);
-  }
-}
-
-function formatBytes(bytes: number): string {
-  if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
-  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${bytes} B`;
-}
-
-function formatKb(kb: number): string {
-  if (kb >= 1024) return `${(kb / 1024).toFixed(1)} MB`;
-  return `${kb} KB`;
-}
-
-// ---------------------------------------------------------------------------
-// Scenario runner
-// ---------------------------------------------------------------------------
-
-type DaemonMode = "node" | "native";
-
-function daemonEnv(mode: DaemonMode): Record<string, string> {
-  return { AGENT_BROWSER_SESSION: `bench-${mode}` };
-}
-
-async function agentBrowser(
-  sandbox: SandboxInstance,
-  args: string[],
-  mode: DaemonMode,
-): Promise<void> {
-  const result = await sandbox.runCommand({
-    cmd: "agent-browser",
-    args,
-    env: daemonEnv(mode),
-  });
-  if (result.exitCode !== 0) {
-    const stderr = await result.stderr();
-    const stdout = await result.stdout();
-    throw new Error(
-      `agent-browser ${args.join(" ")} failed (exit ${result.exitCode}): ${stderr || stdout}`,
-    );
-  }
-}
-
-async function timedAgentBrowser(
-  sandbox: SandboxInstance,
-  args: string[],
-  mode: DaemonMode,
-): Promise<number> {
-  const start = Date.now();
-  const result = await sandbox.runCommand({
-    cmd: "agent-browser",
-    args,
-    env: daemonEnv(mode),
-  });
-  const elapsed = Date.now() - start;
-  if (result.exitCode !== 0) {
-    const stderr = await result.stderr();
-    const stdout = await result.stdout();
-    throw new Error(
-      `agent-browser ${args.join(" ")} failed (exit ${result.exitCode}): ${stderr || stdout}`,
-    );
-  }
-  return elapsed;
-}
-
-interface ScenarioResult {
-  name: string;
-  description: string;
-  stats: Stats;
-  error?: string;
-}
-
-async function runScenario(
-  sandbox: SandboxInstance,
-  scenario: Scenario,
-  mode: DaemonMode,
-  iterations: number,
-  warmup: number,
-): Promise<ScenarioResult> {
-  try {
-    if (scenario.setup) {
-      for (const cmd of scenario.setup) {
-        await agentBrowser(sandbox, cmd, mode);
-      }
-    }
-
-    for (let w = 0; w < warmup; w++) {
-      for (const cmd of scenario.commands) {
-        await agentBrowser(sandbox, cmd, mode);
-      }
-    }
-
-    const samples: number[] = [];
-    for (let i = 0; i < iterations; i++) {
-      let totalMs = 0;
-      for (const cmd of scenario.commands) {
-        totalMs += await timedAgentBrowser(sandbox, cmd, mode);
-      }
-      samples.push(totalMs);
-    }
-
-    if (scenario.teardown) {
-      for (const cmd of scenario.teardown) {
-        await agentBrowser(sandbox, cmd, mode);
-      }
-    }
-
-    return {
-      name: scenario.name,
-      description: scenario.description,
-      stats: computeStats(samples),
-    };
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err);
-    return {
-      name: scenario.name,
-      description: scenario.description,
-      stats: { avgMs: -1, stddevMs: -1, minMs: -1, maxMs: -1, p50Ms: -1, samples: [] },
-      error: message,
-    };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Benchmark phases
-// ---------------------------------------------------------------------------
-
-interface DaemonResults {
-  mode: DaemonMode;
-  label: string;
-  scenarios: ScenarioResult[];
-  metrics: DaemonMetrics;
-}
-
-async function benchmarkDaemon(
-  sandbox: SandboxInstance,
-  mode: DaemonMode,
-  label: string,
-): Promise<DaemonResults> {
-  console.log(`\n--- ${label} ---`);
-
-  // Measure sizes before launch
-  const binarySizeBytes = await getBinarySize(sandbox);
-  const distributionSizeBytes = await getDistributionSize(sandbox, mode);
-
-  // Cold start: time the first launch (daemon spawn + browser launch)
-  const coldStartBegin = Date.now();
-  await agentBrowser(sandbox, ["open", "about:blank"], mode);
-  const coldStartMs = Date.now() - coldStartBegin;
-  console.log(`  Cold start: ${coldStartMs}ms`);
-  console.log(`  Binary size: ${formatBytes(binarySizeBytes)}`);
-  console.log(`  Distribution size: ${formatBytes(distributionSizeBytes)}`);
-
-  // Run all scenarios
-  const results: ScenarioResult[] = [];
-  for (const scenario of scenarios) {
-    process.stdout.write(`  ${scenario.name} `);
-    const result = await runScenario(
-      sandbox,
-      scenario,
-      mode,
-      config.iterations,
-      config.warmup,
-    );
-    if (result.error) {
-      console.log(`FAILED: ${result.error.slice(0, 120)}`);
-    } else {
-      const dots = ".".repeat(Math.max(1, 30 - scenario.name.length));
-      const s = result.stats;
-      console.log(
-        `${dots} ${s.avgMs}ms avg +/-${s.stddevMs}ms (p50: ${s.p50Ms}ms, min: ${s.minMs}ms, max: ${s.maxMs}ms)`,
-      );
-    }
-    results.push(result);
-  }
-
-  // Collect system metrics after scenarios (daemon is still running)
-  const session = `bench-${mode}`;
-  const metrics = await collectDaemonMetrics(
-    sandbox,
-    session,
-    coldStartMs,
-    binarySizeBytes,
-    distributionSizeBytes,
-  );
-
-  // Also grab a full process snapshot for context
-  const psOutput = await shellSafe(
-    sandbox,
-    `ps aux --sort=-rss | head -20`,
-  );
-  console.log(`\n  Process snapshot (top by RSS):`);
-  for (const line of psOutput.split("\n").slice(0, 10)) {
-    console.log(`    ${line}`);
-  }
-
-  console.log(`\n  Daemon processes (${metrics.daemonProcesses.length}):`);
-  console.log(`    RSS: ${formatKb(metrics.daemonRssKb)} (peak: ${formatKb(metrics.daemonPeakRssKb)})`);
-  console.log(`    CPU time: ${metrics.daemonCpuTimeSec.toFixed(1)}s`);
-  for (const p of metrics.daemonProcesses) {
-    console.log(`      PID ${p.pid}: ${p.command} (RSS: ${formatKb(p.rssKb)}, CPU: ${p.cpuPercent}%)`);
-  }
-  console.log(`  Browser processes (${metrics.browserProcesses.length}):`);
-  console.log(`    RSS: ${formatKb(metrics.browserRssKb)}`);
-  for (const p of metrics.browserProcesses) {
-    console.log(`      PID ${p.pid}: ${p.command} (RSS: ${formatKb(p.rssKb)}, CPU: ${p.cpuPercent}%)`);
-  }
-
-  await agentBrowser(sandbox, ["close"], mode);
-  console.log(`  Browser closed.`);
-
-  return { mode, label, scenarios: results, metrics };
-}
-
-// ---------------------------------------------------------------------------
-// Install helpers
-// ---------------------------------------------------------------------------
-
-async function installChromiumDeps(sandbox: SandboxInstance) {
-  console.log("Installing Chromium system dependencies...");
-  await shell(
-    sandbox,
-    `sudo dnf clean all 2>&1 && sudo dnf install -y --skip-broken ${CHROMIUM_SYSTEM_DEPS.join(" ")} 2>&1 && sudo ldconfig 2>&1`,
-  );
-}
-
-async function installNodeDaemon(sandbox: SandboxInstance) {
-  console.log("Installing agent-browser from npm (Node.js daemon)...");
-  await run(sandbox, "npm", ["install", "-g", "agent-browser"]);
-  await run(sandbox, "npx", ["agent-browser", "install"]);
-  const version = await shell(sandbox, "agent-browser --version 2>&1 || true");
-  console.log(`  version: ${version.trim()}`);
-}
-
-async function installNativeDaemon(sandbox: SandboxInstance, branch: string) {
-  console.log(`\nBuilding native daemon from ${branch}...`);
-
-  console.log("  Installing build tools and Rust toolchain...");
-  const rustStart = Date.now();
-  await shell(
-    sandbox,
-    "sudo dnf install -y gcc gcc-c++ make perl-core openssl-devel 2>&1",
-  );
-  await shell(
-    sandbox,
-    "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y 2>&1",
-  );
-  console.log(`  Rust + build tools installed (${Math.round((Date.now() - rustStart) / 1000)}s)`);
-
-  console.log(`  Cloning repo (branch: ${branch})...`);
-  const cloneStart = Date.now();
-  await shell(
-    sandbox,
-    `git clone --depth 1 --branch ${branch} ${REPO_URL} /tmp/agent-browser 2>&1`,
-  );
-  console.log(`  Cloned (${Math.round((Date.now() - cloneStart) / 1000)}s)`);
-
-  console.log("  Building release binary (cargo build --release)...");
-  const buildStart = Date.now();
-  await shell(
-    sandbox,
-    "source $HOME/.cargo/env && cd /tmp/agent-browser/cli && cargo build --release 2>&1",
-  );
-  console.log(`  Built (${Math.round((Date.now() - buildStart) / 1000)}s)`);
-
-  const npmBinPath = (await shell(sandbox, "which agent-browser")).trim();
-  console.log(`  Replacing ${npmBinPath} with native build...`);
-  await shell(
-    sandbox,
-    `sudo cp /tmp/agent-browser/cli/target/release/agent-browser ${npmBinPath}`,
-  );
-
-  const version = await shell(sandbox, "agent-browser --version 2>&1 || true");
-  console.log(`  version: ${version.trim()}`);
-}
-
-// ---------------------------------------------------------------------------
-// Output
-// ---------------------------------------------------------------------------
-
-function printResults(node: DaemonResults, native: DaemonResults) {
-  console.log("\n\n========== COMMAND LATENCY ==========\n");
-
-  const header =
-    "Scenario".padEnd(20) + "| Node avg +/-sd  | Rust avg +/-sd  | Speedup";
-  const sep = "-".repeat(20) + "|-----------------|-----------------|--------";
-  console.log(header);
-  console.log(sep);
-
-  for (let i = 0; i < node.scenarios.length; i++) {
-    const n = node.scenarios[i];
-    const r = native.scenarios[i];
-    const name = n.name.padEnd(20);
-
-    if (n.error || r.error) {
-      const nodeVal = n.error ? "FAILED".padEnd(15) : `${n.stats.avgMs}ms`.padEnd(15);
-      const rustVal = r.error ? "FAILED".padEnd(15) : `${r.stats.avgMs}ms`.padEnd(15);
-      console.log(`${name}| ${nodeVal} | ${rustVal} |    --`);
-      continue;
-    }
-
-    const nodeVal = `${n.stats.avgMs} +/-${n.stats.stddevMs}ms`.padEnd(15);
-    const rustVal = `${r.stats.avgMs} +/-${r.stats.stddevMs}ms`.padEnd(15);
-    const speedup =
-      r.stats.avgMs > 0
-        ? (n.stats.avgMs / r.stats.avgMs).toFixed(2) + "x"
-        : "--";
-    console.log(`${name}| ${nodeVal} | ${rustVal} | ${speedup.padStart(6)}`);
-  }
-
-  console.log("\n\n========== SYSTEM METRICS ==========\n");
-
-  const nm = node.metrics;
-  const rm = native.metrics;
-
-  function ratio(a: number, b: number): string {
-    if (b <= 0) return "--";
-    return (a / b).toFixed(2) + "x";
-  }
-
-  const metricRows: [string, string, string, string][] = [
-    [
-      "Cold start",
-      `${nm.coldStartMs}ms`,
-      `${rm.coldStartMs}ms`,
-      ratio(nm.coldStartMs, rm.coldStartMs),
-    ],
-    [
-      "Binary size",
-      formatBytes(nm.binarySizeBytes),
-      formatBytes(rm.binarySizeBytes),
-      ratio(nm.binarySizeBytes, rm.binarySizeBytes),
-    ],
-    [
-      "Distribution size",
-      formatBytes(nm.distributionSizeBytes),
-      formatBytes(rm.distributionSizeBytes),
-      ratio(nm.distributionSizeBytes, rm.distributionSizeBytes),
-    ],
-    [
-      "Daemon RSS",
-      formatKb(nm.daemonRssKb),
-      formatKb(rm.daemonRssKb),
-      ratio(nm.daemonRssKb, rm.daemonRssKb),
-    ],
-    [
-      "Daemon peak RSS",
-      formatKb(nm.daemonPeakRssKb),
-      formatKb(rm.daemonPeakRssKb),
-      ratio(nm.daemonPeakRssKb, rm.daemonPeakRssKb),
-    ],
-    [
-      "Browser RSS",
-      formatKb(nm.browserRssKb),
-      formatKb(rm.browserRssKb),
-      ratio(nm.browserRssKb, rm.browserRssKb),
-    ],
-    [
-      "Daemon CPU time",
-      `${nm.daemonCpuTimeSec.toFixed(1)}s`,
-      `${rm.daemonCpuTimeSec.toFixed(1)}s`,
-      ratio(nm.daemonCpuTimeSec, rm.daemonCpuTimeSec),
-    ],
-    [
-      "Daemon processes",
-      String(nm.daemonProcesses.length),
-      String(rm.daemonProcesses.length),
-      "--",
-    ],
-    [
-      "Browser processes",
-      String(nm.browserProcesses.length),
-      String(rm.browserProcesses.length),
-      "--",
-    ],
-  ];
-
-  const mHeader =
-    "Metric".padEnd(20) + "| Node".padEnd(14) + "| Rust".padEnd(14) + "| Ratio";
-  const mSep = "-".repeat(20) + "|" + "-".repeat(13) + "|" + "-".repeat(13) + "|--------";
-  console.log(mHeader);
-  console.log(mSep);
-  for (const [metric, nodeVal, rustVal, ratio] of metricRows) {
-    console.log(
-      `${metric.padEnd(20)}| ${nodeVal.padEnd(12)}| ${rustVal.padEnd(12)}| ${ratio}`,
-    );
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-async function main() {
-  console.log("agent-browser Daemon Benchmark (Node.js vs Rust Native)");
-  console.log(`Branch: ${config.branch}`);
-  console.log(`Iterations: ${config.iterations} (+ ${config.warmup} warmup)`);
-  console.log(`vCPUs: ${config.vcpus}\n`);
-
-  console.log("Creating sandbox...");
-  const sandbox = await Sandbox.create({
-    ...credentials,
-    timeout: TIMEOUT_MS,
-    runtime: "node22",
-    networkPolicy: "allow-all" as const,
-    resources: { vcpus: config.vcpus },
-  });
-  console.log(`Sandbox: ${sandbox.sandboxId}`);
-
-  try {
-    await installChromiumDeps(sandbox);
-
-    // Phase 1: Node.js daemon (from published npm package)
-    await installNodeDaemon(sandbox);
-    const nodeResults = await benchmarkDaemon(
-      sandbox,
-      "node",
-      "Node.js Daemon (npm)",
-    );
-
-    // Phase 2: Rust native daemon (built from branch)
-    await installNativeDaemon(sandbox, config.branch);
-    const nativeResults = await benchmarkDaemon(
-      sandbox,
-      "native",
-      `Rust Native Daemon (${config.branch})`,
-    );
-
-    printResults(nodeResults, nativeResults);
-
-    if (config.json) {
-      const output = {
-        timestamp: new Date().toISOString(),
-        branch: config.branch,
-        vcpus: config.vcpus,
-        iterations: config.iterations,
-        warmup: config.warmup,
-        node: {
-          scenarios: nodeResults.scenarios.map((s) => ({
-            name: s.name,
-            description: s.description,
-            ...s.stats,
-            error: s.error,
-          })),
-          metrics: nodeResults.metrics,
-        },
-        native: {
-          scenarios: nativeResults.scenarios.map((s) => ({
-            name: s.name,
-            description: s.description,
-            ...s.stats,
-            error: s.error,
-          })),
-          metrics: nativeResults.metrics,
-        },
-      };
-      writeFileSync("results.json", JSON.stringify(output, null, 2));
-      console.log("\nResults written to results.json");
-    }
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`\nFatal error: ${message}`);
-    process.exit(1);
-  } finally {
-    try {
-      await sandbox.stop();
-      console.log("\nSandbox stopped.");
-    } catch {
-      console.warn("Warning: failed to stop sandbox.");
-    }
-  }
-}
-
-main();

benchmarks/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "agent-browser-benchmarks",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "bench": "tsx bench.ts"
-  },
-  "dependencies": {
-    "@vercel/sandbox": "^1.8.0",
-    "tsx": "^4.19.0"
-  }
-}

benchmarks/pnpm-lock.yaml

@@ -1,472 +0,0 @@
-lockfileVersion: '9.0'
-
-settings:
-  autoInstallPeers: true
-  excludeLinksFromLockfile: false
-
-importers:
-
-  .:
-    dependencies:
-      '@vercel/sandbox':
-        specifier: ^1.8.0
-        version: 1.8.1
-      tsx:
-        specifier: ^4.19.0
-        version: 4.21.0
-
-packages:
-
-  '@esbuild/aix-ppc64@0.27.4':
-    resolution: {integrity: sha512-cQPwL2mp2nSmHHJlCyoXgHGhbEPMrEEU5xhkcy3Hs/O7nGZqEpZ2sUtLaL9MORLtDfRvVl2/3PAuEkYZH0Ty8Q==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [aix]
-
-  '@esbuild/android-arm64@0.27.4':
-    resolution: {integrity: sha512-gdLscB7v75wRfu7QSm/zg6Rx29VLdy9eTr2t44sfTW7CxwAtQghZ4ZnqHk3/ogz7xao0QAgrkradbBzcqFPasw==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [android]
-
-  '@esbuild/android-arm@0.27.4':
-    resolution: {integrity: sha512-X9bUgvxiC8CHAGKYufLIHGXPJWnr0OCdR0anD2e21vdvgCI8lIfqFbnoeOz7lBjdrAGUhqLZLcQo6MLhTO2DKQ==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [android]
-
-  '@esbuild/android-x64@0.27.4':
-    resolution: {integrity: sha512-PzPFnBNVF292sfpfhiyiXCGSn9HZg5BcAz+ivBuSsl6Rk4ga1oEXAamhOXRFyMcjwr2DVtm40G65N3GLeH1Lvw==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [android]
-
-  '@esbuild/darwin-arm64@0.27.4':
-    resolution: {integrity: sha512-b7xaGIwdJlht8ZFCvMkpDN6uiSmnxxK56N2GDTMYPr2/gzvfdQN8rTfBsvVKmIVY/X7EM+/hJKEIbbHs9oA4tQ==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@esbuild/darwin-x64@0.27.4':
-    resolution: {integrity: sha512-sR+OiKLwd15nmCdqpXMnuJ9W2kpy0KigzqScqHI3Hqwr7IXxBp3Yva+yJwoqh7rE8V77tdoheRYataNKL4QrPw==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [darwin]
-
-  '@esbuild/freebsd-arm64@0.27.4':
-    resolution: {integrity: sha512-jnfpKe+p79tCnm4GVav68A7tUFeKQwQyLgESwEAUzyxk/TJr4QdGog9sqWNcUbr/bZt/O/HXouspuQDd9JxFSw==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [freebsd]
-
-  '@esbuild/freebsd-x64@0.27.4':
-    resolution: {integrity: sha512-2kb4ceA/CpfUrIcTUl1wrP/9ad9Atrp5J94Lq69w7UwOMolPIGrfLSvAKJp0RTvkPPyn6CIWrNy13kyLikZRZQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [freebsd]
-
-  '@esbuild/linux-arm64@0.27.4':
-    resolution: {integrity: sha512-7nQOttdzVGth1iz57kxg9uCz57dxQLHWxopL6mYuYthohPKEK0vU0C3O21CcBK6KDlkYVcnDXY099HcCDXd9dA==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [linux]
-
-  '@esbuild/linux-arm@0.27.4':
-    resolution: {integrity: sha512-aBYgcIxX/wd5n2ys0yESGeYMGF+pv6g0DhZr3G1ZG4jMfruU9Tl1i2Z+Wnj9/KjGz1lTLCcorqE2viePZqj4Eg==}
-    engines: {node: '>=18'}
-    cpu: [arm]
-    os: [linux]
-
-  '@esbuild/linux-ia32@0.27.4':
-    resolution: {integrity: sha512-oPtixtAIzgvzYcKBQM/qZ3R+9TEUd1aNJQu0HhGyqtx6oS7qTpvjheIWBbes4+qu1bNlo2V4cbkISr8q6gRBFA==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [linux]
-
-  '@esbuild/linux-loong64@0.27.4':
-    resolution: {integrity: sha512-8mL/vh8qeCoRcFH2nM8wm5uJP+ZcVYGGayMavi8GmRJjuI3g1v6Z7Ni0JJKAJW+m0EtUuARb6Lmp4hMjzCBWzA==}
-    engines: {node: '>=18'}
-    cpu: [loong64]
-    os: [linux]
-
-  '@esbuild/linux-mips64el@0.27.4':
-    resolution: {integrity: sha512-1RdrWFFiiLIW7LQq9Q2NES+HiD4NyT8Itj9AUeCl0IVCA459WnPhREKgwrpaIfTOe+/2rdntisegiPWn/r/aAw==}
-    engines: {node: '>=18'}
-    cpu: [mips64el]
-    os: [linux]
-
-  '@esbuild/linux-ppc64@0.27.4':
-    resolution: {integrity: sha512-tLCwNG47l3sd9lpfyx9LAGEGItCUeRCWeAx6x2Jmbav65nAwoPXfewtAdtbtit/pJFLUWOhpv0FpS6GQAmPrHA==}
-    engines: {node: '>=18'}
-    cpu: [ppc64]
-    os: [linux]
-
-  '@esbuild/linux-riscv64@0.27.4':
-    resolution: {integrity: sha512-BnASypppbUWyqjd1KIpU4AUBiIhVr6YlHx/cnPgqEkNoVOhHg+YiSVxM1RLfiy4t9cAulbRGTNCKOcqHrEQLIw==}
-    engines: {node: '>=18'}
-    cpu: [riscv64]
-    os: [linux]
-
-  '@esbuild/linux-s390x@0.27.4':
-    resolution: {integrity: sha512-+eUqgb/Z7vxVLezG8bVB9SfBie89gMueS+I0xYh2tJdw3vqA/0ImZJ2ROeWwVJN59ihBeZ7Tu92dF/5dy5FttA==}
-    engines: {node: '>=18'}
-    cpu: [s390x]
-    os: [linux]
-
-  '@esbuild/linux-x64@0.27.4':
-    resolution: {integrity: sha512-S5qOXrKV8BQEzJPVxAwnryi2+Iq5pB40gTEIT69BQONqR7JH1EPIcQ/Uiv9mCnn05jff9umq/5nqzxlqTOg9NA==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [linux]
-
-  '@esbuild/netbsd-arm64@0.27.4':
-    resolution: {integrity: sha512-xHT8X4sb0GS8qTqiwzHqpY00C95DPAq7nAwX35Ie/s+LO9830hrMd3oX0ZMKLvy7vsonee73x0lmcdOVXFzd6Q==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [netbsd]
-
-  '@esbuild/netbsd-x64@0.27.4':
-    resolution: {integrity: sha512-RugOvOdXfdyi5Tyv40kgQnI0byv66BFgAqjdgtAKqHoZTbTF2QqfQrFwa7cHEORJf6X2ht+l9ABLMP0dnKYsgg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [netbsd]
-
-  '@esbuild/openbsd-arm64@0.27.4':
-    resolution: {integrity: sha512-2MyL3IAaTX+1/qP0O1SwskwcwCoOI4kV2IBX1xYnDDqthmq5ArrW94qSIKCAuRraMgPOmG0RDTA74mzYNQA9ow==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openbsd]
-
-  '@esbuild/openbsd-x64@0.27.4':
-    resolution: {integrity: sha512-u8fg/jQ5aQDfsnIV6+KwLOf1CmJnfu1ShpwqdwC0uA7ZPwFws55Ngc12vBdeUdnuWoQYx/SOQLGDcdlfXhYmXQ==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [openbsd]
-
-  '@esbuild/openharmony-arm64@0.27.4':
-    resolution: {integrity: sha512-JkTZrl6VbyO8lDQO3yv26nNr2RM2yZzNrNHEsj9bm6dOwwu9OYN28CjzZkH57bh4w0I2F7IodpQvUAEd1mbWXg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [openharmony]
-
-  '@esbuild/sunos-x64@0.27.4':
-    resolution: {integrity: sha512-/gOzgaewZJfeJTlsWhvUEmUG4tWEY2Spp5M20INYRg2ZKl9QPO3QEEgPeRtLjEWSW8FilRNacPOg8R1uaYkA6g==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [sunos]
-
-  '@esbuild/win32-arm64@0.27.4':
-    resolution: {integrity: sha512-Z9SExBg2y32smoDQdf1HRwHRt6vAHLXcxD2uGgO/v2jK7Y718Ix4ndsbNMU/+1Qiem9OiOdaqitioZwxivhXYg==}
-    engines: {node: '>=18'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@esbuild/win32-ia32@0.27.4':
-    resolution: {integrity: sha512-DAyGLS0Jz5G5iixEbMHi5KdiApqHBWMGzTtMiJ72ZOLhbu/bzxgAe8Ue8CTS3n3HbIUHQz/L51yMdGMeoxXNJw==}
-    engines: {node: '>=18'}
-    cpu: [ia32]
-    os: [win32]
-
-  '@esbuild/win32-x64@0.27.4':
-    resolution: {integrity: sha512-+knoa0BDoeXgkNvvV1vvbZX4+hizelrkwmGJBdT17t8FNPwG2lKemmuMZlmaNQ3ws3DKKCxpb4zRZEIp3UxFCg==}
-    engines: {node: '>=18'}
-    cpu: [x64]
-    os: [win32]
-
-  '@vercel/oidc@3.2.0':
-    resolution: {integrity: sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug==}
-    engines: {node: '>= 20'}
-
-  '@vercel/sandbox@1.8.1':
-    resolution: {integrity: sha512-txohjI20aMxZiAzBL/KJi5EqTYsesBdOyIOtpTIyebPLTqYtDYfNhQ4OeYiUcPMUo0XBt8gSet/rIdLQEjj3/A==}
-
-  async-retry@1.3.3:
-    resolution: {integrity: sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==}
-
-  b4a@1.8.0:
-    resolution: {integrity: sha512-qRuSmNSkGQaHwNbM7J78Wwy+ghLEYF1zNrSeMxj4Kgw6y33O3mXcQ6Ie9fRvfU/YnxWkOchPXbaLb73TkIsfdg==}
-    peerDependencies:
-      react-native-b4a: '*'
-    peerDependenciesMeta:
-      react-native-b4a:
-        optional: true
-
-  bare-events@2.8.2:
-    resolution: {integrity: sha512-riJjyv1/mHLIPX4RwiK+oW9/4c3TEUeORHKefKAKnZ5kyslbN+HXowtbaVEqt4IMUB7OXlfixcs6gsFeo/jhiQ==}
-    peerDependencies:
-      bare-abort-controller: '*'
-    peerDependenciesMeta:
-      bare-abort-controller:
-        optional: true
-
-  esbuild@0.27.4:
-    resolution: {integrity: sha512-Rq4vbHnYkK5fws5NF7MYTU68FPRE1ajX7heQ/8QXXWqNgqqJ/GkmmyxIzUnf2Sr/bakf8l54716CcMGHYhMrrQ==}
-    engines: {node: '>=18'}
-    hasBin: true
-
-  events-universal@1.0.1:
-    resolution: {integrity: sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==}
-
-  fast-fifo@1.3.2:
-    resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==}
-
-  fsevents@2.3.3:
-    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
-    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
-    os: [darwin]
-
-  get-tsconfig@4.13.6:
-    resolution: {integrity: sha512-shZT/QMiSHc/YBLxxOkMtgSid5HFoauqCE3/exfsEcwg1WkeqjG+V40yBbBrsD+jW2HDXcs28xOfcbm2jI8Ddw==}
-
-  jsonlines@0.1.1:
-    resolution: {integrity: sha512-ekDrAGso79Cvf+dtm+mL8OBI2bmAOt3gssYs833De/C9NmIpWDWyUO4zPgB5x2/OhY366dkhgfPMYfwZF7yOZA==}
-
-  ms@2.1.3:
-    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
-
-  os-paths@4.4.0:
-    resolution: {integrity: sha512-wrAwOeXp1RRMFfQY8Sy7VaGVmPocaLwSFOYCGKSyo8qmJ+/yaafCl5BCA1IQZWqFSRBrKDYFeR9d/VyQzfH/jg==}
-    engines: {node: '>= 6.0'}
-
-  picocolors@1.1.1:
-    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
-
-  resolve-pkg-maps@1.0.0:
-    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
-
-  retry@0.13.1:
-    resolution: {integrity: sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==}
-    engines: {node: '>= 4'}
-
-  streamx@2.23.0:
-    resolution: {integrity: sha512-kn+e44esVfn2Fa/O0CPFcex27fjIL6MkVae0Mm6q+E6f0hWv578YCERbv+4m02cjxvDsPKLnmxral/rR6lBMAg==}
-
-  tar-stream@3.1.7:
-    resolution: {integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==}
-
-  text-decoder@1.2.7:
-    resolution: {integrity: sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==}
-
-  tsx@4.21.0:
-    resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
-    engines: {node: '>=18.0.0'}
-    hasBin: true
-
-  undici@7.24.1:
-    resolution: {integrity: sha512-5xoBibbmnjlcR3jdqtY2Lnx7WbrD/tHlT01TmvqZUFVc9Q1w4+j5hbnapTqbcXITMH1ovjq/W7BkqBilHiVAaA==}
-    engines: {node: '>=20.18.1'}
-
-  xdg-app-paths@5.1.0:
-    resolution: {integrity: sha512-RAQ3WkPf4KTU1A8RtFx3gWywzVKe00tfOPFfl2NDGqbIFENQO4kqAJp7mhQjNj/33W5x5hiWWUdyfPq/5SU3QA==}
-    engines: {node: '>=6'}
-
-  xdg-portable@7.3.0:
-    resolution: {integrity: sha512-sqMMuL1rc0FmMBOzCpd0yuy9trqF2yTTVe+E9ogwCSWQCdDEtQUwrZPT6AxqtsFGRNxycgncbP/xmOOSPw5ZUw==}
-    engines: {node: '>= 6.0'}
-
-  zod@3.24.4:
-    resolution: {integrity: sha512-OdqJE9UDRPwWsrHjLN2F8bPxvwJBK22EHLWtanu0LSYr5YqzsaaW3RMgmjwr8Rypg5k+meEJdSPXJZXE/yqOMg==}
-
-snapshots:
-
-  '@esbuild/aix-ppc64@0.27.4':
-    optional: true
-
-  '@esbuild/android-arm64@0.27.4':
-    optional: true
-
-  '@esbuild/android-arm@0.27.4':
-    optional: true
-
-  '@esbuild/android-x64@0.27.4':
-    optional: true
-
-  '@esbuild/darwin-arm64@0.27.4':
-    optional: true
-
-  '@esbuild/darwin-x64@0.27.4':
-    optional: true
-
-  '@esbuild/freebsd-arm64@0.27.4':
-    optional: true
-
-  '@esbuild/freebsd-x64@0.27.4':
-    optional: true
-
-  '@esbuild/linux-arm64@0.27.4':
-    optional: true
-
-  '@esbuild/linux-arm@0.27.4':
-    optional: true
-
-  '@esbuild/linux-ia32@0.27.4':
-    optional: true
-
-  '@esbuild/linux-loong64@0.27.4':
-    optional: true
-
-  '@esbuild/linux-mips64el@0.27.4':
-    optional: true
-
-  '@esbuild/linux-ppc64@0.27.4':
-    optional: true
-
-  '@esbuild/linux-riscv64@0.27.4':
-    optional: true
-
-  '@esbuild/linux-s390x@0.27.4':
-    optional: true
-
-  '@esbuild/linux-x64@0.27.4':
-    optional: true
-
-  '@esbuild/netbsd-arm64@0.27.4':
-    optional: true
-
-  '@esbuild/netbsd-x64@0.27.4':
-    optional: true
-
-  '@esbuild/openbsd-arm64@0.27.4':
-    optional: true
-
-  '@esbuild/openbsd-x64@0.27.4':
-    optional: true
-
-  '@esbuild/openharmony-arm64@0.27.4':
-    optional: true
-
-  '@esbuild/sunos-x64@0.27.4':
-    optional: true
-
-  '@esbuild/win32-arm64@0.27.4':
-    optional: true
-
-  '@esbuild/win32-ia32@0.27.4':
-    optional: true
-
-  '@esbuild/win32-x64@0.27.4':
-    optional: true
-
-  '@vercel/oidc@3.2.0': {}
-
-  '@vercel/sandbox@1.8.1':
-    dependencies:
-      '@vercel/oidc': 3.2.0
-      async-retry: 1.3.3
-      jsonlines: 0.1.1
-      ms: 2.1.3
-      picocolors: 1.1.1
-      tar-stream: 3.1.7
-      undici: 7.24.1
-      xdg-app-paths: 5.1.0
-      zod: 3.24.4
-    transitivePeerDependencies:
-      - bare-abort-controller
-      - react-native-b4a
-
-  async-retry@1.3.3:
-    dependencies:
-      retry: 0.13.1
-
-  b4a@1.8.0: {}
-
-  bare-events@2.8.2: {}
-
-  esbuild@0.27.4:
-    optionalDependencies:
-      '@esbuild/aix-ppc64': 0.27.4
-      '@esbuild/android-arm': 0.27.4
-      '@esbuild/android-arm64': 0.27.4
-      '@esbuild/android-x64': 0.27.4
-      '@esbuild/darwin-arm64': 0.27.4
-      '@esbuild/darwin-x64': 0.27.4
-      '@esbuild/freebsd-arm64': 0.27.4
-      '@esbuild/freebsd-x64': 0.27.4
-      '@esbuild/linux-arm': 0.27.4
-      '@esbuild/linux-arm64': 0.27.4
-      '@esbuild/linux-ia32': 0.27.4
-      '@esbuild/linux-loong64': 0.27.4
-      '@esbuild/linux-mips64el': 0.27.4
-      '@esbuild/linux-ppc64': 0.27.4
-      '@esbuild/linux-riscv64': 0.27.4
-      '@esbuild/linux-s390x': 0.27.4
-      '@esbuild/linux-x64': 0.27.4
-      '@esbuild/netbsd-arm64': 0.27.4
-      '@esbuild/netbsd-x64': 0.27.4
-      '@esbuild/openbsd-arm64': 0.27.4
-      '@esbuild/openbsd-x64': 0.27.4
-      '@esbuild/openharmony-arm64': 0.27.4
-      '@esbuild/sunos-x64': 0.27.4
-      '@esbuild/win32-arm64': 0.27.4
-      '@esbuild/win32-ia32': 0.27.4
-      '@esbuild/win32-x64': 0.27.4
-
-  events-universal@1.0.1:
-    dependencies:
-      bare-events: 2.8.2
-    transitivePeerDependencies:
-      - bare-abort-controller
-
-  fast-fifo@1.3.2: {}
-
-  fsevents@2.3.3:
-    optional: true
-
-  get-tsconfig@4.13.6:
-    dependencies:
-      resolve-pkg-maps: 1.0.0
-
-  jsonlines@0.1.1: {}
-
-  ms@2.1.3: {}
-
-  os-paths@4.4.0: {}
-
-  picocolors@1.1.1: {}
-
-  resolve-pkg-maps@1.0.0: {}
-
-  retry@0.13.1: {}
-
-  streamx@2.23.0:
-    dependencies:
-      events-universal: 1.0.1
-      fast-fifo: 1.3.2
-      text-decoder: 1.2.7
-    transitivePeerDependencies:
-      - bare-abort-controller
-      - react-native-b4a
-
-  tar-stream@3.1.7:
-    dependencies:
-      b4a: 1.8.0
-      fast-fifo: 1.3.2
-      streamx: 2.23.0
-    transitivePeerDependencies:
-      - bare-abort-controller
-      - react-native-b4a
-
-  text-decoder@1.2.7:
-    dependencies:
-      b4a: 1.8.0
-    transitivePeerDependencies:
-      - react-native-b4a
-
-  tsx@4.21.0:
-    dependencies:
-      esbuild: 0.27.4
-      get-tsconfig: 4.13.6
-    optionalDependencies:
-      fsevents: 2.3.3
-
-  undici@7.24.1: {}
-
-  xdg-app-paths@5.1.0:
-    dependencies:
-      xdg-portable: 7.3.0
-
-  xdg-portable@7.3.0:
-    dependencies:
-      os-paths: 4.4.0
-
-  zod@3.24.4: {}

benchmarks/scenarios.ts

@@ -1,105 +0,0 @@
-/**
- * Benchmark scenarios for comparing Node.js daemon vs Rust native daemon.
- *
- * Each scenario defines CLI commands run via `sandbox.runCommand("agent-browser", args)`.
- * Setup/teardown commands run once and are not timed.
- * The `commands` array is timed over N iterations.
- */
-
-export interface Scenario {
-  name: string;
-  description: string;
-  setup?: string[][];
-  commands: string[][];
-  teardown?: string[][];
-}
-
-const FORM_HTML = [
-  "<html><head><title>Bench</title></head><body>",
-  "<h1>Benchmark Page</h1>",
-  "<input id='name' type='text' placeholder='Name'>",
-  "<input id='email' type='email' placeholder='Email'>",
-  "<select id='color'><option value='red'>Red</option><option value='blue'>Blue</option></select>",
-  "<input id='agree' type='checkbox'>",
-  "<textarea id='bio' placeholder='Bio'></textarea>",
-  "<button id='submit'>Submit</button>",
-  "<p id='status'>Ready</p>",
-  "<a id='link' href='javascript:void(0)' onclick=\"document.getElementById('status').textContent='Clicked'\">Click me</a>",
-  "<ul>",
-  ...Array.from({ length: 20 }, (_, i) => `<li class='item'>Item ${i + 1}</li>`),
-  "</ul>",
-  "</body></html>",
-].join("");
-
-const INJECT_FORM_SCRIPT = `document.open(); document.write(${JSON.stringify(FORM_HTML)}); document.close(); 'ok'`;
-
-const SETUP_PAGE: string[][] = [
-  ["open", "about:blank"],
-  ["eval", INJECT_FORM_SCRIPT],
-];
-
-export const scenarios: Scenario[] = [
-  {
-    name: "navigate",
-    description: "Page navigation (about:blank round-trip)",
-    commands: [["open", "about:blank"]],
-  },
-  {
-    name: "snapshot",
-    description: "DOM snapshot (accessibility tree)",
-    setup: SETUP_PAGE,
-    commands: [["snapshot"]],
-  },
-  {
-    name: "screenshot",
-    description: "Screenshot capture",
-    setup: SETUP_PAGE,
-    commands: [["screenshot"]],
-  },
-  {
-    name: "evaluate",
-    description: "JavaScript evaluation",
-    setup: SETUP_PAGE,
-    commands: [
-      [
-        "eval",
-        "document.title + ' ' + document.querySelectorAll('li').length",
-      ],
-    ],
-  },
-  {
-    name: "click",
-    description: "Element click interaction",
-    setup: SETUP_PAGE,
-    commands: [["click", "#link"]],
-  },
-  {
-    name: "fill",
-    description: "Form field fill",
-    setup: SETUP_PAGE,
-    commands: [["fill", "#name", "Benchmark User"]],
-  },
-  {
-    name: "agent-loop",
-    description: "AI agent loop: snapshot -> click -> snapshot (typical agent cycle)",
-    setup: SETUP_PAGE,
-    commands: [["snapshot"], ["click", "#link"], ["snapshot"]],
-  },
-  {
-    name: "full-workflow",
-    description:
-      "Realistic workflow: navigate, inject form, snapshot, click, fill, evaluate, screenshot",
-    commands: [
-      ["open", "about:blank"],
-      ["eval", INJECT_FORM_SCRIPT],
-      ["snapshot"],
-      ["click", "#link"],
-      ["fill", "#name", "Agent User"],
-      [
-        "eval",
-        "document.getElementById('name').value",
-      ],
-      ["screenshot"],
-    ],
-  },
-];

benchmarks/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "dist",
-    "declaration": true
-  },
-  "include": ["*.ts"]
-}

bin/agent-browser.js

@@ -8,7 +8,7 @@
  * binary directly (zero overhead).
  */
 
-import { spawn, execSync } from 'child_process';
+import { spawn } from 'child_process';
 import { existsSync, accessSync, chmodSync, constants } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
@@ -16,17 +16,6 @@ import { platform, arch } from 'os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// Detect if the system uses musl libc (e.g. Alpine Linux)
-function isMusl() {
-  if (platform() !== 'linux') return false;
-  try {
-    const result = execSync('ldd --version 2>&1 || true', { encoding: 'utf8' });
-    return result.toLowerCase().includes('musl');
-  } catch {
-    return existsSync('/lib/ld-musl-x86_64.so.1') || existsSync('/lib/ld-musl-aarch64.so.1');
-  }
-}
-
 // Map Node.js platform/arch to binary naming convention
 function getBinaryName() {
   const os = platform();
@@ -38,7 +27,7 @@ function getBinaryName() {
       osKey = 'darwin';
       break;
     case 'linux':
-      osKey = isMusl() ? 'linux-musl' : 'linux';
+      osKey = 'linux';
       break;
     case 'win32':
       osKey = 'win32';

cli/Cargo.lock

@@ -44,18 +44,15 @@ dependencies = [
 ]
 
 [[package]]
-name = "agent-browser"
-version = "0.24.0"
+name = "agent-browser-stealth"
+version = "0.16.1-fork.0"
 dependencies = [
  "aes-gcm",
  "async-trait",
  "base64",
- "chrono",
  "dirs",
  "futures-util",
  "getrandom 0.2.17",
- "hex",
- "hmac",
  "image",
  "libc",
  "reqwest",
@@ -63,15 +60,11 @@ dependencies = [
  "serde_json",
  "sha2",
  "similar",
- "socket2",
- "time",
  "tokio",
  "tokio-tungstenite",
  "url",
- "urlencoding",
  "uuid",
  "windows-sys 0.52.0",
- "zip",
 ]
 
 [[package]]
@@ -92,15 +85,6 @@ dependencies = [
  "equator",
 ]
 
-[[package]]
-name = "android_system_properties"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "anyhow"
 version = "1.0.102"
@@ -301,19 +285,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
-[[package]]
-name = "chrono"
-version = "0.4.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
-dependencies = [
- "iana-time-zone",
- "js-sys",
- "num-traits",
- "wasm-bindgen",
- "windows-link",
-]
-
 [[package]]
 name = "cipher"
 version = "0.4.4"
@@ -330,12 +301,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
-
 [[package]]
 name = "core2"
 version = "0.4.0"
@@ -420,15 +385,6 @@ version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
 
-[[package]]
-name = "deranged"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
-dependencies = [
- "powerfmt",
-]
-
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -437,7 +393,6 @@ checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer",
  "crypto-common",
- "subtle",
 ]
 
 [[package]]
@@ -572,7 +527,6 @@ checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
- "zlib-rs",
 ]
 
 [[package]]
@@ -674,20 +628,20 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
  "wasip2",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
 dependencies = [
  "cfg-if",
  "libc",
- "r-efi",
+ "r-efi 6.0.0",
  "wasip2",
  "wasip3",
 ]
@@ -744,21 +698,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -833,7 +772,7 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots 1.0.5",
+ "webpki-roots 1.0.6",
 ]
 
 [[package]]
@@ -859,30 +798,6 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "iana-time-zone"
-version = "0.1.65"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
-dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "iana-time-zone-haiku",
- "js-sys",
- "log",
- "wasm-bindgen",
- "windows-core",
-]
-
-[[package]]
-name = "iana-time-zone-haiku"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "icu_collections"
 version = "2.1.1"
@@ -1128,9 +1043,9 @@ checksum = "7a79a3332a6609480d7d0c9eab957bca6b455b91bb84e66d19f5ff66294b85b8"
 
 [[package]]
 name = "libc"
-version = "0.2.180"
+version = "0.2.182"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -1144,11 +1059,10 @@ dependencies = [
 
 [[package]]
 name = "libredox"
-version = "0.1.12"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
+checksum = "1744e39d1d6a9948f4f388969627434e31128196de472883b39f148769bfe30a"
 dependencies = [
- "bitflags",
  "libc",
 ]
 
@@ -1191,9 +1105,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.7.6"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "miniz_oxide"
@@ -1257,12 +1171,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "num-conv"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
-
 [[package]]
 name = "num-derive"
 version = "0.4.2"
@@ -1385,12 +1293,6 @@ dependencies = [
  "zerovec",
 ]
 
-[[package]]
-name = "powerfmt"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
@@ -1412,9 +1314,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.105"
+version = "1.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
 dependencies = [
  "unicode-ident",
 ]
@@ -1516,9 +1418,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.43"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
@@ -1529,6 +1431,12 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -1704,7 +1612,7 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
- "webpki-roots 1.0.5",
+ "webpki-roots 1.0.6",
 ]
 
 [[package]]
@@ -1936,9 +1844,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "2.0.114"
+version = "2.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2019,37 +1927,6 @@ dependencies = [
  "zune-jpeg 0.4.21",
 ]
 
-[[package]]
-name = "time"
-version = "0.3.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
-dependencies = [
- "deranged",
- "itoa",
- "num-conv",
- "powerfmt",
- "serde_core",
- "time-core",
- "time-macros",
-]
-
-[[package]]
-name = "time-core"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
-
-[[package]]
-name = "time-macros"
-version = "0.2.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
-dependencies = [
- "num-conv",
- "time-core",
-]
-
 [[package]]
 name = "tinystr"
 version = "0.8.2"
@@ -2077,9 +1954,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.49.0"
+version = "1.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
 dependencies = [
  "bytes",
  "libc",
@@ -2218,12 +2095,6 @@ dependencies = [
  "utf-8",
 ]
 
-[[package]]
-name = "typed-path"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e28f89b80c87b8fb0cf04ab448d5dd0dd0ade2f8891bae878de66a75a28600e"
-
 [[package]]
 name = "typenum"
 version = "1.19.0"
@@ -2232,9 +2103,9 @@ checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.22"
+version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
 name = "unicode-xid"
@@ -2270,12 +2141,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "urlencoding"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
-
 [[package]]
 name = "utf-8"
 version = "0.7.6"
@@ -2294,7 +2159,7 @@ version = "1.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
 dependencies = [
- "getrandom 0.4.1",
+ "getrandom 0.4.2",
  "js-sys",
  "wasm-bindgen",
 ]
@@ -2468,14 +2333,14 @@ version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "webpki-roots 1.0.5",
+ "webpki-roots 1.0.6",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
+checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -2486,65 +2351,12 @@ version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
 
-[[package]]
-name = "windows-core"
-version = "0.62.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
-dependencies = [
- "windows-implement",
- "windows-interface",
- "windows-link",
- "windows-result",
- "windows-strings",
-]
-
-[[package]]
-name = "windows-implement"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "windows-interface"
-version = "0.59.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
-[[package]]
-name = "windows-result"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -2970,43 +2782,11 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "zip"
-version = "8.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b680f2a0cd479b4cff6e1233c483fdead418106eae419dc60200ae9850f6d004"
-dependencies = [
- "crc32fast",
- "flate2",
- "indexmap",
- "memchr",
- "typed-path",
- "zopfli",
-]
-
-[[package]]
-name = "zlib-rs"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513"
-
 [[package]]
 name = "zmij"
-version = "1.0.12"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fc5a66a20078bf1251bde995aa2fdcc4b800c70b5d92dd2c62abc5c60f679f8"
-
-[[package]]
-name = "zopfli"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
-dependencies = [
- "bumpalo",
- "crc32fast",
- "log",
- "simd-adler32",
-]
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
 
 [[package]]
 name = "zune-core"

cli/Cargo.toml

@@ -1,14 +1,17 @@
 [package]
-name = "agent-browser"
-version = "0.24.0"
+name = "agent-browser-stealth"
+version = "0.16.1-fork.1"
 edition = "2021"
-description = "Fast browser automation CLI for AI agents"
+description = "Stealth browser automation CLI for AI agents with anti-bot evasions"
 license = "Apache-2.0"
-repository = "https://github.com/vercel-labs/agent-browser"
-homepage = "https://agent-browser.dev"
-readme = "../README.md"
-keywords = ["browser", "automation", "ai", "cdp", "chrome"]
-categories = ["command-line-utilities", "web-programming"]
+
+[[bin]]
+name = "agent-browser"
+path = "src/main.rs"
+
+[[bin]]
+name = "agent-browser-stealth"
+path = "src/main_stealth.rs"
 
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
@@ -16,7 +19,7 @@ serde_json = "1.0"
 dirs = "5.0"
 base64 = "0.22"
 getrandom = "0.2"
-tokio = { version = "1", features = ["rt-multi-thread", "macros", "net", "io-util", "time", "sync", "signal", "process"] }
+tokio = { version = "1", features = ["rt-multi-thread", "macros", "net", "io-util", "time", "sync", "signal"] }
 tokio-tungstenite = { version = "0.24", features = ["rustls-tls-webpki-roots"] }
 futures-util = "0.3"
 url = "2"
@@ -26,14 +29,7 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "rus
 sha2 = "0.10"
 aes-gcm = "0.10"
 async-trait = "0.1"
-socket2 = "0.6"
 similar = "2"
-zip = { version = "8.2.0", default-features = false, features = ["deflate"] }
-time = { version = "0.3", features = ["formatting"] }
-hmac = "0.12"
-hex = "0.4"
-chrono = "0.4"
-urlencoding = "2"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"

cli/build.rs

@@ -175,7 +175,7 @@ fn to_snake_case(s: &str) -> String {
             // Only insert underscore at transitions from lowercase to uppercase,
             // or when an uppercase sequence ends (e.g. "DOM" -> "dom", not "d_o_m")
             let prev_upper = chars[i - 1].is_uppercase();
-            let next_lower = chars.get(i + 1).is_some_and(|n| n.is_lowercase());
+            let next_lower = chars.get(i + 1).map_or(false, |n| n.is_lowercase());
             if !prev_upper || next_lower {
                 result.push('_');
             }
@@ -202,7 +202,7 @@ fn resolve_ref(
             // Check if this type actually exists in the referenced domain
             if domain_types
                 .get(ref_domain)
-                .is_some_and(|t| t.contains(ref_type))
+                .map_or(false, |t| t.contains(ref_type))
             {
                 format!(
                     "super::cdp_{}::{}",
@@ -339,7 +339,7 @@ fn generate_domain(
                 if variant == "Self" {
                     variant = "SelfValue".to_string();
                 }
-                if variant.chars().next().is_some_and(|c| c.is_ascii_digit()) {
+                if variant.chars().next().map_or(false, |c| c.is_ascii_digit()) {
                     variant = format!("V{}", variant);
                 }
                 if seen_variants.insert(variant.clone()) {

cli/src/connection.rs

@@ -26,8 +26,6 @@ pub struct Response {
     pub success: bool,
     pub data: Option<Value>,
     pub error: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub warning: Option<String>,
 }
 
 #[allow(dead_code)]
@@ -120,10 +118,14 @@ fn get_pid_path(session: &str) -> PathBuf {
 
 /// Clean up stale socket and PID files for a session
 fn cleanup_stale_files(session: &str) {
+    // Never delete files for a live daemon. A missing PID file can happen in
+    // race scenarios, but the socket is authoritative for liveness.
+    if daemon_ready(session) {
+        return;
+    }
+
     let pid_path = get_pid_path(session);
     let _ = fs::remove_file(&pid_path);
-    let stream_path = get_socket_dir().join(format!("{}.stream", session));
-    let _ = fs::remove_file(&stream_path);
 
     #[cfg(unix)]
     {
@@ -144,7 +146,7 @@ fn get_port_path(session: &str) -> PathBuf {
 }
 
 #[cfg(windows)]
-pub fn get_port_for_session(session: &str) -> u16 {
+fn get_port_for_session(session: &str) -> u16 {
     let mut hash: i32 = 0;
     for c in session.chars() {
         hash = ((hash << 5).wrapping_sub(hash)).wrapping_add(c as i32);
@@ -154,19 +156,7 @@ pub fn get_port_for_session(session: &str) -> u16 {
     49152 + ((hash.unsigned_abs() as u32 % 16383) as u16)
 }
 
-/// Read the actual daemon port from the `.port` file written by the daemon.
-/// Falls back to the hash-derived port if the file does not exist or is
-/// unreadable (e.g. daemon has not started yet).
-#[cfg(windows)]
-pub fn resolve_port(session: &str) -> u16 {
-    let port_path = get_port_path(session);
-    fs::read_to_string(&port_path)
-        .ok()
-        .and_then(|s| s.trim().parse::<u16>().ok())
-        .unwrap_or_else(|| get_port_for_session(session))
-}
-
-pub fn daemon_ready(session: &str) -> bool {
+fn daemon_ready(session: &str) -> bool {
     #[cfg(unix)]
     {
         let socket_path = get_socket_path(session);
@@ -174,7 +164,7 @@ pub fn daemon_ready(session: &str) -> bool {
     }
     #[cfg(windows)]
     {
-        let port = resolve_port(session);
+        let port = get_port_for_session(session);
         TcpStream::connect_timeout(
             &format!("127.0.0.1:{}", port).parse().unwrap(),
             Duration::from_millis(50),
@@ -189,127 +179,29 @@ pub struct DaemonResult {
     pub already_running: bool,
 }
 
-/// Options forwarded to the daemon process as environment variables.
-/// Note: `confirm_interactive` is intentionally absent -- it is a CLI-side
-/// UX concern (prompting the user on stdin) and not a daemon configuration.
-/// The daemon only needs `confirm_actions` to gate action categories.
-pub struct DaemonOptions<'a> {
-    pub headed: bool,
-    pub debug: bool,
-    pub executable_path: Option<&'a str>,
-    pub extensions: &'a [String],
-    pub args: Option<&'a str>,
-    pub user_agent: Option<&'a str>,
-    pub proxy: Option<&'a str>,
-    pub proxy_bypass: Option<&'a str>,
-    pub proxy_username: Option<&'a str>,
-    pub proxy_password: Option<&'a str>,
-    pub ignore_https_errors: bool,
-    pub allow_file_access: bool,
-    pub profile: Option<&'a str>,
-    pub state: Option<&'a str>,
-    pub provider: Option<&'a str>,
-    pub device: Option<&'a str>,
-    pub session_name: Option<&'a str>,
-    pub download_path: Option<&'a str>,
-    pub allowed_domains: Option<&'a [String]>,
-    pub action_policy: Option<&'a str>,
-    pub confirm_actions: Option<&'a str>,
-    pub engine: Option<&'a str>,
-    pub auto_connect: bool,
-    pub idle_timeout: Option<&'a str>,
-    pub cdp: Option<&'a str>,
-    pub no_auto_dialog: bool,
-}
-
-fn apply_daemon_env(cmd: &mut Command, session: &str, opts: &DaemonOptions) {
-    cmd.env("AGENT_BROWSER_DAEMON", "1")
-        .env("AGENT_BROWSER_SESSION", session);
-
-    if opts.headed {
-        cmd.env("AGENT_BROWSER_HEADED", "1");
-    }
-    if opts.debug {
-        cmd.env("AGENT_BROWSER_DEBUG", "1");
-    }
-    if let Some(path) = opts.executable_path {
-        cmd.env("AGENT_BROWSER_EXECUTABLE_PATH", path);
-    }
-    if !opts.extensions.is_empty() {
-        cmd.env("AGENT_BROWSER_EXTENSIONS", opts.extensions.join(","));
-    }
-    if let Some(a) = opts.args {
-        cmd.env("AGENT_BROWSER_ARGS", a);
-    }
-    if let Some(ua) = opts.user_agent {
-        cmd.env("AGENT_BROWSER_USER_AGENT", ua);
-    }
-    if let Some(p) = opts.proxy {
-        cmd.env("AGENT_BROWSER_PROXY", p);
-    }
-    if let Some(pb) = opts.proxy_bypass {
-        cmd.env("AGENT_BROWSER_PROXY_BYPASS", pb);
-    }
-    if let Some(pu) = opts.proxy_username {
-        cmd.env("AGENT_BROWSER_PROXY_USERNAME", pu);
-    }
-    if let Some(pp) = opts.proxy_password {
-        cmd.env("AGENT_BROWSER_PROXY_PASSWORD", pp);
-    }
-    if opts.ignore_https_errors {
-        cmd.env("AGENT_BROWSER_IGNORE_HTTPS_ERRORS", "1");
-    }
-    if opts.allow_file_access {
-        cmd.env("AGENT_BROWSER_ALLOW_FILE_ACCESS", "1");
-    }
-    if let Some(prof) = opts.profile {
-        cmd.env("AGENT_BROWSER_PROFILE", prof);
-    }
-    if let Some(st) = opts.state {
-        cmd.env("AGENT_BROWSER_STATE", st);
-    }
-    if let Some(p) = opts.provider {
-        cmd.env("AGENT_BROWSER_PROVIDER", p);
-    }
-    if let Some(d) = opts.device {
-        cmd.env("AGENT_BROWSER_IOS_DEVICE", d);
-    }
-    if let Some(sn) = opts.session_name {
-        cmd.env("AGENT_BROWSER_SESSION_NAME", sn);
-    }
-    if let Some(dp) = opts.download_path {
-        cmd.env("AGENT_BROWSER_DOWNLOAD_PATH", dp);
-    }
-    if let Some(ad) = opts.allowed_domains {
-        cmd.env("AGENT_BROWSER_ALLOWED_DOMAINS", ad.join(","));
-    }
-    if let Some(ap) = opts.action_policy {
-        cmd.env("AGENT_BROWSER_ACTION_POLICY", ap);
-    }
-    if let Some(ca) = opts.confirm_actions {
-        cmd.env("AGENT_BROWSER_CONFIRM_ACTIONS", ca);
-    }
-    if let Some(engine) = opts.engine {
-        cmd.env("AGENT_BROWSER_ENGINE", engine);
-    }
-    if opts.auto_connect {
-        cmd.env("AGENT_BROWSER_AUTO_CONNECT", "1");
-    }
-    if let Some(idle) = opts.idle_timeout {
-        cmd.env("AGENT_BROWSER_IDLE_TIMEOUT_MS", idle);
-    }
-    if let Some(cdp) = opts.cdp {
-        cmd.env("AGENT_BROWSER_CDP", cdp);
-    }
-    if opts.no_auto_dialog {
-        cmd.env("AGENT_BROWSER_NO_AUTO_DIALOG", "1");
-    }
-}
-
-pub fn ensure_daemon(session: &str, opts: &DaemonOptions) -> Result<DaemonResult, String> {
-    // Socket connectivity is the sole liveness check — no PID check — so
-    // callers in a different PID namespace (e.g. unshare) can still reuse
-    // an existing daemon they can reach over the socket.
+#[allow(clippy::too_many_arguments)]
+pub fn ensure_daemon(
+    session: &str,
+    headed: bool,
+    executable_path: Option<&str>,
+    extensions: &[String],
+    args: Option<&str>,
+    user_agent: Option<&str>,
+    proxy: Option<&str>,
+    proxy_bypass: Option<&str>,
+    ignore_https_errors: bool,
+    allow_file_access: bool,
+    state: Option<&str>,
+    provider: Option<&str>,
+    device: Option<&str>,
+    session_name: Option<&str>,
+    debug: bool,
+    download_path: Option<&str>,
+    tab_group: Option<&str>,
+    tab_group_plugin_id: Option<&str>,
+) -> Result<DaemonResult, String> {
+    // Socket readiness is the source of truth for a usable daemon.
+    // PID files can be missing/stale under concurrent start/stop races.
     if daemon_ready(session) {
         // Double-check it's actually responsive by waiting and checking again
         // This handles the race condition where daemon is shutting down
@@ -364,54 +256,207 @@ pub fn ensure_daemon(session: &str, opts: &DaemonOptions) -> Result<DaemonResult
     }
 
     let exe_path = env::current_exe().map_err(|e| e.to_string())?;
+    // Canonicalize to resolve symlinks (e.g., npm global bin symlink -> actual binary)
     let exe_path = exe_path.canonicalize().unwrap_or(exe_path);
+    let exe_dir = exe_path.parent().unwrap();
 
-    #[allow(unused_assignments)]
-    let mut daemon_child: Option<std::process::Child> = None;
+    let mut daemon_paths = vec![
+        exe_dir.join("daemon.js"),
+        exe_dir.join("../dist/daemon.js"),
+        PathBuf::from("dist/daemon.js"),
+    ];
 
+    // Check AGENT_BROWSER_HOME environment variable
+    if let Ok(home) = env::var("AGENT_BROWSER_HOME") {
+        let home_path = PathBuf::from(&home);
+        daemon_paths.insert(0, home_path.join("dist/daemon.js"));
+        daemon_paths.insert(1, home_path.join("daemon.js"));
+    }
+
+    let daemon_path = daemon_paths
+        .iter()
+        .find(|p| p.exists())
+        .ok_or("Daemon not found. Set AGENT_BROWSER_HOME environment variable or run from project directory.")?;
+
+    // Spawn daemon as a fully detached background process
     #[cfg(unix)]
     {
         use std::os::unix::process::CommandExt;
 
-        let mut cmd = Command::new(&exe_path);
-        cmd.env("AGENT_BROWSER_DAEMON", "1");
-        apply_daemon_env(&mut cmd, session, opts);
+        let mut cmd = Command::new("node");
+        cmd.arg(daemon_path)
+            .env("AGENT_BROWSER_DAEMON", "1")
+            .env("AGENT_BROWSER_SESSION", session);
 
+        if headed {
+            cmd.env("AGENT_BROWSER_HEADED", "1");
+        }
+
+        if let Some(path) = executable_path {
+            cmd.env("AGENT_BROWSER_EXECUTABLE_PATH", path);
+        }
+
+        if !extensions.is_empty() {
+            cmd.env("AGENT_BROWSER_EXTENSIONS", extensions.join(","));
+        }
+
+        if let Some(a) = args {
+            cmd.env("AGENT_BROWSER_ARGS", a);
+        }
+
+        if let Some(ua) = user_agent {
+            cmd.env("AGENT_BROWSER_USER_AGENT", ua);
+        }
+
+        if let Some(p) = proxy {
+            cmd.env("AGENT_BROWSER_PROXY", p);
+        }
+
+        if let Some(pb) = proxy_bypass {
+            cmd.env("AGENT_BROWSER_PROXY_BYPASS", pb);
+        }
+
+        if ignore_https_errors {
+            cmd.env("AGENT_BROWSER_IGNORE_HTTPS_ERRORS", "1");
+        }
+
+        if allow_file_access {
+            cmd.env("AGENT_BROWSER_ALLOW_FILE_ACCESS", "1");
+        }
+
+        if let Some(st) = state {
+            cmd.env("AGENT_BROWSER_STATE", st);
+        }
+
+        if let Some(p) = provider {
+            cmd.env("AGENT_BROWSER_PROVIDER", p);
+        }
+
+        if let Some(d) = device {
+            cmd.env("AGENT_BROWSER_IOS_DEVICE", d);
+        }
+
+        if let Some(sn) = session_name {
+            cmd.env("AGENT_BROWSER_SESSION_NAME", sn);
+        }
+
+        cmd.env("AGENT_BROWSER_STEALTH", "1");
+        if debug {
+            cmd.env("AGENT_BROWSER_DEBUG", "1");
+        }
+        if let Some(dp) = download_path {
+            cmd.env("AGENT_BROWSER_DOWNLOAD_PATH", dp);
+        }
+        if let Some(tg) = tab_group {
+            cmd.env("AGENT_BROWSER_TAB_GROUP", tg);
+        }
+        if let Some(plugin_id) = tab_group_plugin_id {
+            cmd.env("AGENT_BROWSER_TAB_GROUP_PLUGIN_ID", plugin_id);
+        }
+
+        // Create new process group and session to fully detach
         unsafe {
             cmd.pre_exec(|| {
+                // Create new session (detach from terminal)
                 libc::setsid();
                 Ok(())
             });
         }
 
-        daemon_child = Some(
-            cmd.stdin(Stdio::null())
-                .stdout(Stdio::null())
-                .stderr(Stdio::piped())
-                .spawn()
-                .map_err(|e| format!("Failed to start daemon: {}", e))?,
-        );
+        cmd.stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null());
+        cmd.spawn()
+            .map_err(|e| format!("Failed to start daemon: {}", e))?;
     }
 
     #[cfg(windows)]
     {
         use std::os::windows::process::CommandExt;
 
-        let mut cmd = Command::new(&exe_path);
-        cmd.env("AGENT_BROWSER_DAEMON", "1");
-        apply_daemon_env(&mut cmd, session, opts);
+        // On Windows, call node directly. Command::new handles PATH resolution (node.exe or node.cmd)
+        // and automatically quotes arguments containing spaces.
+        let mut cmd = Command::new("node");
+        cmd.arg(daemon_path)
+            .env("AGENT_BROWSER_DAEMON", "1")
+            .env("AGENT_BROWSER_SESSION", session);
 
+        if headed {
+            cmd.env("AGENT_BROWSER_HEADED", "1");
+        }
+
+        if let Some(path) = executable_path {
+            cmd.env("AGENT_BROWSER_EXECUTABLE_PATH", path);
+        }
+
+        if !extensions.is_empty() {
+            cmd.env("AGENT_BROWSER_EXTENSIONS", extensions.join(","));
+        }
+
+        if let Some(a) = args {
+            cmd.env("AGENT_BROWSER_ARGS", a);
+        }
+
+        if let Some(ua) = user_agent {
+            cmd.env("AGENT_BROWSER_USER_AGENT", ua);
+        }
+
+        if let Some(p) = proxy {
+            cmd.env("AGENT_BROWSER_PROXY", p);
+        }
+
+        if let Some(pb) = proxy_bypass {
+            cmd.env("AGENT_BROWSER_PROXY_BYPASS", pb);
+        }
+
+        if ignore_https_errors {
+            cmd.env("AGENT_BROWSER_IGNORE_HTTPS_ERRORS", "1");
+        }
+
+        if allow_file_access {
+            cmd.env("AGENT_BROWSER_ALLOW_FILE_ACCESS", "1");
+        }
+
+        if let Some(st) = state {
+            cmd.env("AGENT_BROWSER_STATE", st);
+        }
+
+        if let Some(p) = provider {
+            cmd.env("AGENT_BROWSER_PROVIDER", p);
+        }
+
+        if let Some(d) = device {
+            cmd.env("AGENT_BROWSER_IOS_DEVICE", d);
+        }
+
+        if let Some(sn) = session_name {
+            cmd.env("AGENT_BROWSER_SESSION_NAME", sn);
+        }
+
+        cmd.env("AGENT_BROWSER_STEALTH", "1");
+        if debug {
+            cmd.env("AGENT_BROWSER_DEBUG", "1");
+        }
+        if let Some(dp) = download_path {
+            cmd.env("AGENT_BROWSER_DOWNLOAD_PATH", dp);
+        }
+        if let Some(tg) = tab_group {
+            cmd.env("AGENT_BROWSER_TAB_GROUP", tg);
+        }
+        if let Some(plugin_id) = tab_group_plugin_id {
+            cmd.env("AGENT_BROWSER_TAB_GROUP_PLUGIN_ID", plugin_id);
+        }
+
+        // CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS
         const CREATE_NEW_PROCESS_GROUP: u32 = 0x00000200;
         const DETACHED_PROCESS: u32 = 0x00000008;
 
-        daemon_child = Some(
-            cmd.creation_flags(CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS)
-                .stdin(Stdio::null())
-                .stdout(Stdio::null())
-                .stderr(Stdio::piped())
-                .spawn()
-                .map_err(|e| format!("Failed to start daemon: {}", e))?,
-        );
+        cmd.creation_flags(CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS)
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null());
+        cmd.spawn()
+            .map_err(|e| format!("Failed to start daemon: {}", e))?;
     }
 
     for _ in 0..50 {
@@ -420,47 +465,13 @@ pub fn ensure_daemon(session: &str, opts: &DaemonOptions) -> Result<DaemonResult
                 already_running: false,
             });
         }
-
-        // Detect early daemon exit and surface the real error from stderr
-        if let Some(ref mut child) = daemon_child {
-            if let Ok(Some(_)) = child.try_wait() {
-                let mut stderr_output = String::new();
-                if let Some(mut stderr) = child.stderr.take() {
-                    let _ = stderr.read_to_string(&mut stderr_output);
-                }
-                let stderr_trimmed = stderr_output.trim();
-                if !stderr_trimmed.is_empty() {
-                    let msg = if stderr_trimmed.len() > 500 {
-                        let mut end = 500;
-                        while !stderr_trimmed.is_char_boundary(end) {
-                            end -= 1;
-                        }
-                        &stderr_trimmed[..end]
-                    } else {
-                        stderr_trimmed
-                    };
-                    return Err(format!("Daemon process exited during startup:\n{}", msg));
-                }
-                return Err(
-                    "Daemon process exited during startup with no error output. \
-                     Re-run with --debug for more details."
-                        .to_string(),
-                );
-            }
-        }
-
         thread::sleep(Duration::from_millis(100));
     }
 
-    #[cfg(unix)]
-    let endpoint_info = format!(
-        "socket: {}",
+    Err(format!(
+        "Daemon failed to start (socket: {})",
         get_socket_dir().join(format!("{}.sock", session)).display()
-    );
-    #[cfg(windows)]
-    let endpoint_info = format!("port: 127.0.0.1:{}", resolve_port(session));
-
-    Err(format!("Daemon failed to start ({})", endpoint_info))
+    ))
 }
 
 fn connect(session: &str) -> Result<Connection, String> {
@@ -473,7 +484,7 @@ fn connect(session: &str) -> Result<Connection, String> {
     }
     #[cfg(windows)]
     {
-        let port = resolve_port(session);
+        let port = get_port_for_session(session);
         TcpStream::connect(format!("127.0.0.1:{}", port))
             .map(Connection::Tcp)
             .map_err(|e| format!("Failed to connect: {}", e))
@@ -531,8 +542,6 @@ fn is_transient_error(error: &str) -> bool {
         || error.contains("os error 2") // No such file or directory (socket gone)
         || error.contains("os error 61") // Connection refused (macOS)
         || error.contains("os error 111") // Connection refused (Linux)
-        || error.contains("os error 10061") // Connection refused (Windows)
-        || error.contains("os error 10054") // Connection reset by peer (Windows)
 }
 
 fn send_command_once(cmd: &Value, session: &str) -> Result<Response, String> {
@@ -560,14 +569,45 @@ fn send_command_once(cmd: &Value, session: &str) -> Result<Response, String> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::EnvGuard;
+    use std::sync::{Mutex, MutexGuard};
+
+    // Mutex to prevent parallel tests from interfering with env vars
+    static ENV_MUTEX: Mutex<()> = Mutex::new(());
+
+    /// RAII guard that locks env mutex and restores env vars on drop
+    struct EnvGuard<'a> {
+        _lock: MutexGuard<'a, ()>,
+        vars: Vec<(String, Option<String>)>,
+    }
+
+    impl<'a> EnvGuard<'a> {
+        fn new(var_names: &[&str]) -> Self {
+            let lock = ENV_MUTEX.lock().unwrap();
+            let vars = var_names
+                .iter()
+                .map(|&name| (name.to_string(), env::var(name).ok()))
+                .collect();
+            Self { _lock: lock, vars }
+        }
+    }
+
+    impl Drop for EnvGuard<'_> {
+        fn drop(&mut self) {
+            for (name, value) in &self.vars {
+                match value {
+                    Some(v) => env::set_var(name, v),
+                    None => env::remove_var(name),
+                }
+            }
+        }
+    }
 
     #[test]
     fn test_get_socket_dir_explicit_override() {
         let _guard = EnvGuard::new(&["AGENT_BROWSER_SOCKET_DIR", "XDG_RUNTIME_DIR"]);
 
-        _guard.set("AGENT_BROWSER_SOCKET_DIR", "/custom/socket/path");
-        _guard.remove("XDG_RUNTIME_DIR");
+        env::set_var("AGENT_BROWSER_SOCKET_DIR", "/custom/socket/path");
+        env::remove_var("XDG_RUNTIME_DIR");
 
         assert_eq!(get_socket_dir(), PathBuf::from("/custom/socket/path"));
     }
@@ -576,8 +616,8 @@ mod tests {
     fn test_get_socket_dir_ignores_empty_socket_dir() {
         let _guard = EnvGuard::new(&["AGENT_BROWSER_SOCKET_DIR", "XDG_RUNTIME_DIR"]);
 
-        _guard.set("AGENT_BROWSER_SOCKET_DIR", "");
-        _guard.remove("XDG_RUNTIME_DIR");
+        env::set_var("AGENT_BROWSER_SOCKET_DIR", "");
+        env::remove_var("XDG_RUNTIME_DIR");
 
         assert!(get_socket_dir()
             .to_string_lossy()
@@ -588,8 +628,8 @@ mod tests {
     fn test_get_socket_dir_xdg_runtime() {
         let _guard = EnvGuard::new(&["AGENT_BROWSER_SOCKET_DIR", "XDG_RUNTIME_DIR"]);
 
-        _guard.remove("AGENT_BROWSER_SOCKET_DIR");
-        _guard.set("XDG_RUNTIME_DIR", "/run/user/1000");
+        env::remove_var("AGENT_BROWSER_SOCKET_DIR");
+        env::set_var("XDG_RUNTIME_DIR", "/run/user/1000");
 
         assert_eq!(
             get_socket_dir(),
@@ -601,8 +641,8 @@ mod tests {
     fn test_get_socket_dir_ignores_empty_xdg_runtime() {
         let _guard = EnvGuard::new(&["AGENT_BROWSER_SOCKET_DIR", "XDG_RUNTIME_DIR"]);
 
-        _guard.set("AGENT_BROWSER_SOCKET_DIR", "");
-        _guard.set("XDG_RUNTIME_DIR", "");
+        env::set_var("AGENT_BROWSER_SOCKET_DIR", "");
+        env::set_var("XDG_RUNTIME_DIR", "");
 
         assert!(get_socket_dir()
             .to_string_lossy()
@@ -613,8 +653,8 @@ mod tests {
     fn test_get_socket_dir_home_fallback() {
         let _guard = EnvGuard::new(&["AGENT_BROWSER_SOCKET_DIR", "XDG_RUNTIME_DIR"]);
 
-        _guard.remove("AGENT_BROWSER_SOCKET_DIR");
-        _guard.remove("XDG_RUNTIME_DIR");
+        env::remove_var("AGENT_BROWSER_SOCKET_DIR");
+        env::remove_var("XDG_RUNTIME_DIR");
 
         let result = get_socket_dir();
         assert!(result.to_string_lossy().ends_with(".agent-browser"));
@@ -708,20 +748,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn test_is_transient_error_connection_refused_windows() {
-        assert!(is_transient_error(
-            "Failed to connect: No connection could be made because the target machine actively refused it. (os error 10061)"
-        ));
-    }
-
-    #[test]
-    fn test_is_transient_error_connection_reset_windows() {
-        assert!(is_transient_error(
-            "Failed to send: An existing connection was forcibly closed by the remote host. (os error 10054)"
-        ));
-    }
-
     #[test]
     fn test_is_transient_error_non_transient() {
         // These should NOT be considered transient
@@ -730,13 +756,4 @@ mod tests {
         assert!(!is_transient_error("Permission denied"));
         assert!(!is_transient_error("Daemon not found"));
     }
-
-    #[test]
-    #[cfg(windows)]
-    fn test_get_port_for_session() {
-        assert_eq!(get_port_for_session("default"), 50838);
-        assert_eq!(get_port_for_session("my-session"), 63105);
-        assert_eq!(get_port_for_session("work"), 51184);
-        assert_eq!(get_port_for_session(""), 49152);
-    }
 }

cli/src/flags.rs

@@ -1,4 +1,4 @@
-use crate::color;
+use crate::{color, validation};
 use serde::Deserialize;
 use std::env;
 use std::fs;
@@ -7,60 +7,20 @@ use std::path::{Path, PathBuf};
 const CONFIG_DIR: &str = ".agent-browser";
 const CONFIG_FILENAME: &str = "config.json";
 const PROJECT_CONFIG_FILENAME: &str = "agent-browser.json";
-
-/// Parse idle timeout from user-friendly format.
-/// Supports: "10s" (seconds), "3m" (minutes), "1h" (hours), or raw milliseconds.
-fn parse_idle_timeout(s: &str) -> Result<String, String> {
-    let s = s.trim();
-    if s.is_empty() {
-        return Err("Empty idle timeout".to_string());
-    }
-
-    // If the value ends with a unit suffix, convert it to milliseconds.
-    if s.chars().last().is_some_and(|c| c.is_ascii_alphabetic()) {
-        let (num_str, unit) = s.split_at(s.len() - 1);
-        let num: u64 = num_str.parse().map_err(|_| "Invalid number")?;
-
-        let ms = match unit {
-            "s" => num * 1000,
-            "m" => num * 60 * 1000,
-            "h" => num * 60 * 60 * 1000,
-            _ => return Err("Invalid idle timeout unit (use s, m, h, or raw ms)".to_string()),
-        };
-        return Ok(ms.to_string());
-    }
-
-    // Pure numbers are already expressed in milliseconds.
-    s.parse::<u64>().map_err(|_| "Invalid idle timeout")?;
-    Ok(s.to_string())
-}
-
-fn parse_idle_timeout_value(value: Option<String>, source: &str) -> Option<String> {
-    value.and_then(|raw| match parse_idle_timeout(&raw) {
-        Ok(ms) => Some(ms),
-        Err(e) => {
-            eprintln!(
-                "{} invalid idle timeout from {}: {}",
-                color::warning_indicator(),
-                source,
-                e
-            );
-            None
-        }
-    })
-}
+const DEFAULT_TAB_GROUP: &str = "Agent Browser Stealth";
+const DEFAULT_TAB_GROUP_PLUGIN_ID: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 
 #[derive(Debug, Default, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct Config {
     pub headed: Option<bool>,
     pub json: Option<bool>,
+    pub full: Option<bool>,
     pub debug: Option<bool>,
     pub session: Option<String>,
     pub session_name: Option<String>,
     pub executable_path: Option<String>,
     pub extensions: Option<Vec<String>>,
-    pub profile: Option<String>,
     pub state: Option<String>,
     pub proxy: Option<String>,
     pub proxy_bypass: Option<String>,
@@ -76,18 +36,10 @@ pub struct Config {
     pub annotate: Option<bool>,
     pub color_scheme: Option<String>,
     pub download_path: Option<String>,
-    pub content_boundaries: Option<bool>,
-    pub max_output: Option<usize>,
-    pub allowed_domains: Option<Vec<String>>,
-    pub action_policy: Option<String>,
-    pub confirm_actions: Option<String>,
-    pub confirm_interactive: Option<bool>,
-    pub engine: Option<String>,
-    pub screenshot_dir: Option<String>,
-    pub screenshot_quality: Option<u32>,
-    pub screenshot_format: Option<String>,
-    pub idle_timeout: Option<String>,
-    pub no_auto_dialog: Option<bool>,
+    pub tab_group: Option<String>,
+    pub tab_group_plugin_id: Option<String>,
+    pub risk_mode: Option<String>,
+    pub wait_until: Option<String>,
 }
 
 impl Config {
@@ -95,6 +47,7 @@ impl Config {
         Config {
             headed: other.headed.or(self.headed),
             json: other.json.or(self.json),
+            full: other.full.or(self.full),
             debug: other.debug.or(self.debug),
             session: other.session.or(self.session),
             session_name: other.session_name.or(self.session_name),
@@ -106,7 +59,6 @@ impl Config {
                 }
                 (a, b) => b.or(a),
             },
-            profile: other.profile.or(self.profile),
             state: other.state.or(self.state),
             proxy: other.proxy.or(self.proxy),
             proxy_bypass: other.proxy_bypass.or(self.proxy_bypass),
@@ -122,18 +74,10 @@ impl Config {
             annotate: other.annotate.or(self.annotate),
             color_scheme: other.color_scheme.or(self.color_scheme),
             download_path: other.download_path.or(self.download_path),
-            content_boundaries: other.content_boundaries.or(self.content_boundaries),
-            max_output: other.max_output.or(self.max_output),
-            allowed_domains: other.allowed_domains.or(self.allowed_domains),
-            action_policy: other.action_policy.or(self.action_policy),
-            confirm_actions: other.confirm_actions.or(self.confirm_actions),
-            confirm_interactive: other.confirm_interactive.or(self.confirm_interactive),
-            engine: other.engine.or(self.engine),
-            screenshot_dir: other.screenshot_dir.or(self.screenshot_dir),
-            screenshot_quality: other.screenshot_quality.or(self.screenshot_quality),
-            screenshot_format: other.screenshot_format.or(self.screenshot_format),
-            idle_timeout: other.idle_timeout.or(self.idle_timeout),
-            no_auto_dialog: other.no_auto_dialog.or(self.no_auto_dialog),
+            tab_group: other.tab_group.or(self.tab_group),
+            tab_group_plugin_id: other.tab_group_plugin_id.or(self.tab_group_plugin_id),
+            risk_mode: other.risk_mode.or(self.risk_mode),
+            wait_until: other.wait_until.or(self.wait_until),
         }
     }
 }
@@ -141,13 +85,7 @@ impl Config {
 fn read_config_file(path: &Path) -> Option<Config> {
     let content = fs::read_to_string(path).ok()?;
     match serde_json::from_str::<Config>(&content) {
-        Ok(mut config) => {
-            config.idle_timeout = parse_idle_timeout_value(
-                config.idle_timeout.take(),
-                &format!("config file {}", path.display()),
-            );
-            Some(config)
-        }
+        Ok(config) => Some(config),
         Err(e) => {
             eprintln!(
                 "{} invalid config file {}: {}",
@@ -186,11 +124,6 @@ fn parse_bool_arg(args: &[String], i: usize) -> (bool, bool) {
 /// Extract --config <path> from args before full flag parsing.
 /// Returns `Some(Some(path))` if --config <path> found, `Some(None)` if --config
 /// was the last arg with no value, `None` if --config not present.
-///
-/// Only flags that consume a following argument need to be listed here.
-/// Boolean flags (--content-boundaries, --confirm-interactive, etc.) are
-/// intentionally absent -- they don't take a value, so they can't cause
-/// the next argument to be mis-consumed.
 fn extract_config_path(args: &[String]) -> Option<Option<String>> {
     const FLAGS_WITH_VALUE: &[&str] = &[
         "--session",
@@ -209,16 +142,12 @@ fn extract_config_path(args: &[String]) -> Option<Option<String>> {
         "--device",
         "--session-name",
         "--color-scheme",
+        "--channel",
         "--download-path",
-        "--max-output",
-        "--allowed-domains",
-        "--action-policy",
-        "--confirm-actions",
-        "--engine",
-        "--screenshot-dir",
-        "--screenshot-quality",
-        "--screenshot-format",
-        "--idle-timeout",
+        "--tab-group",
+        "--tab-group-plugin-id",
+        "--risk-mode",
+        "--wait-until",
     ];
     let mut i = 0;
     while i < args.len() {
@@ -267,6 +196,7 @@ pub fn load_config(args: &[String]) -> Result<Config, String> {
 
 pub struct Flags {
     pub json: bool,
+    pub full: bool,
     pub headed: bool,
     pub debug: bool,
     pub session: String,
@@ -274,7 +204,6 @@ pub struct Flags {
     pub executable_path: Option<String>,
     pub cdp: Option<String>,
     pub extensions: Vec<String>,
-    pub profile: Option<String>,
     pub state: Option<String>,
     pub proxy: Option<String>,
     pub proxy_bypass: Option<String>,
@@ -285,28 +214,23 @@ pub struct Flags {
     pub allow_file_access: bool,
     pub device: Option<String>,
     pub auto_connect: bool,
-    pub session_name: Option<String>,
+    pub session_name: Option<String>, // Defaults to --session when unset
     pub annotate: bool,
     pub color_scheme: Option<String>,
     pub download_path: Option<String>,
-    pub content_boundaries: bool,
-    pub max_output: Option<usize>,
-    pub allowed_domains: Option<Vec<String>>,
-    pub action_policy: Option<String>,
-    pub confirm_actions: Option<String>,
-    pub confirm_interactive: bool,
-    pub engine: Option<String>,
-    pub screenshot_dir: Option<String>,
-    pub screenshot_quality: Option<u32>,
-    pub screenshot_format: Option<String>,
-    pub idle_timeout: Option<String>, // Canonical milliseconds string for AGENT_BROWSER_IDLE_TIMEOUT_MS
-    pub no_auto_dialog: bool,
+    pub tab_group: Option<String>,
+    pub tab_group_plugin_id: Option<String>,
+    /// How verification/captcha detections are handled on navigation:
+    /// `off` (disable), `warn` (retry and warn), `block` (fail fast).
+    pub risk_mode: Option<String>,
+    /// Navigation wait strategy passed to navigate/open commands:
+    /// `load`, `domcontentloaded`, or `networkidle`.
+    pub wait_until: Option<String>,
 
     // Track which launch-time options were explicitly passed via CLI
     // (as opposed to being set only via environment variables)
     pub cli_executable_path: bool,
     pub cli_extensions: bool,
-    pub cli_profile: bool,
     pub cli_state: bool,
     pub cli_args: bool,
     pub cli_user_agent: bool,
@@ -315,7 +239,8 @@ pub struct Flags {
     pub cli_allow_file_access: bool,
     pub cli_annotate: bool,
     pub cli_download_path: bool,
-    pub cli_headed: bool,
+    pub cli_tab_group: bool,
+    pub cli_tab_group_plugin_id: bool,
 }
 
 pub fn parse_flags(args: &[String]) -> Flags {
@@ -342,7 +267,11 @@ pub fn parse_flags(args: &[String]) -> Flags {
 
     let mut flags = Flags {
         json: env_var_is_truthy("AGENT_BROWSER_JSON") || config.json.unwrap_or(false),
-        headed: env_var_is_truthy("AGENT_BROWSER_HEADED") || config.headed.unwrap_or(false),
+        full: env_var_is_truthy("AGENT_BROWSER_FULL") || config.full.unwrap_or(false),
+        headed: match env::var("AGENT_BROWSER_HEADED") {
+            Ok(val) => !matches!(val.to_lowercase().as_str(), "0" | "false" | "no" | ""),
+            Err(_) => config.headed.unwrap_or(true),
+        },
         debug: env_var_is_truthy("AGENT_BROWSER_DEBUG") || config.debug.unwrap_or(false),
         session: env::var("AGENT_BROWSER_SESSION")
             .ok()
@@ -354,22 +283,11 @@ pub fn parse_flags(args: &[String]) -> Flags {
             .or(config.executable_path),
         cdp: config.cdp,
         extensions,
-        profile: env::var("AGENT_BROWSER_PROFILE").ok().or(config.profile),
         state: env::var("AGENT_BROWSER_STATE").ok().or(config.state),
-        proxy: env::var("AGENT_BROWSER_PROXY")
-            .ok()
-            .or(config.proxy)
-            .or_else(|| env::var("HTTP_PROXY").ok())
-            .or_else(|| env::var("http_proxy").ok())
-            .or_else(|| env::var("HTTPS_PROXY").ok())
-            .or_else(|| env::var("https_proxy").ok())
-            .or_else(|| env::var("ALL_PROXY").ok())
-            .or_else(|| env::var("all_proxy").ok()),
+        proxy: env::var("AGENT_BROWSER_PROXY").ok().or(config.proxy),
         proxy_bypass: env::var("AGENT_BROWSER_PROXY_BYPASS")
             .ok()
-            .or(config.proxy_bypass)
-            .or_else(|| env::var("NO_PROXY").ok())
-            .or_else(|| env::var("no_proxy").ok()),
+            .or(config.proxy_bypass),
         args: env::var("AGENT_BROWSER_ARGS").ok().or(config.args),
         user_agent: env::var("AGENT_BROWSER_USER_AGENT")
             .ok()
@@ -392,51 +310,21 @@ pub fn parse_flags(args: &[String]) -> Flags {
         download_path: env::var("AGENT_BROWSER_DOWNLOAD_PATH")
             .ok()
             .or(config.download_path),
-        content_boundaries: env_var_is_truthy("AGENT_BROWSER_CONTENT_BOUNDARIES")
-            || config.content_boundaries.unwrap_or(false),
-        max_output: env::var("AGENT_BROWSER_MAX_OUTPUT")
+        tab_group: env::var("AGENT_BROWSER_TAB_GROUP")
             .ok()
-            .and_then(|s| s.parse().ok())
-            .or(config.max_output),
-        allowed_domains: env::var("AGENT_BROWSER_ALLOWED_DOMAINS")
+            .or(config.tab_group)
+            .or_else(|| Some(DEFAULT_TAB_GROUP.to_string())),
+        tab_group_plugin_id: env::var("AGENT_BROWSER_TAB_GROUP_PLUGIN_ID")
             .ok()
-            .map(|s| {
-                s.split(',')
-                    .map(|d| d.trim().to_lowercase())
-                    .filter(|d| !d.is_empty())
-                    .collect()
-            })
-            .or(config.allowed_domains),
-        action_policy: env::var("AGENT_BROWSER_ACTION_POLICY")
+            .or(config.tab_group_plugin_id)
+            .or_else(|| Some(DEFAULT_TAB_GROUP_PLUGIN_ID.to_string())),
+        risk_mode: env::var("AGENT_BROWSER_RISK_MODE")
             .ok()
-            .or(config.action_policy),
-        confirm_actions: env::var("AGENT_BROWSER_CONFIRM_ACTIONS")
-            .ok()
-            .or(config.confirm_actions),
-        confirm_interactive: env_var_is_truthy("AGENT_BROWSER_CONFIRM_INTERACTIVE")
-            || config.confirm_interactive.unwrap_or(false),
-        engine: env::var("AGENT_BROWSER_ENGINE").ok().or(config.engine),
-        screenshot_dir: env::var("AGENT_BROWSER_SCREENSHOT_DIR")
-            .ok()
-            .or(config.screenshot_dir),
-        screenshot_quality: env::var("AGENT_BROWSER_SCREENSHOT_QUALITY")
-            .ok()
-            .and_then(|s| s.parse().ok())
-            .or(config.screenshot_quality),
-        screenshot_format: env::var("AGENT_BROWSER_SCREENSHOT_FORMAT")
-            .ok()
-            .or(config.screenshot_format)
-            .filter(|s| s == "png" || s == "jpeg"),
-        idle_timeout: parse_idle_timeout_value(
-            env::var("AGENT_BROWSER_IDLE_TIMEOUT_MS").ok(),
-            "AGENT_BROWSER_IDLE_TIMEOUT_MS",
-        )
-        .or(config.idle_timeout),
-        no_auto_dialog: env_var_is_truthy("AGENT_BROWSER_NO_AUTO_DIALOG")
-            || config.no_auto_dialog.unwrap_or(false),
+            .or(config.risk_mode)
+            .map(|s| s.to_ascii_lowercase()),
+        wait_until: config.wait_until.map(|s| s.to_ascii_lowercase()),
         cli_executable_path: false,
         cli_extensions: false,
-        cli_profile: false,
         cli_state: false,
         cli_args: false,
         cli_user_agent: false,
@@ -445,7 +333,8 @@ pub fn parse_flags(args: &[String]) -> Flags {
         cli_allow_file_access: false,
         cli_annotate: false,
         cli_download_path: false,
-        cli_headed: false,
+        cli_tab_group: false,
+        cli_tab_group_plugin_id: false,
     };
 
     let mut i = 0;
@@ -458,10 +347,16 @@ pub fn parse_flags(args: &[String]) -> Flags {
                     i += 1;
                 }
             }
+            "--full" | "-f" => {
+                let (val, consumed) = parse_bool_arg(args, i);
+                flags.full = val;
+                if consumed {
+                    i += 1;
+                }
+            }
             "--headed" => {
                 let (val, consumed) = parse_bool_arg(args, i);
                 flags.headed = val;
-                flags.cli_headed = true;
                 if consumed {
                     i += 1;
                 }
@@ -479,19 +374,6 @@ pub fn parse_flags(args: &[String]) -> Flags {
                     i += 1;
                 }
             }
-            "--idle-timeout" => {
-                if let Some(s) = args.get(i + 1) {
-                    match parse_idle_timeout(s) {
-                        Ok(ms) => flags.idle_timeout = Some(ms),
-                        Err(e) => eprintln!(
-                            "{} Invalid --idle-timeout: {}",
-                            color::warning_indicator(),
-                            e
-                        ),
-                    }
-                    i += 1;
-                }
-            }
             "--headers" => {
                 if let Some(h) = args.get(i + 1) {
                     flags.headers = Some(h.clone());
@@ -518,13 +400,6 @@ pub fn parse_flags(args: &[String]) -> Flags {
                     i += 1;
                 }
             }
-            "--profile" => {
-                if let Some(s) = args.get(i + 1) {
-                    flags.profile = Some(s.clone());
-                    flags.cli_profile = true;
-                    i += 1;
-                }
-            }
             "--state" => {
                 if let Some(s) = args.get(i + 1) {
                     flags.state = Some(s.clone());
@@ -621,97 +496,29 @@ pub fn parse_flags(args: &[String]) -> Flags {
                     i += 1;
                 }
             }
-            "--content-boundaries" => {
-                let (val, consumed) = parse_bool_arg(args, i);
-                flags.content_boundaries = val;
-                if consumed {
-                    i += 1;
-                }
-            }
-            "--max-output" => {
+            "--tab-group" => {
                 if let Some(s) = args.get(i + 1) {
-                    if let Ok(n) = s.parse::<usize>() {
-                        flags.max_output = Some(n);
-                    }
+                    flags.tab_group = Some(s.clone());
+                    flags.cli_tab_group = true;
                     i += 1;
                 }
             }
-            "--allowed-domains" => {
+            "--tab-group-plugin-id" => {
                 if let Some(s) = args.get(i + 1) {
-                    flags.allowed_domains = Some(
-                        s.split(',')
-                            .map(|d| d.trim().to_lowercase())
-                            .filter(|d| !d.is_empty())
-                            .collect(),
-                    );
+                    flags.tab_group_plugin_id = Some(s.clone());
+                    flags.cli_tab_group_plugin_id = true;
                     i += 1;
                 }
             }
-            "--action-policy" => {
+            "--risk-mode" => {
                 if let Some(s) = args.get(i + 1) {
-                    flags.action_policy = Some(s.clone());
+                    flags.risk_mode = Some(s.to_ascii_lowercase());
                     i += 1;
                 }
             }
-            "--confirm-actions" => {
+            "--wait-until" => {
                 if let Some(s) = args.get(i + 1) {
-                    flags.confirm_actions = Some(s.clone());
-                    i += 1;
-                }
-            }
-            "--confirm-interactive" => {
-                let (val, consumed) = parse_bool_arg(args, i);
-                flags.confirm_interactive = val;
-                if consumed {
-                    i += 1;
-                }
-            }
-            "--engine" => {
-                if let Some(s) = args.get(i + 1) {
-                    flags.engine = Some(s.clone());
-                    i += 1;
-                }
-            }
-            "--screenshot-dir" => {
-                if let Some(s) = args.get(i + 1) {
-                    flags.screenshot_dir = Some(s.clone());
-                    i += 1;
-                }
-            }
-            "--screenshot-quality" => {
-                if let Some(s) = args.get(i + 1) {
-                    if let Ok(n) = s.parse::<u32>() {
-                        if n <= 100 {
-                            flags.screenshot_quality = Some(n);
-                        } else {
-                            eprintln!(
-                                "{} --screenshot-quality must be 0-100, got {}",
-                                color::warning_indicator(),
-                                n
-                            );
-                        }
-                    }
-                    i += 1;
-                }
-            }
-            "--screenshot-format" => {
-                if let Some(s) = args.get(i + 1) {
-                    if s == "png" || s == "jpeg" {
-                        flags.screenshot_format = Some(s.clone());
-                    } else {
-                        eprintln!(
-                            "{} --screenshot-format must be png or jpeg, got '{}'",
-                            color::warning_indicator(),
-                            s
-                        );
-                    }
-                    i += 1;
-                }
-            }
-            "--no-auto-dialog" => {
-                let (val, consumed) = parse_bool_arg(args, i);
-                flags.no_auto_dialog = val;
-                if consumed {
+                    flags.wait_until = Some(s.to_ascii_lowercase());
                     i += 1;
                 }
             }
@@ -723,6 +530,18 @@ pub fn parse_flags(args: &[String]) -> Flags {
         }
         i += 1;
     }
+
+    // Keep auth/state continuity stable by default: if no explicit --session-name
+    // is provided, derive it from --session (or fall back to "default" when invalid).
+    if flags.session_name.is_none() {
+        let derived = if validation::is_valid_session_name(&flags.session) {
+            flags.session.clone()
+        } else {
+            "default".to_string()
+        };
+        flags.session_name = Some(derived);
+    }
+
     flags
 }
 
@@ -733,15 +552,13 @@ pub fn clean_args(args: &[String]) -> Vec<String> {
     // Boolean flags that optionally take true/false
     const GLOBAL_BOOL_FLAGS: &[&str] = &[
         "--json",
+        "--full",
         "--headed",
         "--debug",
         "--ignore-https-errors",
         "--allow-file-access",
         "--auto-connect",
         "--annotate",
-        "--content-boundaries",
-        "--confirm-interactive",
-        "--no-auto-dialog",
     ];
     // Global flags that always take a value (need to skip the next arg too)
     const GLOBAL_FLAGS_WITH_VALUE: &[&str] = &[
@@ -750,7 +567,6 @@ pub fn clean_args(args: &[String]) -> Vec<String> {
         "--executable-path",
         "--cdp",
         "--extension",
-        "--profile",
         "--state",
         "--proxy",
         "--proxy-bypass",
@@ -762,16 +578,11 @@ pub fn clean_args(args: &[String]) -> Vec<String> {
         "--session-name",
         "--color-scheme",
         "--download-path",
-        "--max-output",
-        "--allowed-domains",
-        "--action-policy",
-        "--confirm-actions",
+        "--tab-group",
+        "--tab-group-plugin-id",
+        "--risk-mode",
+        "--wait-until",
         "--config",
-        "--engine",
-        "--screenshot-dir",
-        "--screenshot-quality",
-        "--screenshot-format",
-        "--idle-timeout",
     ];
 
     let mut i = 0;
@@ -787,7 +598,7 @@ pub fn clean_args(args: &[String]) -> Vec<String> {
             i += 1;
             continue;
         }
-        if GLOBAL_BOOL_FLAGS.contains(&arg.as_str()) {
+        if GLOBAL_BOOL_FLAGS.contains(&arg.as_str()) || arg == "-f" {
             if let Some(v) = args.get(i + 1) {
                 if matches!(v.as_str(), "true" | "false") {
                     i += 1;
@@ -805,6 +616,36 @@ pub fn clean_args(args: &[String]) -> Vec<String> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::sync::{Mutex, MutexGuard};
+
+    static ENV_MUTEX: Mutex<()> = Mutex::new(());
+
+    struct EnvGuard<'a> {
+        _lock: MutexGuard<'a, ()>,
+        vars: Vec<(String, Option<String>)>,
+    }
+
+    impl<'a> EnvGuard<'a> {
+        fn new(var_names: &[&str]) -> Self {
+            let lock = ENV_MUTEX.lock().unwrap();
+            let vars = var_names
+                .iter()
+                .map(|&name| (name.to_string(), env::var(name).ok()))
+                .collect();
+            Self { _lock: lock, vars }
+        }
+    }
+
+    impl Drop for EnvGuard<'_> {
+        fn drop(&mut self) {
+            for (name, value) in &self.vars {
+                match value {
+                    Some(v) => env::set_var(name, v),
+                    None => env::remove_var(name),
+                }
+            }
+        }
+    }
 
     fn args(s: &str) -> Vec<String> {
         s.split_whitespace().map(String::from).collect()
@@ -816,36 +657,6 @@ mod tests {
         assert_eq!(flags.headers, Some(r#"{"Auth":"token"}"#.to_string()));
     }
 
-    #[test]
-    fn test_parse_idle_timeout_raw_ms() {
-        assert_eq!(parse_idle_timeout("10").unwrap(), "10");
-    }
-
-    #[test]
-    fn test_parse_idle_timeout_seconds() {
-        assert_eq!(parse_idle_timeout("10s").unwrap(), "10000");
-    }
-
-    #[test]
-    fn test_parse_idle_timeout_minutes() {
-        assert_eq!(parse_idle_timeout("3m").unwrap(), "180000");
-    }
-
-    #[test]
-    fn test_parse_idle_timeout_hours() {
-        assert_eq!(parse_idle_timeout("1h").unwrap(), "3600000");
-    }
-
-    #[test]
-    fn test_parse_idle_timeout_rejects_capital_m() {
-        assert!(parse_idle_timeout("10M").is_err());
-    }
-
-    #[test]
-    fn test_parse_idle_timeout_rejects_unknown_unit() {
-        assert!(parse_idle_timeout("10x").is_err());
-    }
-
     #[test]
     fn test_parse_headers_flag_with_spaces() {
         // Headers JSON is passed as a single quoted argument in shell
@@ -941,18 +752,6 @@ mod tests {
         assert_eq!(cleaned, vec!["open", "example.com"]);
     }
 
-    #[test]
-    fn test_clean_args_removes_idle_timeout_before_command() {
-        let cleaned = clean_args(&args("--idle-timeout 10s open example.com"));
-        assert_eq!(cleaned, vec!["open", "example.com"]);
-    }
-
-    #[test]
-    fn test_parse_idle_timeout_flag_converts_to_ms() {
-        let flags = parse_flags(&args("--idle-timeout 10s open example.com"));
-        assert_eq!(flags.idle_timeout.as_deref(), Some("10000"));
-    }
-
     #[test]
     fn test_parse_flags_with_session_and_executable_path() {
         let flags = parse_flags(&args(
@@ -960,6 +759,19 @@ mod tests {
         ));
         assert_eq!(flags.session, "test");
         assert_eq!(flags.executable_path, Some("/custom/chrome".to_string()));
+        assert_eq!(flags.session_name.as_deref(), Some("test"));
+    }
+
+    #[test]
+    fn test_session_name_defaults_to_session_when_not_provided() {
+        let flags = parse_flags(&args("--session my-session snapshot"));
+        assert_eq!(flags.session_name.as_deref(), Some("my-session"));
+    }
+
+    #[test]
+    fn test_invalid_session_falls_back_to_default_session_name() {
+        let flags = parse_flags(&args("--session bad/session snapshot"));
+        assert_eq!(flags.session_name.as_deref(), Some("default"));
     }
 
     #[test]
@@ -984,12 +796,6 @@ mod tests {
         assert!(flags.cli_extensions);
     }
 
-    #[test]
-    fn test_cli_profile_tracking() {
-        let flags = parse_flags(&args("--profile /path/to/profile snapshot"));
-        assert!(flags.cli_profile);
-    }
-
     #[test]
     fn test_cli_annotate_tracking() {
         let flags = parse_flags(&args("--annotate screenshot"));
@@ -1016,13 +822,134 @@ mod tests {
         assert!(!flags.cli_download_path);
     }
 
+    #[test]
+    fn test_default_tab_group_is_enabled() {
+        let flags = parse_flags(&args("snapshot"));
+        assert_eq!(flags.tab_group.as_deref(), Some(DEFAULT_TAB_GROUP));
+        assert!(!flags.cli_tab_group);
+    }
+
+    #[test]
+    fn test_default_tab_group_plugin_id_is_enabled() {
+        let flags = parse_flags(&args("snapshot"));
+        assert_eq!(
+            flags.tab_group_plugin_id.as_deref(),
+            Some(DEFAULT_TAB_GROUP_PLUGIN_ID)
+        );
+        assert!(!flags.cli_tab_group_plugin_id);
+    }
+
+    #[test]
+    fn test_parse_tab_group_flag() {
+        let input = vec![
+            "--tab-group".to_string(),
+            "Agent Browser Stealth".to_string(),
+            "snapshot".to_string(),
+        ];
+        let flags = parse_flags(&input);
+        assert_eq!(flags.tab_group.as_deref(), Some("Agent Browser Stealth"));
+        assert!(flags.cli_tab_group);
+    }
+
+    #[test]
+    fn test_clean_args_removes_tab_group() {
+        let cleaned = clean_args(&args("--tab-group AgentGroup open example.com"));
+        assert_eq!(cleaned, vec!["open", "example.com"]);
+    }
+
+    #[test]
+    fn test_parse_tab_group_plugin_id_flag() {
+        let input = vec![
+            "--tab-group-plugin-id".to_string(),
+            "cli-plugin-id".to_string(),
+            "snapshot".to_string(),
+        ];
+        let flags = parse_flags(&input);
+        assert_eq!(flags.tab_group_plugin_id.as_deref(), Some("cli-plugin-id"));
+        assert!(flags.cli_tab_group_plugin_id);
+    }
+
+    #[test]
+    fn test_clean_args_removes_tab_group_plugin_id() {
+        let cleaned = clean_args(&args(
+            "--tab-group-plugin-id cli-plugin-id open example.com",
+        ));
+        assert_eq!(cleaned, vec!["open", "example.com"]);
+    }
+
+    #[test]
+    fn test_tab_group_plugin_id_precedence_config_env_cli() {
+        use std::io::Write;
+
+        let _guard = EnvGuard::new(&["AGENT_BROWSER_TAB_GROUP_PLUGIN_ID"]);
+
+        let dir = std::env::temp_dir().join("ab-test-plugin-id-precedence");
+        let _ = fs::create_dir_all(&dir);
+        let config_path = dir.join("config.json");
+        let mut f = fs::File::create(&config_path).unwrap();
+        writeln!(f, r#"{{"tabGroupPluginId":"config-plugin-id"}}"#).unwrap();
+
+        env::set_var("AGENT_BROWSER_TAB_GROUP_PLUGIN_ID", "env-plugin-id");
+
+        let env_args = vec![
+            "--config".to_string(),
+            config_path.to_string_lossy().to_string(),
+            "snapshot".to_string(),
+        ];
+        let flags_from_env = parse_flags(&env_args);
+        assert_eq!(
+            flags_from_env.tab_group_plugin_id.as_deref(),
+            Some("env-plugin-id")
+        );
+
+        let cli_args = vec![
+            "--config".to_string(),
+            config_path.to_string_lossy().to_string(),
+            "--tab-group-plugin-id".to_string(),
+            "cli-plugin-id".to_string(),
+            "snapshot".to_string(),
+        ];
+        let flags_from_cli = parse_flags(&cli_args);
+        assert_eq!(
+            flags_from_cli.tab_group_plugin_id.as_deref(),
+            Some("cli-plugin-id")
+        );
+        assert!(flags_from_cli.cli_tab_group_plugin_id);
+
+        let _ = fs::remove_file(&config_path);
+        let _ = fs::remove_dir(&dir);
+    }
+
+    #[test]
+    fn test_parse_risk_mode_flag() {
+        let flags = parse_flags(&args("--risk-mode block open example.com"));
+        assert_eq!(flags.risk_mode.as_deref(), Some("block"));
+    }
+
+    #[test]
+    fn test_clean_args_removes_risk_mode() {
+        let cleaned = clean_args(&args("--risk-mode warn open example.com"));
+        assert_eq!(cleaned, vec!["open", "example.com"]);
+    }
+
+    #[test]
+    fn test_parse_wait_until_flag() {
+        let flags = parse_flags(&args("--wait-until domcontentloaded open example.com"));
+        assert_eq!(flags.wait_until.as_deref(), Some("domcontentloaded"));
+    }
+
+    #[test]
+    fn test_clean_args_removes_wait_until() {
+        let cleaned = clean_args(&args("--wait-until networkidle open example.com"));
+        assert_eq!(cleaned, vec!["open", "example.com"]);
+    }
+
     #[test]
     fn test_cli_multiple_flags_tracking() {
         let flags = parse_flags(&args(
-            "--executable-path /chrome --profile /profile --proxy http://proxy snapshot",
+            "--executable-path /chrome --proxy http://proxy snapshot",
         ));
         assert!(flags.cli_executable_path);
-        assert!(flags.cli_profile);
         assert!(flags.cli_proxy);
         assert!(!flags.cli_extensions);
         assert!(!flags.cli_state);
@@ -1035,12 +962,12 @@ mod tests {
         let json = r#"{
             "headed": true,
             "json": true,
+            "full": true,
             "debug": true,
             "session": "test-session",
             "sessionName": "my-app",
             "executablePath": "/usr/bin/chromium",
             "extensions": ["/ext1", "/ext2"],
-            "profile": "/tmp/profile",
             "state": "/tmp/state.json",
             "proxy": "http://proxy:8080",
             "proxyBypass": "localhost",
@@ -1052,11 +979,15 @@ mod tests {
             "allowFileAccess": true,
             "cdp": "9222",
             "autoConnect": true,
-            "headers": "{\"Auth\":\"token\"}"
+            "headers": "{\"Auth\":\"token\"}",
+            "tabGroup": "Agent Browser Stealth",
+            "tabGroupPluginId": "tab-group-plugin-id",
+            "riskMode": "block"
         }"#;
         let config: Config = serde_json::from_str(json).unwrap();
         assert_eq!(config.headed, Some(true));
         assert_eq!(config.json, Some(true));
+        assert_eq!(config.full, Some(true));
         assert_eq!(config.debug, Some(true));
         assert_eq!(config.session.as_deref(), Some("test-session"));
         assert_eq!(config.session_name.as_deref(), Some("my-app"));
@@ -1065,7 +996,6 @@ mod tests {
             config.extensions,
             Some(vec!["/ext1".to_string(), "/ext2".to_string()])
         );
-        assert_eq!(config.profile.as_deref(), Some("/tmp/profile"));
         assert_eq!(config.state.as_deref(), Some("/tmp/state.json"));
         assert_eq!(config.proxy.as_deref(), Some("http://proxy:8080"));
         assert_eq!(config.proxy_bypass.as_deref(), Some("localhost"));
@@ -1078,6 +1008,12 @@ mod tests {
         assert_eq!(config.cdp.as_deref(), Some("9222"));
         assert_eq!(config.auto_connect, Some(true));
         assert_eq!(config.headers.as_deref(), Some("{\"Auth\":\"token\"}"));
+        assert_eq!(config.tab_group.as_deref(), Some("Agent Browser Stealth"));
+        assert_eq!(
+            config.tab_group_plugin_id.as_deref(),
+            Some("tab-group-plugin-id")
+        );
+        assert_eq!(config.risk_mode.as_deref(), Some("block"));
     }
 
     #[test]
@@ -1111,7 +1047,6 @@ mod tests {
         let user = Config {
             headed: Some(true),
             proxy: Some("http://user-proxy:8080".to_string()),
-            profile: Some("/user/profile".to_string()),
             ..Config::default()
         };
         let project = Config {
@@ -1122,7 +1057,6 @@ mod tests {
         let merged = user.merge(project);
         assert_eq!(merged.headed, Some(true)); // kept from user
         assert_eq!(merged.proxy.as_deref(), Some("http://project-proxy:9090")); // overridden by project
-        assert_eq!(merged.profile.as_deref(), Some("/user/profile")); // kept from user
         assert_eq!(merged.debug, Some(true)); // added by project
     }
 
@@ -1156,22 +1090,6 @@ mod tests {
         let _ = fs::remove_dir(&dir);
     }
 
-    #[test]
-    fn test_load_config_from_file_parses_idle_timeout() {
-        use std::io::Write;
-        let dir = std::env::temp_dir().join("ab-test-idle-timeout-config");
-        let _ = fs::create_dir_all(&dir);
-        let config_path = dir.join("test-config.json");
-        let mut f = fs::File::create(&config_path).unwrap();
-        writeln!(f, r#"{{"idleTimeout": "10s"}}"#).unwrap();
-
-        let config = read_config_file(&config_path).unwrap();
-        assert_eq!(config.idle_timeout.as_deref(), Some("10000"));
-
-        let _ = fs::remove_file(&config_path);
-        let _ = fs::remove_dir(&dir);
-    }
-
     #[test]
     fn test_load_config_missing_file_returns_none() {
         let result = read_config_file(&PathBuf::from("/nonexistent/agent-browser.json"));
@@ -1332,6 +1250,36 @@ mod tests {
         assert!(!flags.auto_connect);
     }
 
+    #[test]
+    fn test_full_bare_defaults_true() {
+        let flags = parse_flags(&args("--full open example.com"));
+        assert!(flags.full);
+    }
+
+    #[test]
+    fn test_full_false() {
+        let flags = parse_flags(&args("--full false open example.com"));
+        assert!(!flags.full);
+    }
+
+    #[test]
+    fn test_full_short_flag() {
+        let flags = parse_flags(&args("-f open example.com"));
+        assert!(flags.full);
+    }
+
+    #[test]
+    fn test_clean_args_removes_full_with_value() {
+        let cleaned = clean_args(&args("--full false open example.com"));
+        assert_eq!(cleaned, vec!["open", "example.com"]);
+    }
+
+    #[test]
+    fn test_clean_args_removes_short_full() {
+        let cleaned = clean_args(&args("-f open example.com"));
+        assert_eq!(cleaned, vec!["open", "example.com"]);
+    }
+
     #[test]
     fn test_clean_args_removes_bool_flag_with_value() {
         let cleaned = clean_args(&args("--headed false --debug true open example.com"));
@@ -1388,27 +1336,4 @@ mod tests {
         let merged = user.merge(project);
         assert_eq!(merged.extensions, Some(vec!["/ext2".to_string()]));
     }
-
-    #[test]
-    fn test_no_auto_dialog_flag() {
-        let flags = parse_flags(&args("open example.com --no-auto-dialog"));
-        assert!(flags.no_auto_dialog);
-    }
-
-    #[test]
-    fn test_no_auto_dialog_default_false() {
-        let flags = parse_flags(&args("open example.com"));
-        assert!(!flags.no_auto_dialog);
-    }
-
-    #[test]
-    fn test_clean_args_removes_no_auto_dialog() {
-        let input: Vec<String> = vec![
-            "open".to_string(),
-            "example.com".to_string(),
-            "--no-auto-dialog".to_string(),
-        ];
-        let clean = clean_args(&input);
-        assert_eq!(clean, vec!["open", "example.com"]);
-    }
 }

cli/src/install.rs

@@ -1,416 +1,167 @@
 use crate::color;
-use std::fs;
-use std::io::{self, Write};
-use std::path::{Path, PathBuf};
 use std::process::{exit, Command, Stdio};
 
-const LAST_KNOWN_GOOD_URL: &str =
-    "https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions-with-downloads.json";
-
-pub fn get_browsers_dir() -> PathBuf {
-    dirs::home_dir()
-        .unwrap_or_else(|| PathBuf::from("."))
-        .join(".agent-browser")
-        .join("browsers")
-}
-
-pub fn find_installed_chrome() -> Option<PathBuf> {
-    let browsers_dir = get_browsers_dir();
-    let debug = std::env::var("AGENT_BROWSER_DEBUG").is_ok();
-
-    if debug {
-        let _ = writeln!(
-            io::stderr(),
-            "[chrome-search] home_dir={:?} browsers_dir={}",
-            dirs::home_dir(),
-            browsers_dir.display()
-        );
-    }
-
-    if !browsers_dir.exists() {
-        if debug {
-            let _ = writeln!(io::stderr(), "[chrome-search] browsers_dir does not exist");
-        }
-        return None;
-    }
-
-    let entries = match fs::read_dir(&browsers_dir) {
-        Ok(entries) => entries,
-        Err(e) => {
-            let _ = writeln!(
-                io::stderr(),
-                "Warning: cannot read Chrome cache directory {}: {}",
-                browsers_dir.display(),
-                e
-            );
-            return None;
-        }
-    };
-
-    let mut versions: Vec<_> = entries
-        .filter_map(|e| e.ok())
-        .filter(|e| {
-            let matches = e
-                .file_name()
-                .to_str()
-                .is_some_and(|n| n.starts_with("chrome-"));
-            if debug {
-                let _ = writeln!(
-                    io::stderr(),
-                    "[chrome-search] entry {:?} matches={}",
-                    e.file_name(),
-                    matches
-                );
-            }
-            matches
-        })
-        .collect();
-
-    versions.sort_by_key(|b| std::cmp::Reverse(b.file_name()));
-
-    for entry in versions {
-        let dir = entry.path();
-        if let Some(bin) = chrome_binary_in_dir(&dir) {
-            let exists = bin.exists();
-            if debug {
-                let _ = writeln!(
-                    io::stderr(),
-                    "[chrome-search] candidate {} exists={}",
-                    bin.display(),
-                    exists
-                );
-            }
-            if exists {
-                return Some(bin);
-            }
-        } else if debug {
-            let _ = writeln!(
-                io::stderr(),
-                "[chrome-search] no binary found in {}",
-                dir.display()
-            );
-        }
-    }
-
-    if debug {
-        let _ = writeln!(io::stderr(), "[chrome-search] no installed Chrome found");
-    }
-    None
-}
-
-fn chrome_binary_in_dir(dir: &Path) -> Option<PathBuf> {
-    #[cfg(target_os = "macos")]
-    {
-        let app =
-            dir.join("Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing");
-        if app.exists() {
-            return Some(app);
-        }
-        let inner = dir.join("chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing");
-        if inner.exists() {
-            return Some(inner);
-        }
-        let inner_x64 = dir.join(
-            "chrome-mac-x64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing",
-        );
-        if inner_x64.exists() {
-            return Some(inner_x64);
-        }
-        None
-    }
-
-    #[cfg(target_os = "linux")]
-    {
-        let bin = dir.join("chrome");
-        if bin.exists() {
-            return Some(bin);
-        }
-        let inner = dir.join("chrome-linux64/chrome");
-        if inner.exists() {
-            return Some(inner);
-        }
-        None
-    }
-
-    #[cfg(target_os = "windows")]
-    {
-        let bin = dir.join("chrome.exe");
-        if bin.exists() {
-            return Some(bin);
-        }
-        let inner = dir.join("chrome-win64/chrome.exe");
-        if inner.exists() {
-            return Some(inner);
-        }
-        None
-    }
-
-    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
-    {
-        None
-    }
-}
-
-fn platform_key() -> &'static str {
-    #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
-    {
-        "mac-arm64"
-    }
-    #[cfg(all(target_os = "macos", target_arch = "x86_64"))]
-    {
-        "mac-x64"
-    }
-    #[cfg(all(target_os = "linux", target_arch = "x86_64"))]
-    {
-        "linux64"
-    }
-    #[cfg(all(target_os = "windows", target_arch = "x86_64"))]
-    {
-        "win64"
-    }
-    #[cfg(not(any(
-        all(target_os = "macos", target_arch = "aarch64"),
-        all(target_os = "macos", target_arch = "x86_64"),
-        all(target_os = "linux", target_arch = "x86_64"),
-        all(target_os = "windows", target_arch = "x86_64"),
-    )))]
-    {
-        // Compiles on unsupported platforms (e.g. linux aarch64) so the binary
-        // can still be used for other commands like `connect`. The install path
-        // guards against this at runtime before calling platform_key().
-        panic!("Unsupported platform for Chrome for Testing download")
-    }
-}
-
-async fn fetch_download_url() -> Result<(String, String), String> {
-    let resp = reqwest::get(LAST_KNOWN_GOOD_URL)
-        .await
-        .map_err(|e| format!("Failed to fetch version info: {}", e))?;
-
-    let body: serde_json::Value = resp
-        .json()
-        .await
-        .map_err(|e| format!("Failed to parse version info: {}", e))?;
-
-    let channel = body
-        .get("channels")
-        .and_then(|c| c.get("Stable"))
-        .ok_or("No Stable channel found in version info")?;
-
-    let version = channel
-        .get("version")
-        .and_then(|v| v.as_str())
-        .ok_or("No version string found")?
-        .to_string();
-
-    let platform = platform_key();
-
-    let url = channel
-        .get("downloads")
-        .and_then(|d| d.get("chrome"))
-        .and_then(|c| c.as_array())
-        .and_then(|arr| {
-            arr.iter().find_map(|entry| {
-                if entry.get("platform")?.as_str()? == platform {
-                    Some(entry.get("url")?.as_str()?.to_string())
-                } else {
-                    None
-                }
-            })
-        })
-        .ok_or_else(|| format!("No download URL found for platform: {}", platform))?;
-
-    Ok((version, url))
-}
-
-async fn download_bytes(url: &str) -> Result<Vec<u8>, String> {
-    let resp = reqwest::get(url)
-        .await
-        .map_err(|e| format!("Download failed: {}", e))?;
-
-    let total = resp.content_length();
-    let mut bytes = Vec::new();
-    let mut stream = resp;
-    let mut downloaded: u64 = 0;
-    let mut last_pct: u64 = 0;
-
-    loop {
-        let chunk = stream
-            .chunk()
-            .await
-            .map_err(|e| format!("Download error: {}", e))?;
-        match chunk {
-            Some(data) => {
-                downloaded += data.len() as u64;
-                bytes.extend_from_slice(&data);
-
-                if let Some(total) = total {
-                    let pct = (downloaded * 100) / total;
-                    if pct >= last_pct + 5 {
-                        last_pct = pct;
-                        let mb = downloaded as f64 / 1_048_576.0;
-                        let total_mb = total as f64 / 1_048_576.0;
-                        eprint!("\r  {:.0}/{:.0} MB ({pct}%)", mb, total_mb);
-                        let _ = io::stderr().flush();
-                    }
-                }
-            }
-            None => break,
-        }
-    }
-
-    eprintln!();
-    Ok(bytes)
-}
-
-fn extract_zip(bytes: Vec<u8>, dest: &Path) -> Result<(), String> {
-    fs::create_dir_all(dest).map_err(|e| format!("Failed to create directory: {}", e))?;
-
-    let cursor = io::Cursor::new(bytes);
-    let mut archive =
-        zip::ZipArchive::new(cursor).map_err(|e| format!("Failed to read zip archive: {}", e))?;
-
-    for i in 0..archive.len() {
-        let mut file = archive
-            .by_index(i)
-            .map_err(|e| format!("Failed to read zip entry: {}", e))?;
-
-        let enclosed = match file.enclosed_name() {
-            Some(name) => name.to_owned(),
-            None => continue,
-        };
-        let raw_name = enclosed.to_string_lossy().to_string();
-        // Strip the top-level "chrome-<platform>/" directory from zip entries.
-        // On Windows, enclosed_name() normalizes paths to backslashes, so we
-        // must split on either separator.
-        let rel_path = raw_name
-            .strip_prefix("chrome-")
-            .and_then(|s| s.find(['/', '\\']).map(|i| &s[i + 1..]))
-            .filter(|s| !s.is_empty())
-            .map(|s| s.to_string())
-            .unwrap_or(raw_name.clone());
-
-        if rel_path.is_empty() {
-            continue;
-        }
-
-        let out_path = dest.join(&rel_path);
-
-        // Defense-in-depth: ensure the resolved path is inside dest
-        if !out_path.starts_with(dest) {
-            continue;
-        }
-
-        if file.is_dir() {
-            fs::create_dir_all(&out_path)
-                .map_err(|e| format!("Failed to create dir {}: {}", out_path.display(), e))?;
-        } else {
-            if let Some(parent) = out_path.parent() {
-                fs::create_dir_all(parent).map_err(|e| {
-                    format!("Failed to create parent dir {}: {}", parent.display(), e)
-                })?;
-            }
-            let mut out_file = fs::File::create(&out_path)
-                .map_err(|e| format!("Failed to create file {}: {}", out_path.display(), e))?;
-            io::copy(&mut file, &mut out_file)
-                .map_err(|e| format!("Failed to write {}: {}", out_path.display(), e))?;
-
-            #[cfg(unix)]
-            {
-                use std::os::unix::fs::PermissionsExt;
-                if let Some(mode) = file.unix_mode() {
-                    let _ = fs::set_permissions(&out_path, fs::Permissions::from_mode(mode));
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
 pub fn run_install(with_deps: bool) {
-    if cfg!(all(target_os = "linux", target_arch = "aarch64")) {
-        eprintln!(
-            "{} Chrome for Testing does not provide Linux ARM64 builds.",
-            color::error_indicator()
-        );
-        eprintln!("  Install Chromium from your system package manager instead:");
-        eprintln!("    sudo apt install chromium-browser   # Debian/Ubuntu");
-        eprintln!("    sudo dnf install chromium            # Fedora");
-        eprintln!("  Then use: agent-browser --executable-path /usr/bin/chromium");
-        exit(1);
-    }
-
     let is_linux = cfg!(target_os = "linux");
 
     if is_linux {
         if with_deps {
-            install_linux_deps();
+            println!("{}", color::cyan("Installing system dependencies..."));
+
+            let (pkg_mgr, deps) = if which_exists("apt-get") {
+                let libasound = if package_exists_apt("libasound2t64") {
+                    "libasound2t64"
+                } else {
+                    "libasound2"
+                };
+
+                (
+                    "apt-get",
+                    vec![
+                        "libxcb-shm0",
+                        "libx11-xcb1",
+                        "libx11-6",
+                        "libxcb1",
+                        "libxext6",
+                        "libxrandr2",
+                        "libxcomposite1",
+                        "libxcursor1",
+                        "libxdamage1",
+                        "libxfixes3",
+                        "libxi6",
+                        "libgtk-3-0",
+                        "libpangocairo-1.0-0",
+                        "libpango-1.0-0",
+                        "libatk1.0-0",
+                        "libcairo-gobject2",
+                        "libcairo2",
+                        "libgdk-pixbuf-2.0-0",
+                        "libxrender1",
+                        libasound,
+                        "libfreetype6",
+                        "libfontconfig1",
+                        "libdbus-1-3",
+                        "libnss3",
+                        "libnspr4",
+                        "libatk-bridge2.0-0",
+                        "libdrm2",
+                        "libxkbcommon0",
+                        "libatspi2.0-0",
+                        "libcups2",
+                        "libxshmfence1",
+                        "libgbm1",
+                    ],
+                )
+            } else if which_exists("dnf") {
+                (
+                    "dnf",
+                    vec![
+                        "nss",
+                        "nspr",
+                        "atk",
+                        "at-spi2-atk",
+                        "cups-libs",
+                        "libdrm",
+                        "libXcomposite",
+                        "libXdamage",
+                        "libXrandr",
+                        "mesa-libgbm",
+                        "pango",
+                        "alsa-lib",
+                        "libxkbcommon",
+                        "libxcb",
+                        "libX11-xcb",
+                        "libX11",
+                        "libXext",
+                        "libXcursor",
+                        "libXfixes",
+                        "libXi",
+                        "gtk3",
+                        "cairo-gobject",
+                    ],
+                )
+            } else if which_exists("yum") {
+                (
+                    "yum",
+                    vec![
+                        "nss",
+                        "nspr",
+                        "atk",
+                        "at-spi2-atk",
+                        "cups-libs",
+                        "libdrm",
+                        "libXcomposite",
+                        "libXdamage",
+                        "libXrandr",
+                        "mesa-libgbm",
+                        "pango",
+                        "alsa-lib",
+                        "libxkbcommon",
+                    ],
+                )
+            } else {
+                eprintln!(
+                    "{} No supported package manager found (apt-get, dnf, or yum)",
+                    color::error_indicator()
+                );
+                exit(1);
+            };
+
+            let install_cmd = match pkg_mgr {
+                "apt-get" => {
+                    format!(
+                        "sudo apt-get update && sudo apt-get install -y {}",
+                        deps.join(" ")
+                    )
+                }
+                _ => format!("sudo {} install -y {}", pkg_mgr, deps.join(" ")),
+            };
+
+            println!("Running: {}", install_cmd);
+            let status = Command::new("sh").arg("-c").arg(&install_cmd).status();
+
+            match status {
+                Ok(s) if s.success() => {
+                    println!("{} System dependencies installed", color::success_indicator())
+                }
+                Ok(_) => eprintln!(
+                    "{} Failed to install some dependencies. You may need to run manually with sudo.",
+                    color::warning_indicator()
+                ),
+                Err(e) => eprintln!("{} Could not run install command: {}", color::warning_indicator(), e),
+            }
         } else {
             println!(
                 "{} Linux detected. If browser fails to launch, run:",
                 color::warning_indicator()
             );
             println!("  agent-browser install --with-deps");
+            println!("  or: npx playwright install-deps chromium");
             println!();
         }
     }
 
-    println!("{}", color::cyan("Installing Chrome..."));
+    println!("{}", color::cyan("Installing Chromium browser..."));
 
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .unwrap_or_else(|e| {
-            eprintln!(
-                "{} Failed to create runtime: {}",
-                color::error_indicator(),
-                e
-            );
-            exit(1);
-        });
+    // On Windows, we need to use cmd.exe to run npx because npx is actually npx.cmd
+    // and Command::new() doesn't resolve .cmd files the way the shell does.
+    // Pass the entire command as a single string to /c to handle paths with spaces.
+    #[cfg(windows)]
+    let status = Command::new("cmd")
+        .args(["/c", "npx playwright install chromium"])
+        .status();
 
-    let (version, url) = match rt.block_on(fetch_download_url()) {
-        Ok(v) => v,
-        Err(e) => {
-            eprintln!("{} {}", color::error_indicator(), e);
-            exit(1);
-        }
-    };
+    #[cfg(not(windows))]
+    let status = Command::new("npx")
+        .args(["playwright", "install", "chromium"])
+        .status();
 
-    let dest = get_browsers_dir().join(format!("chrome-{}", version));
-
-    if let Some(bin) = chrome_binary_in_dir(&dest) {
-        if bin.exists() {
+    match status {
+        Ok(s) if s.success() => {
             println!(
-                "{} Chrome {} is already installed",
-                color::success_indicator(),
-                version
+                "{} Chromium installed successfully",
+                color::success_indicator()
             );
-            return;
-        }
-    }
-
-    println!("  Downloading Chrome {} for {}", version, platform_key());
-    println!("  {}", url);
-
-    let bytes = match rt.block_on(download_bytes(&url)) {
-        Ok(b) => b,
-        Err(e) => {
-            eprintln!("{} {}", color::error_indicator(), e);
-            exit(1);
-        }
-    };
-
-    match extract_zip(bytes, &dest) {
-        Ok(()) => {
-            println!(
-                "{} Chrome {} installed successfully",
-                color::success_indicator(),
-                version
-            );
-            println!("  Location: {}", dest.display());
-
             if is_linux && !with_deps {
                 println!();
                 println!(
@@ -420,252 +171,22 @@ pub fn run_install(with_deps: bool) {
                 println!("  agent-browser install --with-deps");
             }
         }
-        Err(e) => {
-            let _ = fs::remove_dir_all(&dest);
-            eprintln!("{} {}", color::error_indicator(), e);
+        Ok(_) => {
+            eprintln!("{} Failed to install browser", color::error_indicator());
+            if is_linux {
+                println!(
+                    "{} Try installing system dependencies first:",
+                    color::yellow("Tip:")
+                );
+                println!("  agent-browser install --with-deps");
+            }
             exit(1);
         }
-    }
-}
-
-fn report_install_status(status: io::Result<std::process::ExitStatus>) {
-    match status {
-        Ok(s) if s.success() => {
-            println!(
-                "{} System dependencies installed",
-                color::success_indicator()
-            )
+        Err(e) => {
+            eprintln!("{} Failed to run npx: {}", color::error_indicator(), e);
+            eprintln!("Make sure Node.js is installed and npx is in your PATH");
+            exit(1);
         }
-        Ok(_) => eprintln!(
-            "{} Failed to install some dependencies. You may need to run manually with sudo.",
-            color::warning_indicator()
-        ),
-        Err(e) => eprintln!(
-            "{} Could not run install command: {}",
-            color::warning_indicator(),
-            e
-        ),
-    }
-}
-
-fn install_linux_deps() {
-    println!("{}", color::cyan("Installing system dependencies..."));
-
-    let (pkg_mgr, deps) = if which_exists("apt-get") {
-        // On Ubuntu 24.04+, many libraries were renamed with a t64 suffix as
-        // part of the 64-bit time_t transition. Using the old names can cause
-        // apt to propose removing hundreds of system packages to resolve
-        // conflicts. We check for the t64 variant first to avoid this.
-        let apt_deps: Vec<&str> = vec![
-            ("libxcb-shm0", None),
-            ("libx11-xcb1", None),
-            ("libx11-6", None),
-            ("libxcb1", None),
-            ("libxext6", None),
-            ("libxrandr2", None),
-            ("libxcomposite1", None),
-            ("libxcursor1", None),
-            ("libxdamage1", None),
-            ("libxfixes3", None),
-            ("libxi6", None),
-            ("libgtk-3-0", Some("libgtk-3-0t64")),
-            ("libpangocairo-1.0-0", Some("libpangocairo-1.0-0t64")),
-            ("libpango-1.0-0", Some("libpango-1.0-0t64")),
-            ("libatk1.0-0", Some("libatk1.0-0t64")),
-            ("libcairo-gobject2", Some("libcairo-gobject2t64")),
-            ("libcairo2", Some("libcairo2t64")),
-            ("libgdk-pixbuf-2.0-0", Some("libgdk-pixbuf-2.0-0t64")),
-            ("libxrender1", None),
-            ("libasound2", Some("libasound2t64")),
-            ("libfreetype6", None),
-            ("libfontconfig1", None),
-            ("libdbus-1-3", Some("libdbus-1-3t64")),
-            ("libnss3", None),
-            ("libnspr4", None),
-            ("libatk-bridge2.0-0", Some("libatk-bridge2.0-0t64")),
-            ("libdrm2", None),
-            ("libxkbcommon0", None),
-            ("libatspi2.0-0", Some("libatspi2.0-0t64")),
-            ("libcups2", Some("libcups2t64")),
-            ("libxshmfence1", None),
-            ("libgbm1", None),
-            // Fonts: without actual font files, pages render with missing glyphs
-            // (tofu). This is especially visible for CJK and emoji characters.
-            ("fonts-noto-color-emoji", None),
-            ("fonts-noto-cjk", None),
-            ("fonts-freefont-ttf", None),
-        ]
-        .into_iter()
-        .map(|(base, t64_variant)| {
-            if let Some(t64) = t64_variant {
-                if package_exists_apt(t64) {
-                    return t64;
-                }
-            }
-            base
-        })
-        .collect();
-
-        ("apt-get", apt_deps)
-    } else if which_exists("dnf") {
-        (
-            "dnf",
-            vec![
-                "nss",
-                "nspr",
-                "atk",
-                "at-spi2-atk",
-                "cups-libs",
-                "libdrm",
-                "libXcomposite",
-                "libXdamage",
-                "libXrandr",
-                "mesa-libgbm",
-                "pango",
-                "alsa-lib",
-                "libxkbcommon",
-                "libxcb",
-                "libX11-xcb",
-                "libX11",
-                "libXext",
-                "libXcursor",
-                "libXfixes",
-                "libXi",
-                "gtk3",
-                "cairo-gobject",
-                // Fonts
-                "google-noto-cjk-fonts",
-                "google-noto-emoji-color-fonts",
-                "liberation-fonts",
-            ],
-        )
-    } else if which_exists("yum") {
-        (
-            "yum",
-            vec![
-                "nss",
-                "nspr",
-                "atk",
-                "at-spi2-atk",
-                "cups-libs",
-                "libdrm",
-                "libXcomposite",
-                "libXdamage",
-                "libXrandr",
-                "mesa-libgbm",
-                "pango",
-                "alsa-lib",
-                "libxkbcommon",
-                // Fonts
-                "google-noto-cjk-fonts",
-                "liberation-fonts",
-            ],
-        )
-    } else {
-        eprintln!(
-            "{} No supported package manager found (apt-get, dnf, or yum)",
-            color::error_indicator()
-        );
-        exit(1);
-    };
-
-    if pkg_mgr == "apt-get" {
-        // Run apt-get update first
-        println!("Running: sudo apt-get update");
-        let update_status = Command::new("sudo").args(["apt-get", "update"]).status();
-
-        match update_status {
-            Ok(s) if !s.success() => {
-                eprintln!(
-                    "{} apt-get update failed. Continuing with existing package lists.",
-                    color::warning_indicator()
-                );
-            }
-            Err(e) => {
-                eprintln!(
-                    "{} Could not run apt-get update: {}",
-                    color::warning_indicator(),
-                    e
-                );
-            }
-            _ => {}
-        }
-
-        // Simulate the install first to detect if apt would remove any
-        // packages. This prevents the catastrophic scenario where installing
-        // these libraries triggers removal of hundreds of system packages
-        // due to dependency conflicts (e.g. on Ubuntu 24.04 with the
-        // t64 transition).
-        println!("Checking for conflicts...");
-        let sim_output = Command::new("sudo")
-            .args(["apt-get", "install", "--simulate"])
-            .args(&deps)
-            .output();
-
-        match sim_output {
-            Ok(output) => {
-                let stdout = String::from_utf8_lossy(&output.stdout);
-                let stderr = String::from_utf8_lossy(&output.stderr);
-                let combined = format!("{}\n{}", stdout, stderr);
-
-                // Count packages that would be removed
-                let removals: Vec<&str> = combined
-                    .lines()
-                    .filter(|line| line.starts_with("Remv "))
-                    .collect();
-
-                if !removals.is_empty() {
-                    eprintln!(
-                        "{} Aborting: apt would remove {} package(s) to install these dependencies.",
-                        color::error_indicator(),
-                        removals.len()
-                    );
-                    eprintln!(
-                        "  This usually means some package names have changed on your system"
-                    );
-                    eprintln!("  (e.g. Ubuntu 24.04 renamed libraries with a t64 suffix).");
-                    eprintln!();
-                    eprintln!("  Packages that would be removed:");
-                    for line in removals.iter().take(20) {
-                        eprintln!("    {}", line);
-                    }
-                    if removals.len() > 20 {
-                        eprintln!("    ... and {} more", removals.len() - 20);
-                    }
-                    eprintln!();
-                    eprintln!("  To install dependencies manually, run:");
-                    eprintln!("    sudo apt-get install {}", deps.join(" "));
-                    eprintln!();
-                    eprintln!("  Review the apt output carefully before confirming.");
-                    exit(1);
-                }
-            }
-            Err(e) => {
-                eprintln!(
-                    "{} Could not simulate install ({}). Proceeding with caution.",
-                    color::warning_indicator(),
-                    e
-                );
-            }
-        }
-
-        // Safe to proceed: no removals detected
-        let install_cmd = format!("sudo apt-get install -y {}", deps.join(" "));
-        println!("Running: {}", install_cmd);
-        let status = Command::new("sudo")
-            .args(["apt-get", "install", "-y"])
-            .args(&deps)
-            .status();
-
-        report_install_status(status);
-    } else {
-        // dnf / yum path — these package managers do not remove packages
-        // during install, so the simulate-first guard is not needed.
-        let install_cmd = format!("sudo {} install -y {}", pkg_mgr, deps.join(" "));
-        println!("Running: {}", install_cmd);
-        let status = Command::new("sh").arg("-c").arg(&install_cmd).status();
-
-        report_install_status(status);
     }
 }
 
@@ -702,124 +223,3 @@ fn package_exists_apt(pkg: &str) -> bool {
         .map(|s| s.success())
         .unwrap_or(false)
 }
-
-// ---------------------------------------------------------------------------
-// Dashboard install
-// ---------------------------------------------------------------------------
-
-pub fn get_dashboard_dir() -> PathBuf {
-    dirs::home_dir()
-        .unwrap_or_else(|| PathBuf::from("."))
-        .join(".agent-browser")
-        .join("dashboard")
-}
-
-const DASHBOARD_VERSION: &str = env!("CARGO_PKG_VERSION");
-
-fn dashboard_download_url() -> String {
-    format!(
-        "https://github.com/vercel-labs/agent-browser/releases/download/v{}/dashboard.zip",
-        DASHBOARD_VERSION
-    )
-}
-
-pub fn run_dashboard_install() {
-    println!("{}", color::cyan("Installing dashboard..."));
-
-    let dest = get_dashboard_dir();
-
-    if dest.join("index.html").exists() {
-        println!(
-            "{} Dashboard is already installed at {}",
-            color::success_indicator(),
-            dest.display()
-        );
-        return;
-    }
-
-    let url = dashboard_download_url();
-    println!("  Downloading dashboard v{}", DASHBOARD_VERSION);
-    println!("  {}", url);
-
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .unwrap_or_else(|e| {
-            eprintln!(
-                "{} Failed to create runtime: {}",
-                color::error_indicator(),
-                e
-            );
-            exit(1);
-        });
-
-    let bytes = match rt.block_on(download_bytes(&url)) {
-        Ok(b) => b,
-        Err(e) => {
-            eprintln!("{} {}", color::error_indicator(), e);
-            eprintln!("  The dashboard may not be available for this version yet.");
-            eprintln!("  You can build it locally: cd packages/dashboard && pnpm build");
-            exit(1);
-        }
-    };
-
-    match extract_dashboard_zip(bytes, &dest) {
-        Ok(()) => {
-            println!(
-                "{} Dashboard v{} installed successfully",
-                color::success_indicator(),
-                DASHBOARD_VERSION
-            );
-            println!("  Location: {}", dest.display());
-        }
-        Err(e) => {
-            let _ = fs::remove_dir_all(&dest);
-            eprintln!("{} {}", color::error_indicator(), e);
-            exit(1);
-        }
-    }
-}
-
-fn extract_dashboard_zip(bytes: Vec<u8>, dest: &Path) -> Result<(), String> {
-    fs::create_dir_all(dest).map_err(|e| format!("Failed to create directory: {}", e))?;
-
-    let cursor = io::Cursor::new(bytes);
-    let mut archive =
-        zip::ZipArchive::new(cursor).map_err(|e| format!("Failed to read zip archive: {}", e))?;
-
-    for i in 0..archive.len() {
-        let mut file = archive
-            .by_index(i)
-            .map_err(|e| format!("Failed to read zip entry: {}", e))?;
-
-        let enclosed = match file.enclosed_name() {
-            Some(name) => name.to_owned(),
-            None => continue,
-        };
-        let rel_path = enclosed.to_string_lossy().to_string();
-
-        if rel_path.is_empty() || file.is_dir() {
-            if file.is_dir() {
-                let out_dir = dest.join(&rel_path);
-                let _ = fs::create_dir_all(&out_dir);
-            }
-            continue;
-        }
-
-        let out_path = dest.join(&rel_path);
-        if !out_path.starts_with(dest) {
-            continue;
-        }
-
-        if let Some(parent) = out_path.parent() {
-            fs::create_dir_all(parent)
-                .map_err(|e| format!("Failed to create parent dir {}: {}", parent.display(), e))?;
-        }
-        let mut out_file = fs::File::create(&out_path)
-            .map_err(|e| format!("Failed to create file {}: {}", out_path.display(), e))?;
-        io::copy(&mut file, &mut out_file)
-            .map_err(|e| format!("Failed to write {}: {}", out_path.display(), e))?;
-    }
-
-    Ok(())
-}

cli/src/main_stealth.rs

@@ -0,0 +1 @@
+include!("main.rs");

cli/src/native/auth.rs

@@ -1,13 +1,11 @@
 use aes_gcm::{aead::Aead, aead::KeyInit, Aes256Gcm};
-use base64::{engine::general_purpose::STANDARD, Engine};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
+use sha2::{Digest, Sha256};
 use std::fs;
-use std::io::Write;
 use std::path::PathBuf;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
 pub struct AuthProfile {
     pub name: String,
     pub url: String,
@@ -19,10 +17,6 @@ pub struct AuthProfile {
     pub password_selector: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub submit_selector: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created_at: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub last_login_at: Option<String>,
 }
 
 // Keep legacy Credential alias for backward compatibility
@@ -54,203 +48,79 @@ fn get_profile_path(name: &str) -> PathBuf {
     get_auth_dir().join(format!("{}.json", name))
 }
 
-const ENCRYPTION_KEY_ENV: &str = "AGENT_BROWSER_ENCRYPTION_KEY";
-const KEY_FILE_NAME: &str = ".encryption-key";
-
-fn get_agent_browser_dir() -> PathBuf {
-    if let Some(home) = dirs::home_dir() {
-        home.join(".agent-browser")
-    } else {
-        std::env::temp_dir().join("agent-browser")
-    }
-}
-
-fn get_key_file_path() -> PathBuf {
-    get_agent_browser_dir().join(KEY_FILE_NAME)
-}
-
-fn parse_key_hex(hex_str: &str) -> Option<Vec<u8>> {
-    let hex_str = hex_str.trim();
-    if hex_str.len() != 64 || !hex_str.chars().all(|c| c.is_ascii_hexdigit()) {
-        return None;
-    }
-    let bytes: Vec<u8> = (0..32)
-        .map(|i| u8::from_str_radix(&hex_str[i * 2..i * 2 + 2], 16).unwrap())
-        .collect();
-    Some(bytes)
-}
-
-/// Read the encryption key from AGENT_BROWSER_ENCRYPTION_KEY env var or
-/// ~/.agent-browser/.encryption-key file (matching the Node.js implementation).
-fn get_encryption_key() -> Result<Vec<u8>, String> {
-    if let Ok(key_hex) = std::env::var(ENCRYPTION_KEY_ENV) {
-        return parse_key_hex(&key_hex).ok_or_else(|| {
-            format!(
-                "{} should be a 64-character hex string (256 bits). Generate one with: openssl rand -hex 32",
-                ENCRYPTION_KEY_ENV
-            )
+fn derive_encryption_key() -> Vec<u8> {
+    let hostname = std::env::var("HOSTNAME")
+        .or_else(|_| std::env::var("COMPUTERNAME"))
+        .unwrap_or_else(|_| {
+            #[cfg(unix)]
+            {
+                let mut buf = [0u8; 256];
+                let len = unsafe { libc::gethostname(buf.as_mut_ptr() as *mut _, buf.len()) };
+                if len == 0 {
+                    let end = buf.iter().position(|&b| b == 0).unwrap_or(buf.len());
+                    String::from_utf8_lossy(&buf[..end]).to_string()
+                } else {
+                    "unknown-host".to_string()
+                }
+            }
+            #[cfg(not(unix))]
+            {
+                "unknown-host".to_string()
+            }
         });
-    }
-
-    let key_file = get_key_file_path();
-    if key_file.exists() {
-        let hex = fs::read_to_string(&key_file)
-            .map_err(|e| format!("Failed to read encryption key file: {}", e))?;
-        return parse_key_hex(&hex).ok_or_else(|| {
-            format!(
-                "Invalid encryption key in {}. Expected 64-character hex string.",
-                key_file.display()
-            )
-        });
-    }
-
-    Err(format!(
-        "Encryption key required. Set {} or ensure {} exists.",
-        ENCRYPTION_KEY_ENV,
-        key_file.display()
-    ))
+    let username = std::env::var("USER")
+        .or_else(|_| std::env::var("USERNAME"))
+        .unwrap_or_else(|_| "unknown-user".to_string());
+    let mut hasher = Sha256::new();
+    hasher.update(format!("agent-browser:{}:{}", hostname, username).as_bytes());
+    hasher.finalize().to_vec()
 }
 
-/// Ensure an encryption key exists, auto-generating one if needed.
-fn ensure_encryption_key() -> Result<Vec<u8>, String> {
-    if let Ok(key) = get_encryption_key() {
-        return Ok(key);
-    }
-
-    let mut key = [0u8; 32];
-    getrandom::getrandom(&mut key).map_err(|e| format!("Failed to generate key: {}", e))?;
-    let key_hex = key.iter().map(|b| format!("{:02x}", b)).collect::<String>();
-
-    let dir = get_agent_browser_dir();
-    fs::create_dir_all(&dir).map_err(|e| format!("Failed to create directory: {}", e))?;
-    #[cfg(unix)]
-    {
-        use std::os::unix::fs::PermissionsExt;
-        let _ = fs::set_permissions(&dir, fs::Permissions::from_mode(0o700));
-    }
-
-    let key_file = get_key_file_path();
-    fs::write(&key_file, format!("{}\n", key_hex))
-        .map_err(|e| format!("Failed to write encryption key: {}", e))?;
-    #[cfg(unix)]
-    {
-        use std::os::unix::fs::PermissionsExt;
-        let _ = fs::set_permissions(&key_file, fs::Permissions::from_mode(0o600));
-    }
-
-    let _ = writeln!(
-        std::io::stderr(),
-        "[agent-browser] Auto-generated encryption key at {} -- back up this file or set {}",
-        key_file.display(),
-        ENCRYPTION_KEY_ENV
-    );
-
-    Ok(key.to_vec())
-}
-
-/// Encrypt a profile to the JSON+base64 format compatible with Node.js.
-fn encrypt_profile(profile: &AuthProfile) -> Result<String, String> {
-    let key = ensure_encryption_key()?;
+fn encrypt_profile(profile: &AuthProfile) -> Result<Vec<u8>, String> {
+    let key = derive_encryption_key();
     let cipher =
         Aes256Gcm::new_from_slice(&key).map_err(|e| format!("Encryption key error: {}", e))?;
 
     let plaintext = serde_json::to_string(profile)
         .map_err(|e| format!("Failed to serialize profile: {}", e))?;
 
-    let mut iv = [0u8; 12];
-    getrandom::getrandom(&mut iv).map_err(|e| format!("Failed to generate IV: {}", e))?;
-
-    // aes_gcm appends the 16-byte auth tag to the ciphertext
-    let encrypted = cipher
-        .encrypt(aes_gcm::Nonce::from_slice(&iv), plaintext.as_bytes())
+    let mut nonce = [0u8; 12];
+    getrandom::getrandom(&mut nonce).map_err(|e| format!("Failed to generate nonce: {}", e))?;
+    let ciphertext = cipher
+        .encrypt(aes_gcm::Nonce::from_slice(&nonce), plaintext.as_bytes())
         .map_err(|e| format!("Encryption failed: {}", e))?;
 
-    let tag_offset = encrypted.len() - 16;
-    let ciphertext = &encrypted[..tag_offset];
-    let auth_tag = &encrypted[tag_offset..];
-
-    let payload = json!({
-        "version": 1,
-        "encrypted": true,
-        "iv": STANDARD.encode(iv),
-        "authTag": STANDARD.encode(auth_tag),
-        "data": STANDARD.encode(ciphertext),
-    });
-
-    serde_json::to_string_pretty(&payload)
-        .map_err(|e| format!("Failed to serialize payload: {}", e))
-}
-
-/// JSON envelope written by Node.js encryption (src/encryption.ts).
-#[derive(Deserialize)]
-struct EncryptedPayload {
-    #[allow(dead_code)]
-    version: u32,
-    #[allow(dead_code)]
-    encrypted: bool,
-    iv: String,
-    #[serde(rename = "authTag")]
-    auth_tag: String,
-    data: String,
+    let mut result = Vec::with_capacity(12 + ciphertext.len());
+    result.extend_from_slice(&nonce);
+    result.extend_from_slice(&ciphertext);
+    Ok(result)
 }
 
 fn decrypt_profile(data: &[u8]) -> Result<AuthProfile, String> {
-    let text = std::str::from_utf8(data).map_err(|_| {
-        "Profile is not valid UTF-8 -- it may use an older incompatible binary format".to_string()
-    })?;
-
-    if let Ok(payload) = serde_json::from_str::<EncryptedPayload>(text) {
-        let key = get_encryption_key()?;
-
-        let iv = STANDARD
-            .decode(&payload.iv)
-            .map_err(|e| format!("Invalid base64 iv: {}", e))?;
-        let auth_tag = STANDARD
-            .decode(&payload.auth_tag)
-            .map_err(|e| format!("Invalid base64 authTag: {}", e))?;
-        let ciphertext = STANDARD
-            .decode(&payload.data)
-            .map_err(|e| format!("Invalid base64 data: {}", e))?;
-
-        // aes_gcm expects ciphertext || auth_tag as input to decrypt
-        let mut combined = Vec::with_capacity(ciphertext.len() + auth_tag.len());
-        combined.extend_from_slice(&ciphertext);
-        combined.extend_from_slice(&auth_tag);
-
-        let cipher =
-            Aes256Gcm::new_from_slice(&key).map_err(|e| format!("Decryption key error: {}", e))?;
-        let plaintext = cipher
-            .decrypt(aes_gcm::Nonce::from_slice(&iv), combined.as_slice())
-            .map_err(|e| format!("Decryption failed: {}", e))?;
-
-        let json_str = String::from_utf8(plaintext)
-            .map_err(|e| format!("Decrypted data is not valid UTF-8: {}", e))?;
-        return serde_json::from_str(&json_str).map_err(|e| format!("Invalid profile data: {}", e));
+    if data.len() < 13 {
+        return Err("Encrypted data too short".to_string());
     }
+    let (nonce_bytes, ciphertext) = data.split_at(12);
 
-    // Fallback: try as plain unencrypted JSON profile
-    serde_json::from_str::<AuthProfile>(text)
-        .map_err(|_| "Profile is not a valid encrypted or unencrypted payload".to_string())
+    let key = derive_encryption_key();
+    let cipher =
+        Aes256Gcm::new_from_slice(&key).map_err(|e| format!("Decryption key error: {}", e))?;
+    let plaintext = cipher
+        .decrypt(aes_gcm::Nonce::from_slice(nonce_bytes), ciphertext)
+        .map_err(|e| format!("Decryption failed: {}", e))?;
+
+    let json_str = String::from_utf8(plaintext)
+        .map_err(|e| format!("Decrypted data is not valid UTF-8: {}", e))?;
+    serde_json::from_str(&json_str).map_err(|e| format!("Invalid profile data: {}", e))
 }
 
 fn save_profile(profile: &AuthProfile) -> Result<(), String> {
     let dir = get_auth_dir();
-    fs::create_dir_all(&dir).map_err(|e| format!("Failed to create auth dir: {}", e))?;
-    #[cfg(unix)]
-    {
-        use std::os::unix::fs::PermissionsExt;
-        let _ = fs::set_permissions(&dir, fs::Permissions::from_mode(0o700));
-    }
+    let _ = fs::create_dir_all(&dir);
 
-    let encrypted_json = encrypt_profile(profile)?;
+    let encrypted = encrypt_profile(profile)?;
     let path = get_profile_path(&profile.name);
-    fs::write(&path, &encrypted_json).map_err(|e| format!("Failed to write profile: {}", e))?;
-    #[cfg(unix)]
-    {
-        use std::os::unix::fs::PermissionsExt;
-        let _ = fs::set_permissions(&path, fs::Permissions::from_mode(0o600));
-    }
-    Ok(())
+    fs::write(&path, &encrypted).map_err(|e| format!("Failed to write profile: {}", e))
 }
 
 fn load_profile(name: &str) -> Result<AuthProfile, String> {
@@ -277,8 +147,6 @@ pub fn credentials_set(
         username_selector: None,
         password_selector: None,
         submit_selector: None,
-        created_at: None,
-        last_login_at: None,
     };
     save_profile(&profile)?;
     Ok(json!({ "saved": name }))
@@ -302,8 +170,6 @@ pub fn auth_save(
         username_selector: username_selector.map(String::from),
         password_selector: password_selector.map(String::from),
         submit_selector: submit_selector.map(String::from),
-        created_at: None,
-        last_login_at: None,
     };
     save_profile(&profile)?;
     Ok(json!({ "saved": name }))
@@ -386,27 +252,10 @@ pub fn auth_show(name: &str) -> Result<Value, String> {
     }))
 }
 
-#[cfg(test)]
-pub(crate) static AUTH_TEST_MUTEX: std::sync::Mutex<()> = std::sync::Mutex::new(());
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    fn with_test_key<F: FnOnce()>(f: F) {
-        let _lock = AUTH_TEST_MUTEX.lock().unwrap();
-        let original = std::env::var(ENCRYPTION_KEY_ENV).ok();
-        let test_key = "a".repeat(64);
-        // SAFETY: TEST_MUTEX serializes all test access so no concurrent mutation.
-        unsafe { std::env::set_var(ENCRYPTION_KEY_ENV, &test_key) };
-        f();
-        // SAFETY: TEST_MUTEX serializes all test access so no concurrent mutation.
-        match original {
-            Some(val) => unsafe { std::env::set_var(ENCRYPTION_KEY_ENV, val) },
-            None => unsafe { std::env::remove_var(ENCRYPTION_KEY_ENV) },
-        }
-    }
-
     #[test]
     fn test_validate_profile_name() {
         assert!(validate_profile_name("github").is_ok());
@@ -428,8 +277,6 @@ mod tests {
             username_selector: None,
             password_selector: None,
             submit_selector: Some("button[type=submit]".to_string()),
-            created_at: None,
-            last_login_at: None,
         };
         let json = serde_json::to_string(&profile).unwrap();
         let parsed: AuthProfile = serde_json::from_str(&json).unwrap();
@@ -443,114 +290,26 @@ mod tests {
 
     #[test]
     fn test_encrypt_decrypt_roundtrip() {
-        with_test_key(|| {
-            let profile = AuthProfile {
-                name: "roundtrip".to_string(),
-                url: "https://example.com".to_string(),
-                username: "user".to_string(),
-                password: "s3cret!".to_string(),
-                username_selector: None,
-                password_selector: None,
-                submit_selector: None,
-                created_at: None,
-                last_login_at: None,
-            };
-            let encrypted_json = encrypt_profile(&profile).unwrap();
-            let decrypted = decrypt_profile(encrypted_json.as_bytes()).unwrap();
-            assert_eq!(decrypted.name, "roundtrip");
-            assert_eq!(decrypted.password, "s3cret!");
-        });
+        let profile = AuthProfile {
+            name: "roundtrip".to_string(),
+            url: "https://example.com".to_string(),
+            username: "user".to_string(),
+            password: "s3cret!".to_string(),
+            username_selector: None,
+            password_selector: None,
+            submit_selector: None,
+        };
+        let encrypted = encrypt_profile(&profile).unwrap();
+        let decrypted = decrypt_profile(&encrypted).unwrap();
+        assert_eq!(decrypted.name, "roundtrip");
+        assert_eq!(decrypted.password, "s3cret!");
     }
 
     #[test]
-    fn test_get_encryption_key_from_env() {
-        with_test_key(|| {
-            let key = get_encryption_key().unwrap();
-            assert_eq!(key.len(), 32);
-            assert!(key.iter().all(|&b| b == 0xaa));
-        });
-    }
-
-    #[test]
-    fn test_parse_key_hex_valid() {
-        let hex = "ab".repeat(32);
-        let key = parse_key_hex(&hex).unwrap();
-        assert_eq!(key.len(), 32);
-        assert!(key.iter().all(|&b| b == 0xab));
-    }
-
-    #[test]
-    fn test_parse_key_hex_invalid() {
-        assert!(parse_key_hex("too_short").is_none());
-        assert!(parse_key_hex(&"g".repeat(64)).is_none());
-        assert!(parse_key_hex("").is_none());
-    }
-
-    #[test]
-    fn test_decrypt_json_payload_format() {
-        with_test_key(|| {
-            let key = get_encryption_key().unwrap();
-            let profile = AuthProfile {
-                name: "json-test".to_string(),
-                url: "https://example.com/login".to_string(),
-                username: "admin".to_string(),
-                password: "hunter2".to_string(),
-                username_selector: Some("#email".to_string()),
-                password_selector: None,
-                submit_selector: None,
-                created_at: None,
-                last_login_at: None,
-            };
-
-            // Encrypt with aes_gcm, then manually build the JSON payload
-            // to simulate what Node.js would produce
-            let cipher = Aes256Gcm::new_from_slice(&key).unwrap();
-            let mut iv = [0u8; 12];
-            getrandom::getrandom(&mut iv).unwrap();
-            let plaintext = serde_json::to_string(&profile).unwrap();
-            let encrypted = cipher
-                .encrypt(aes_gcm::Nonce::from_slice(&iv), plaintext.as_bytes())
-                .unwrap();
-
-            let tag_offset = encrypted.len() - 16;
-            let ciphertext = &encrypted[..tag_offset];
-            let auth_tag = &encrypted[tag_offset..];
-
-            let payload = format!(
-                r#"{{"version":1,"encrypted":true,"iv":"{}","authTag":"{}","data":"{}"}}"#,
-                STANDARD.encode(iv),
-                STANDARD.encode(auth_tag),
-                STANDARD.encode(ciphertext),
-            );
-
-            let decrypted = decrypt_profile(payload.as_bytes()).unwrap();
-            assert_eq!(decrypted.name, "json-test");
-            assert_eq!(decrypted.password, "hunter2");
-            assert_eq!(decrypted.username_selector, Some("#email".to_string()));
-        });
-    }
-
-    #[test]
-    fn test_encrypted_output_is_json_format() {
-        with_test_key(|| {
-            let profile = AuthProfile {
-                name: "format-check".to_string(),
-                url: "https://example.com".to_string(),
-                username: "user".to_string(),
-                password: "pass".to_string(),
-                username_selector: None,
-                password_selector: None,
-                submit_selector: None,
-                created_at: None,
-                last_login_at: None,
-            };
-            let encrypted = encrypt_profile(&profile).unwrap();
-            let parsed: Value = serde_json::from_str(&encrypted).unwrap();
-            assert_eq!(parsed["version"], 1);
-            assert_eq!(parsed["encrypted"], true);
-            assert!(parsed["iv"].is_string());
-            assert!(parsed["authTag"].is_string());
-            assert!(parsed["data"].is_string());
-        });
+    fn test_derive_encryption_key_is_stable() {
+        let k1 = derive_encryption_key();
+        let k2 = derive_encryption_key();
+        assert_eq!(k1, k2);
+        assert_eq!(k1.len(), 32);
     }
 }

cli/src/native/cdp/chrome.rs

@@ -1,14 +1,13 @@
-use std::io::{BufRead, BufReader, Write};
+use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 use std::process::{Child, Command, Stdio};
 use std::time::Duration;
 
-use super::discovery::discover_cdp_url;
+use super::types::BrowserVersionInfo;
 
 pub struct ChromeProcess {
     child: Child,
     pub ws_url: String,
-    temp_user_data_dir: Option<PathBuf>,
 }
 
 impl ChromeProcess {
@@ -16,60 +15,11 @@ impl ChromeProcess {
         let _ = self.child.kill();
         let _ = self.child.wait();
     }
-
-    /// Returns the OS process ID of the Chrome child process.
-    pub fn id(&self) -> u32 {
-        self.child.id()
-    }
-
-    /// Non-blocking check whether Chrome has exited.
-    /// Returns `true` if the process has exited (and reaps it), `false` if still running.
-    pub fn has_exited(&mut self) -> bool {
-        matches!(self.child.try_wait(), Ok(Some(_)) | Err(_))
-    }
-
-    /// Wait for Chrome to exit on its own (after Browser.close CDP command),
-    /// falling back to kill() if it doesn't exit within the timeout.
-    /// This allows Chrome to flush cookies and other state to the user-data-dir.
-    pub fn wait_or_kill(&mut self, timeout: Duration) {
-        let start = std::time::Instant::now();
-        let poll_interval = Duration::from_millis(50);
-
-        while start.elapsed() < timeout {
-            match self.child.try_wait() {
-                Ok(Some(_)) => return,
-                Ok(None) => std::thread::sleep(poll_interval),
-                Err(_) => break,
-            }
-        }
-
-        self.kill();
-    }
 }
 
 impl Drop for ChromeProcess {
     fn drop(&mut self) {
         self.kill();
-        if let Some(ref dir) = self.temp_user_data_dir {
-            for attempt in 0..3 {
-                match std::fs::remove_dir_all(dir) {
-                    Ok(()) => break,
-                    Err(_) if attempt < 2 => {
-                        std::thread::sleep(Duration::from_millis(100));
-                    }
-                    Err(e) => {
-                        // Use write! instead of eprintln! to avoid panicking
-                        // if the daemon's stderr pipe is broken (parent dropped it).
-                        let _ = writeln!(
-                            std::io::stderr(),
-                            "Warning: failed to clean up temp profile {}: {}",
-                            dir.display(),
-                            e
-                        );
-                    }
-                }
-            }
-        }
     }
 }
 
@@ -78,8 +28,6 @@ pub struct LaunchOptions {
     pub executable_path: Option<String>,
     pub proxy: Option<String>,
     pub proxy_bypass: Option<String>,
-    pub proxy_username: Option<String>,
-    pub proxy_password: Option<String>,
     pub profile: Option<String>,
     pub args: Vec<String>,
     pub allow_file_access: bool,
@@ -98,8 +46,6 @@ impl Default for LaunchOptions {
             executable_path: None,
             proxy: None,
             proxy_bypass: None,
-            proxy_username: None,
-            proxy_password: None,
             profile: None,
             args: Vec::new(),
             allow_file_access: false,
@@ -113,13 +59,14 @@ impl Default for LaunchOptions {
     }
 }
 
-struct ChromeArgs {
-    args: Vec<String>,
-    user_data_dir: PathBuf,
-    temp_user_data_dir: Option<PathBuf>,
-}
+pub fn launch_chrome(options: &LaunchOptions) -> Result<ChromeProcess, String> {
+    let chrome_path = match &options.executable_path {
+        Some(p) => PathBuf::from(p),
+        None => {
+            find_chrome().ok_or("Chrome not found. Install Chrome or use --executable-path.")?
+        }
+    };
 
-fn build_chrome_args(options: &LaunchOptions) -> Result<ChromeArgs, String> {
     let mut args = vec![
         "--remote-debugging-port=0".to_string(),
         "--no-first-run".to_string(),
@@ -132,27 +79,14 @@ fn build_chrome_args(options: &LaunchOptions) -> Result<ChromeArgs, String> {
         "--disable-popup-blocking".to_string(),
         "--disable-prompt-on-repost".to_string(),
         "--disable-sync".to_string(),
-        "--disable-features=Translate".to_string(),
         "--enable-features=NetworkService,NetworkServiceInProcess".to_string(),
         "--metrics-recording-only".to_string(),
         "--password-store=basic".to_string(),
         "--use-mock-keychain".to_string(),
     ];
 
-    let has_extensions = options
-        .extensions
-        .as_ref()
-        .is_some_and(|exts| !exts.is_empty());
-
-    // Extensions require headed mode in native Chrome (content scripts are not
-    // injected in headless mode).  Skip --headless when extensions are loaded.
-    if options.headless && !has_extensions {
+    if options.headless {
         args.push("--headless=new".to_string());
-        // Enable SwiftShader software rendering in headless mode.  This
-        // prevents silent crashes in environments where GPU drivers are
-        // missing or restricted (VMs, containers, some cloud machines)
-        // while preserving WebGL support.  Playwright uses the same flag.
-        args.push("--enable-unsafe-swiftshader".to_string());
     }
 
     if let Some(ref proxy) = options.proxy {
@@ -163,19 +97,10 @@ fn build_chrome_args(options: &LaunchOptions) -> Result<ChromeArgs, String> {
         args.push(format!("--proxy-bypass-list={}", bypass));
     }
 
-    let (user_data_dir, temp_user_data_dir) = if let Some(ref profile) = options.profile {
+    if let Some(ref profile) = options.profile {
         let expanded = expand_tilde(profile);
-        let dir = PathBuf::from(&expanded);
         args.push(format!("--user-data-dir={}", expanded));
-        (dir, None)
-    } else {
-        let dir =
-            std::env::temp_dir().join(format!("agent-browser-chrome-{}", uuid::Uuid::new_v4()));
-        std::fs::create_dir_all(&dir)
-            .map_err(|e| format!("Failed to create temp profile dir: {}", e))?;
-        args.push(format!("--user-data-dir={}", dir.display()));
-        (dir.clone(), Some(dir))
-    };
+    }
 
     if options.allow_file_access {
         args.push("--allow-file-access-from-files".to_string());
@@ -190,12 +115,13 @@ fn build_chrome_args(options: &LaunchOptions) -> Result<ChromeArgs, String> {
         }
     }
 
+    // Check if user args set window size (skip viewport override)
     let has_window_size = options
         .args
         .iter()
         .any(|a| a.starts_with("--start-maximized") || a.starts_with("--window-size="));
 
-    if !has_window_size && options.headless && !has_extensions {
+    if !has_window_size && options.headless {
         args.push("--window-size=1280,720".to_string());
     }
 
@@ -205,161 +131,27 @@ fn build_chrome_args(options: &LaunchOptions) -> Result<ChromeArgs, String> {
         args.push("--no-sandbox".to_string());
     }
 
-    if should_disable_dev_shm(&args) {
-        args.push("--disable-dev-shm-usage".to_string());
-    }
-
-    Ok(ChromeArgs {
-        args,
-        user_data_dir,
-        temp_user_data_dir,
-    })
-}
-
-pub fn launch_chrome(options: &LaunchOptions) -> Result<ChromeProcess, String> {
-    let chrome_path = match &options.executable_path {
-        Some(p) => PathBuf::from(p),
-        None => find_chrome().ok_or_else(|| {
-            let cache_dir = crate::install::get_browsers_dir();
-            format!(
-                "Chrome not found. Checked:\n  \
-                 - agent-browser cache: {}\n  \
-                 - System Chrome installations\n  \
-                 - Puppeteer browser cache\n  \
-                 - Playwright browser cache\n\
-                 Run `agent-browser install` to download Chrome, or use --executable-path.",
-                cache_dir.display()
-            )
-        })?,
-    };
-
-    let max_attempts = 3;
-    let mut last_err = String::new();
-
-    for attempt in 1..=max_attempts {
-        match try_launch_chrome(&chrome_path, options) {
-            Ok(process) => return Ok(process),
-            Err(e) => {
-                last_err = e;
-                if attempt < max_attempts {
-                    // Use write! instead of eprintln! to avoid panicking
-                    // if the daemon's stderr pipe is broken (parent dropped it).
-                    let _ = writeln!(
-                        std::io::stderr(),
-                        "[chrome] Launch attempt {}/{} failed, retrying in 500ms...",
-                        attempt,
-                        max_attempts
-                    );
-                    std::thread::sleep(Duration::from_millis(500));
-                }
-            }
-        }
-    }
-
-    Err(last_err)
-}
-
-fn try_launch_chrome(chrome_path: &Path, options: &LaunchOptions) -> Result<ChromeProcess, String> {
-    let ChromeArgs {
-        args,
-        user_data_dir,
-        temp_user_data_dir,
-    } = build_chrome_args(options)?;
-
-    // Mitigate stale DevToolsActivePort risk (e.g., previous crash left it behind).
-    // Puppeteer does similar cleanup before spawning.
-    let _ = std::fs::remove_file(user_data_dir.join("DevToolsActivePort"));
-
-    let cleanup_temp_dir = |dir: &Option<PathBuf>| {
-        if let Some(ref d) = dir {
-            let _ = std::fs::remove_dir_all(d);
-        }
-    };
-
-    let mut child = Command::new(chrome_path)
+    let mut child = Command::new(&chrome_path)
         .args(&args)
         .stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::piped())
         .spawn()
-        .map_err(|e| {
-            cleanup_temp_dir(&temp_user_data_dir);
-            format!("Failed to launch Chrome at {:?}: {}", chrome_path, e)
-        })?;
+        .map_err(|e| format!("Failed to launch Chrome at {:?}: {}", chrome_path, e))?;
 
-    // Shared overall deadline so we don't double-wait (poll + stderr fallback).
+    let stderr = child
+        .stderr
+        .take()
+        .ok_or("Failed to capture Chrome stderr")?;
+    let reader = BufReader::new(stderr);
+
+    let ws_url = wait_for_ws_url(reader)?;
+
+    Ok(ChromeProcess { child, ws_url })
+}
+
+fn wait_for_ws_url(reader: BufReader<std::process::ChildStderr>) -> Result<String, String> {
     let deadline = std::time::Instant::now() + Duration::from_secs(30);
-
-    // Primary path: use DevToolsActivePort written into user-data-dir.
-    // This is more reliable on Windows than scraping stderr for "DevTools listening on ...",
-    // which can be missing/empty depending on how Chrome is launched.
-    let ws_url = match wait_for_devtools_active_port(&mut child, &user_data_dir, deadline) {
-        Ok(url) => url,
-        Err(primary_err) => {
-            // Fallback: scrape stderr (legacy behavior) for better diagnostics.
-            let stderr = child.stderr.take().ok_or_else(|| {
-                let _ = child.kill();
-                cleanup_temp_dir(&temp_user_data_dir);
-                "Failed to capture Chrome stderr".to_string()
-            })?;
-            let reader = BufReader::new(stderr);
-            match wait_for_ws_url_until(reader, deadline) {
-                Ok(url) => url,
-                Err(fallback_err) => {
-                    let _ = child.kill();
-                    cleanup_temp_dir(&temp_user_data_dir);
-                    return Err(format!(
-                        "{}\n(also tried parsing stderr) {}",
-                        primary_err, fallback_err
-                    ));
-                }
-            }
-        }
-    };
-
-    Ok(ChromeProcess {
-        child,
-        ws_url,
-        temp_user_data_dir,
-    })
-}
-
-fn wait_for_devtools_active_port(
-    child: &mut Child,
-    user_data_dir: &Path,
-    deadline: std::time::Instant,
-) -> Result<String, String> {
-    let poll_interval = Duration::from_millis(50);
-
-    while std::time::Instant::now() <= deadline {
-        if let Ok(Some(status)) = child.try_wait() {
-            // Chrome exited before writing DevToolsActivePort -- report the
-            // exit code so the caller can surface it alongside stderr output.
-            let code = status
-                .code()
-                .map(|c| format!("{}", c))
-                .unwrap_or_else(|| "unknown".to_string());
-            return Err(format!(
-                "Chrome exited early (exit code: {}) without writing DevToolsActivePort",
-                code
-            ));
-        }
-
-        if let Some((port, ws_path)) = read_devtools_active_port(user_data_dir) {
-            let ws_url = format!("ws://127.0.0.1:{}{}", port, ws_path);
-            return Ok(ws_url);
-        }
-
-        std::thread::sleep(poll_interval);
-    }
-
-    Err("Timeout waiting for DevToolsActivePort".to_string())
-}
-
-fn wait_for_ws_url_until(
-    reader: BufReader<std::process::ChildStderr>,
-    deadline: std::time::Instant,
-) -> Result<String, String> {
     let prefix = "DevTools listening on ";
     let mut stderr_lines: Vec<String> = Vec::new();
 
@@ -401,10 +193,7 @@ fn chrome_launch_error(message: &str, stderr_lines: &[String]) -> String {
 
     if relevant.is_empty() {
         if stderr_lines.is_empty() {
-            return format!(
-                "{} (no stderr output from Chrome)\nHint: try passing --args \"--no-sandbox\" if Chrome crashes silently in your environment",
-                message
-            );
+            return format!("{} (no stderr output from Chrome)", message);
         }
         let last_lines: Vec<&String> = stderr_lines.iter().rev().take(5).collect();
         return format!(
@@ -442,31 +231,12 @@ fn chrome_launch_error(message: &str, stderr_lines: &[String]) -> String {
 }
 
 pub fn find_chrome() -> Option<PathBuf> {
-    // 1. Check Chrome downloaded by `agent-browser install`
-    if let Some(p) = crate::install::find_installed_chrome() {
-        return Some(p);
-    }
-
-    // If the cache directory exists but no Chrome was found, warn -- this
-    // likely means the cache is corrupted or the directory layout is unexpected.
-    let cache_dir = crate::install::get_browsers_dir();
-    if cache_dir.exists() {
-        let _ = writeln!(
-            std::io::stderr(),
-            "Warning: Chrome cache directory exists ({}) but no Chrome binary found inside. \
-             Falling back to system Chrome. Run `agent-browser install` to re-download.",
-            cache_dir.display()
-        );
-    }
-
-    // 2. Check system-installed Chrome
     #[cfg(target_os = "macos")]
     {
         let candidates = [
             "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
             "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
             "/Applications/Chromium.app/Contents/MacOS/Chromium",
-            "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
         ];
         for c in &candidates {
             let p = PathBuf::from(c);
@@ -474,6 +244,10 @@ pub fn find_chrome() -> Option<PathBuf> {
                 return Some(p);
             }
         }
+
+        if let Some(p) = find_playwright_chromium() {
+            return Some(p);
+        }
     }
 
     #[cfg(target_os = "linux")]
@@ -483,8 +257,6 @@ pub fn find_chrome() -> Option<PathBuf> {
             "google-chrome-stable",
             "chromium-browser",
             "chromium",
-            "brave-browser",
-            "brave-browser-stable",
         ];
         for name in &candidates {
             if let Ok(output) = Command::new("which").arg(name).output() {
@@ -496,6 +268,10 @@ pub fn find_chrome() -> Option<PathBuf> {
                 }
             }
         }
+
+        if let Some(p) = find_playwright_chromium() {
+            return Some(p);
+        }
     }
 
     #[cfg(target_os = "windows")]
@@ -505,14 +281,9 @@ pub fn find_chrome() -> Option<PathBuf> {
             r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
         ];
         if let Ok(local) = std::env::var("LOCALAPPDATA") {
-            let chrome = PathBuf::from(&local).join(r"Google\Chrome\Application\chrome.exe");
-            if chrome.exists() {
-                return Some(chrome);
-            }
-            let brave =
-                PathBuf::from(&local).join(r"BraveSoftware\Brave-Browser\Application\brave.exe");
-            if brave.exists() {
-                return Some(brave);
+            let p = PathBuf::from(&local).join(r"Google\Chrome\Application\chrome.exe");
+            if p.exists() {
+                return Some(p);
             }
         }
         for c in &candidates {
@@ -523,17 +294,78 @@ pub fn find_chrome() -> Option<PathBuf> {
         }
     }
 
-    // 3. Fallback: check Puppeteer / Playwright browser caches
-    if let Some(p) = find_puppeteer_chrome() {
-        return Some(p);
-    }
-    if let Some(p) = find_playwright_chromium() {
-        return Some(p);
-    }
-
     None
 }
 
+pub async fn discover_cdp_url(port: u16) -> Result<String, String> {
+    let url = format!("http://127.0.0.1:{}/json/version", port);
+
+    let body = tokio::time::timeout(Duration::from_secs(2), async {
+        reqwest_get_string(&url).await
+    })
+    .await
+    .map_err(|_| format!("Timeout connecting to CDP on port {}", port))?
+    .map_err(|e| format!("Failed to connect to CDP on port {}: {}", port, e))?;
+
+    let info: BrowserVersionInfo = serde_json::from_str(&body)
+        .map_err(|e| format!("Invalid /json/version response: {}", e))?;
+
+    info.web_socket_debugger_url
+        .ok_or_else(|| format!("No webSocketDebuggerUrl in /json/version on port {}", port))
+}
+
+async fn reqwest_get_string(url: &str) -> Result<String, String> {
+    let client = tokio::net::TcpStream::connect(
+        url.strip_prefix("http://")
+            .unwrap_or(url)
+            .split('/')
+            .next()
+            .unwrap_or("127.0.0.1:9222"),
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
+    let path = url
+        .find('/')
+        .and_then(|i| url[i..].find('/').map(|j| &url[i + j..]))
+        .unwrap_or("/json/version");
+
+    let host = url
+        .strip_prefix("http://")
+        .unwrap_or(url)
+        .split('/')
+        .next()
+        .unwrap_or("127.0.0.1");
+
+    let request = format!(
+        "GET {} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\n\r\n",
+        path, host
+    );
+
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    let mut client = client;
+    client
+        .write_all(request.as_bytes())
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let mut response = Vec::new();
+    client
+        .read_to_end(&mut response)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let response_str = String::from_utf8_lossy(&response);
+    let body = response_str
+        .split("\r\n\r\n")
+        .nth(1)
+        .unwrap_or("")
+        .to_string();
+
+    Ok(body)
+}
+
 pub fn read_devtools_active_port(user_data_dir: &Path) -> Option<(u16, String)> {
     let path = user_data_dir.join("DevToolsActivePort");
     let content = std::fs::read_to_string(&path).ok()?;
@@ -553,26 +385,18 @@ pub async fn auto_connect_cdp() -> Result<String, String> {
     for dir in &user_data_dirs {
         if let Some((port, ws_path)) = read_devtools_active_port(dir) {
             // Try HTTP endpoint first (pre-M144)
-            if let Ok(ws_url) = discover_cdp_url("127.0.0.1", port, None).await {
+            if let Ok(ws_url) = discover_cdp_url(port).await {
                 return Ok(ws_url);
             }
-            // M144+: direct WebSocket — verify the port is actually listening
-            // before returning, otherwise a stale DevToolsActivePort file
-            // (left behind after Chrome exits/crashes) produces a confusing
-            // "connection refused" error instead of falling through.
-            if is_port_reachable(port) {
-                let ws_url = format!("ws://127.0.0.1:{}{}", port, ws_path);
-                return Ok(ws_url);
-            }
-            // Port is dead — remove the stale file so future runs skip it.
-            let stale = dir.join("DevToolsActivePort");
-            let _ = std::fs::remove_file(&stale);
+            // M144+: direct WebSocket
+            let ws_url = format!("ws://127.0.0.1:{}{}", port, ws_path);
+            return Ok(ws_url);
         }
     }
 
     // Fallback: probe common ports
     for port in [9222u16, 9229] {
-        if let Ok(ws_url) = discover_cdp_url("127.0.0.1", port, None).await {
+        if let Ok(ws_url) = discover_cdp_url(port).await {
             return Ok(ws_url);
         }
     }
@@ -580,12 +404,6 @@ pub async fn auto_connect_cdp() -> Result<String, String> {
     Err("No running Chrome instance found. Launch Chrome with --remote-debugging-port or use --cdp.".to_string())
 }
 
-fn is_port_reachable(port: u16) -> bool {
-    use std::net::TcpStream;
-    let addr = format!("127.0.0.1:{}", port);
-    TcpStream::connect_timeout(&addr.parse().unwrap(), Duration::from_millis(500)).is_ok()
-}
-
 fn get_chrome_user_data_dirs() -> Vec<PathBuf> {
     let mut dirs = Vec::new();
 
@@ -593,12 +411,7 @@ fn get_chrome_user_data_dirs() -> Vec<PathBuf> {
     {
         if let Some(home) = dirs::home_dir() {
             let base = home.join("Library/Application Support");
-            for name in [
-                "Google/Chrome",
-                "Google/Chrome Canary",
-                "Chromium",
-                "BraveSoftware/Brave-Browser",
-            ] {
+            for name in ["Google/Chrome", "Google/Chrome Canary", "Chromium"] {
                 dirs.push(base.join(name));
             }
         }
@@ -608,12 +421,7 @@ fn get_chrome_user_data_dirs() -> Vec<PathBuf> {
     {
         if let Some(home) = dirs::home_dir() {
             let config = home.join(".config");
-            for name in [
-                "google-chrome",
-                "google-chrome-unstable",
-                "chromium",
-                "BraveSoftware/Brave-Browser",
-            ] {
+            for name in ["google-chrome", "google-chrome-unstable", "chromium"] {
                 dirs.push(config.join(name));
             }
         }
@@ -627,7 +435,6 @@ fn get_chrome_user_data_dirs() -> Vec<PathBuf> {
                 r"Google\Chrome\User Data",
                 r"Google\Chrome SxS\User Data",
                 r"Chromium\User Data",
-                r"BraveSoftware\Brave-Browser\User Data",
             ] {
                 dirs.push(base.join(name));
             }
@@ -638,18 +445,12 @@ fn get_chrome_user_data_dirs() -> Vec<PathBuf> {
 }
 
 /// Returns true if Chrome's sandbox should be disabled because the environment
-/// doesn't support it (containers, VMs, CI runners, running as root).
+/// doesn't support it (containers, VMs, running as root).
 fn should_disable_sandbox(existing_args: &[String]) -> bool {
     if existing_args.iter().any(|a| a == "--no-sandbox") {
         return false; // already set by user
     }
 
-    // CI environments (GitHub Actions, GitLab CI, etc.) often lack user namespace
-    // support due to AppArmor or kernel restrictions.
-    if std::env::var("CI").is_ok() {
-        return true;
-    }
-
     #[cfg(unix)]
     {
         // Root user -- standard container default, Chrome sandbox requires non-root
@@ -669,7 +470,10 @@ fn should_disable_sandbox(existing_args: &[String]) -> bool {
 
         // Generic container detection: cgroup contains docker/kubepods/lxc
         if let Ok(cgroup) = std::fs::read_to_string("/proc/1/cgroup") {
-            if cgroup.contains("docker") || cgroup.contains("kubepods") || cgroup.contains("lxc") {
+            if cgroup.contains("docker")
+                || cgroup.contains("kubepods")
+                || cgroup.contains("lxc")
+            {
                 return true;
             }
         }
@@ -678,108 +482,8 @@ fn should_disable_sandbox(existing_args: &[String]) -> bool {
     false
 }
 
-/// Returns true if Chrome should use disk instead of /dev/shm for shared memory.
-/// On CI runners and containers, /dev/shm is often too small (64MB default),
-/// which causes Chrome to crash mid-session.
-fn should_disable_dev_shm(existing_args: &[String]) -> bool {
-    if existing_args.iter().any(|a| a == "--disable-dev-shm-usage") {
-        return false;
-    }
-
-    if std::env::var("CI").is_ok() {
-        return true;
-    }
-
-    #[cfg(unix)]
-    {
-        if unsafe { libc::geteuid() } == 0 {
-            return true;
-        }
-        if Path::new("/.dockerenv").exists() || Path::new("/run/.containerenv").exists() {
-            return true;
-        }
-        if let Ok(cgroup) = std::fs::read_to_string("/proc/1/cgroup") {
-            if cgroup.contains("docker") || cgroup.contains("kubepods") || cgroup.contains("lxc") {
-                return true;
-            }
-        }
-    }
-
-    false
-}
-
-/// Search Puppeteer's browser cache for a Chrome binary.
-/// Puppeteer v19+ stores Chrome in ~/.cache/puppeteer/chrome/<platform>-<version>/
-fn find_puppeteer_chrome() -> Option<PathBuf> {
-    let mut search_dirs = Vec::new();
-
-    if let Ok(custom) = std::env::var("PUPPETEER_CACHE_DIR") {
-        search_dirs.push(PathBuf::from(custom).join("chrome"));
-    }
-
-    if let Some(home) = dirs::home_dir() {
-        search_dirs.push(home.join(".cache/puppeteer/chrome"));
-    }
-
-    for dir in &search_dirs {
-        if !dir.is_dir() {
-            continue;
-        }
-        if let Ok(entries) = std::fs::read_dir(dir) {
-            let mut matches: Vec<PathBuf> = entries
-                .filter_map(|e| e.ok())
-                .filter(|e| e.path().is_dir())
-                .filter_map(|e| {
-                    let candidate = build_puppeteer_binary_path(&e.path());
-                    if candidate.exists() {
-                        Some(candidate)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            matches.sort();
-            matches.reverse();
-            if let Some(p) = matches.into_iter().next() {
-                return Some(p);
-            }
-        }
-    }
-
-    None
-}
-
-#[cfg(target_os = "linux")]
-fn build_puppeteer_binary_path(version_dir: &Path) -> PathBuf {
-    version_dir.join("chrome-linux64/chrome")
-}
-
-#[cfg(target_os = "macos")]
-fn build_puppeteer_binary_path(version_dir: &Path) -> PathBuf {
-    // Puppeteer uses chrome-mac-arm64 or chrome-mac-x64 depending on arch
-    let arm = version_dir.join(
-        "chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing",
-    );
-    if arm.exists() {
-        return arm;
-    }
-    version_dir.join(
-        "chrome-mac-x64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing",
-    )
-}
-
-#[cfg(target_os = "windows")]
-fn build_puppeteer_binary_path(version_dir: &Path) -> PathBuf {
-    version_dir.join(r"chrome-win64\chrome.exe")
-}
-
-#[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
-fn build_puppeteer_binary_path(version_dir: &Path) -> PathBuf {
-    version_dir.join("chrome")
-}
-
 /// Search Playwright's browser cache for a Chromium binary.
-/// Legacy fallback for users who previously installed Chromium via Playwright.
+/// This is where `agent-browser install` (via `npx playwright install chromium`) puts it.
 fn find_playwright_chromium() -> Option<PathBuf> {
     let mut search_dirs = Vec::new();
 
@@ -855,29 +559,6 @@ fn expand_tilde(path: &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::EnvGuard;
-
-    #[cfg(unix)]
-    fn spawn_noop_child() -> Child {
-        Command::new("/bin/sh")
-            .args(["-c", "exit 0"])
-            .stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .spawn()
-            .unwrap()
-    }
-
-    #[cfg(windows)]
-    fn spawn_noop_child() -> Child {
-        Command::new("cmd.exe")
-            .args(["/C", "exit 0"])
-            .stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .spawn()
-            .unwrap()
-    }
 
     #[test]
     fn test_find_chrome_returns_some_on_host() {
@@ -919,8 +600,6 @@ mod tests {
     fn test_chrome_launch_error_no_stderr() {
         let msg = chrome_launch_error("Chrome exited", &[]);
         assert!(msg.contains("no stderr output"));
-        assert!(msg.contains("Hint:"));
-        assert!(msg.contains("--no-sandbox"));
     }
 
     #[test]
@@ -937,211 +616,20 @@ mod tests {
 
     #[test]
     fn test_chrome_launch_error_generic() {
-        let lines = vec!["info line".to_string(), "another info line".to_string()];
+        let lines = vec![
+            "info line".to_string(),
+            "another info line".to_string(),
+        ];
         let msg = chrome_launch_error("Chrome exited", &lines);
         assert!(msg.contains("last 2 lines"));
     }
 
     #[test]
     fn test_find_playwright_chromium_nonexistent() {
-        let guard = EnvGuard::new(&["PLAYWRIGHT_BROWSERS_PATH", "HOME", "USERPROFILE"]);
-        guard.set("PLAYWRIGHT_BROWSERS_PATH", "/nonexistent/path");
-
-        let temp_home = std::env::temp_dir().join(format!(
-            "agent-browser-test-home-{}-{}",
-            std::process::id(),
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .expect("system clock should be after unix epoch")
-                .as_nanos()
-        ));
-        std::fs::create_dir_all(&temp_home).expect("temp home should be created");
-        let temp_home = temp_home.to_string_lossy().to_string();
-        guard.set("HOME", &temp_home);
-        guard.set("USERPROFILE", &temp_home);
-
+        // With no Playwright cache, should return None
+        std::env::set_var("PLAYWRIGHT_BROWSERS_PATH", "/nonexistent/path");
         let result = find_playwright_chromium();
+        std::env::remove_var("PLAYWRIGHT_BROWSERS_PATH");
         assert!(result.is_none());
     }
-
-    #[test]
-    fn test_build_args_headless_includes_headless_flag() {
-        let opts = LaunchOptions {
-            headless: true,
-            ..Default::default()
-        };
-        let result = build_chrome_args(&opts).unwrap();
-        assert!(result.args.iter().any(|a| a == "--headless=new"));
-        assert!(result
-            .args
-            .iter()
-            .any(|a| a == "--enable-unsafe-swiftshader"));
-        assert!(result.args.iter().any(|a| a == "--window-size=1280,720"));
-        // Temp dir created when no profile
-        assert!(result.temp_user_data_dir.is_some());
-        let dir = result.temp_user_data_dir.unwrap();
-        assert!(dir.exists());
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn test_build_args_headed_no_headless_flag() {
-        let opts = LaunchOptions {
-            headless: false,
-            ..Default::default()
-        };
-        let result = build_chrome_args(&opts).unwrap();
-        assert!(!result.args.iter().any(|a| a.contains("--headless")));
-        assert!(!result
-            .args
-            .iter()
-            .any(|a| a == "--enable-unsafe-swiftshader"));
-        assert!(!result.args.iter().any(|a| a.starts_with("--window-size=")));
-        // Temp dir created when no profile
-        assert!(result.temp_user_data_dir.is_some());
-        let dir = result.temp_user_data_dir.unwrap();
-        assert!(dir.exists());
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn test_build_args_temp_user_data_dir_created() {
-        let opts = LaunchOptions::default();
-        let result = build_chrome_args(&opts).unwrap();
-        let dir = result.temp_user_data_dir.as_ref().unwrap();
-        assert!(dir.exists());
-        assert!(result
-            .args
-            .iter()
-            .any(|a| a.starts_with("--user-data-dir=")));
-        let _ = std::fs::remove_dir_all(dir);
-    }
-
-    #[test]
-    fn test_build_args_profile_no_temp_dir() {
-        let opts = LaunchOptions {
-            profile: Some("/tmp/my-profile".to_string()),
-            ..Default::default()
-        };
-        let result = build_chrome_args(&opts).unwrap();
-        assert!(result.temp_user_data_dir.is_none());
-        assert!(result
-            .args
-            .iter()
-            .any(|a| a == "--user-data-dir=/tmp/my-profile"));
-    }
-
-    #[test]
-    fn test_build_args_custom_window_size_not_overridden() {
-        let opts = LaunchOptions {
-            headless: true,
-            args: vec!["--window-size=1920,1080".to_string()],
-            ..Default::default()
-        };
-        let result = build_chrome_args(&opts).unwrap();
-        assert!(!result.args.iter().any(|a| a == "--window-size=1280,720"));
-        assert!(result.args.iter().any(|a| a == "--window-size=1920,1080"));
-        if let Some(ref dir) = result.temp_user_data_dir {
-            let _ = std::fs::remove_dir_all(dir);
-        }
-    }
-
-    #[test]
-    fn test_build_args_start_maximized_suppresses_default_window_size() {
-        let opts = LaunchOptions {
-            headless: true,
-            args: vec!["--start-maximized".to_string()],
-            ..Default::default()
-        };
-        let result = build_chrome_args(&opts).unwrap();
-        assert!(!result.args.iter().any(|a| a == "--window-size=1280,720"));
-        assert!(result.args.iter().any(|a| a == "--start-maximized"));
-        if let Some(ref dir) = result.temp_user_data_dir {
-            let _ = std::fs::remove_dir_all(dir);
-        }
-    }
-
-    #[test]
-    fn test_build_args_disables_translate() {
-        let opts = LaunchOptions::default();
-        let result = build_chrome_args(&opts).unwrap();
-        assert!(result
-            .args
-            .iter()
-            .any(|a| a.contains("--disable-features") && a.contains("Translate")));
-        if let Some(ref dir) = result.temp_user_data_dir {
-            let _ = std::fs::remove_dir_all(dir);
-        }
-    }
-
-    #[test]
-    fn test_build_args_headless_with_extensions_skips_headless_flag() {
-        let opts = LaunchOptions {
-            headless: true,
-            extensions: Some(vec!["/tmp/my-ext".to_string()]),
-            ..Default::default()
-        };
-        let result = build_chrome_args(&opts).unwrap();
-        assert!(
-            !result.args.iter().any(|a| a.contains("--headless")),
-            "headless flag should be omitted when extensions are present"
-        );
-        assert!(
-            !result.args.iter().any(|a| a.contains("--window-size")),
-            "window-size should be omitted when extensions force headed mode"
-        );
-        assert!(result
-            .args
-            .iter()
-            .any(|a| a.starts_with("--load-extension=")));
-        if let Some(ref dir) = result.temp_user_data_dir {
-            let _ = std::fs::remove_dir_all(dir);
-        }
-    }
-
-    #[test]
-    fn test_build_args_headed_with_extensions_no_headless_flag() {
-        let opts = LaunchOptions {
-            headless: false,
-            extensions: Some(vec!["/tmp/my-ext".to_string()]),
-            ..Default::default()
-        };
-        let result = build_chrome_args(&opts).unwrap();
-        assert!(
-            !result.args.iter().any(|a| a.contains("--headless")),
-            "headless flag should not be present in headed mode"
-        );
-        assert!(result
-            .args
-            .iter()
-            .any(|a| a.starts_with("--load-extension=")));
-        if let Some(ref dir) = result.temp_user_data_dir {
-            let _ = std::fs::remove_dir_all(dir);
-        }
-    }
-
-    #[test]
-    fn test_chrome_process_drop_cleans_temp_dir() {
-        let dir = std::env::temp_dir().join(format!(
-            "agent-browser-chrome-drop-test-{}",
-            uuid::Uuid::new_v4()
-        ));
-        let _ = std::fs::create_dir_all(&dir);
-        assert!(dir.exists());
-
-        {
-            // Simulate a ChromeProcess with a temp dir but a dummy child.
-            // We can't actually spawn Chrome here, but we can verify the Drop
-            // logic by creating a small helper process.
-            let child = spawn_noop_child();
-            let _process = ChromeProcess {
-                child,
-                ws_url: String::new(),
-                temp_user_data_dir: Some(dir.clone()),
-            };
-            // _process dropped here
-        }
-
-        assert!(!dir.exists(), "Temp dir should be cleaned up on drop");
-    }
 }

cli/src/native/cdp/client.rs

@@ -1,31 +1,17 @@
 use std::collections::HashMap;
-use std::io::Write;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 
 use futures_util::{SinkExt, StreamExt};
 use serde_json::Value;
 use tokio::sync::{broadcast, oneshot, Mutex};
-use tokio_tungstenite::tungstenite::client::IntoClientRequest;
-use tokio_tungstenite::tungstenite::protocol::WebSocketConfig;
+use tokio_tungstenite::connect_async;
 use tokio_tungstenite::tungstenite::Message;
 
 use super::types::{CdpCommand, CdpEvent, CdpMessage};
 
 type PendingMap = Arc<Mutex<HashMap<u64, oneshot::Sender<CdpMessage>>>>;
 
-/// Interval between WebSocket ping frames sent to keep the connection alive
-/// through intermediate proxies (reverse proxies, load balancers, service meshes).
-const WS_KEEPALIVE_INTERVAL_SECS: u64 = 30;
-
-/// Raw incoming CDP message (text) broadcast to all subscribers.
-/// Used by the inspect proxy to forward responses and events to DevTools.
-#[derive(Debug, Clone)]
-pub struct RawCdpMessage {
-    pub text: String,
-    pub session_id: Option<String>,
-}
-
 pub struct CdpClient {
     ws_tx: Arc<
         Mutex<
@@ -40,110 +26,35 @@ pub struct CdpClient {
     next_id: AtomicU64,
     pending: PendingMap,
     event_tx: broadcast::Sender<CdpEvent>,
-    raw_tx: broadcast::Sender<RawCdpMessage>,
     _reader_handle: tokio::task::JoinHandle<()>,
-    _keepalive_handle: tokio::task::JoinHandle<()>,
 }
 
 impl CdpClient {
     pub async fn connect(url: &str) -> Result<Self, String> {
-        Self::connect_with_headers(url, None).await
-    }
-
-    pub async fn connect_with_headers(
-        url: &str,
-        headers: Option<Vec<(String, String)>>,
-    ) -> Result<Self, String> {
-        let mut request = url
-            .into_client_request()
-            .map_err(|e| format!("Invalid WebSocket URL: {}", e))?;
-
-        if let Some(hdrs) = headers {
-            let req_headers = request.headers_mut();
-            for (key, value) in hdrs {
-                if let (Ok(name), Ok(val)) = (
-                    key.parse::<tokio_tungstenite::tungstenite::http::header::HeaderName>(),
-                    value.parse::<tokio_tungstenite::tungstenite::http::header::HeaderValue>(),
-                ) {
-                    req_headers.insert(name, val);
-                }
-            }
-        }
-
-        let ws_config = WebSocketConfig {
-            max_message_size: None,
-            max_frame_size: None,
-            ..Default::default()
-        };
-
-        let (ws_stream, _) =
-            tokio_tungstenite::connect_async_with_config(request, Some(ws_config), false)
-                .await
-                .map_err(|e| format!("CDP WebSocket connect failed: {}", e))?;
-
-        enable_tcp_keepalive(ws_stream.get_ref());
+        let (ws_stream, _) = connect_async(url)
+            .await
+            .map_err(|e| format!("CDP WebSocket connect failed: {}", e))?;
 
         let (ws_tx, mut ws_rx) = ws_stream.split();
         let ws_tx = Arc::new(Mutex::new(ws_tx));
 
         let pending: PendingMap = Arc::new(Mutex::new(HashMap::new()));
         let (event_tx, _) = broadcast::channel(256);
-        let (raw_tx, _) = broadcast::channel(512);
 
         let pending_clone = pending.clone();
         let event_tx_clone = event_tx.clone();
-        let raw_tx_clone = raw_tx.clone();
-
-        // Notify used to stop the keepalive task when the reader loop exits.
-        let (cancel_tx, mut cancel_rx) = tokio::sync::watch::channel(false);
 
         let reader_handle = tokio::spawn(async move {
             while let Some(msg) = ws_rx.next().await {
-                // Accept both Text and Binary frames — remote CDP proxies
-                // (e.g. Browserless) may send responses as Binary frames.
                 let msg = match msg {
                     Ok(Message::Text(text)) => text,
-                    Ok(Message::Binary(data)) => match String::from_utf8(data) {
-                        Ok(text) => text,
-                        Err(_) => continue,
-                    },
-                    Ok(Message::Close(frame)) => {
-                        if std::env::var("AGENT_BROWSER_DEBUG").is_ok() {
-                            let reason = frame
-                                .as_ref()
-                                .map(|f| format!("code={}, reason={}", f.code, f.reason))
-                                .unwrap_or_else(|| "no frame".to_string());
-                            let _ =
-                                writeln!(std::io::stderr(), "[cdp] WebSocket Close: {}", reason);
-                        }
-                        break;
-                    }
-                    Ok(Message::Pong(_)) => continue,
+                    Ok(Message::Close(_)) => break,
                     Ok(_) => continue,
-                    Err(e) => {
-                        if std::env::var("AGENT_BROWSER_DEBUG").is_ok() {
-                            let _ = writeln!(std::io::stderr(), "[cdp] WebSocket Error: {}", e);
-                        }
-                        break;
-                    }
+                    Err(_) => break,
                 };
 
-                // Broadcast raw message for inspect proxy subscribers before typed parse,
-                // so messages with negative IDs (used by the inspect proxy) are still delivered.
-                if raw_tx_clone.receiver_count() > 0 {
-                    let session_id = serde_json::from_str::<serde_json::Value>(&msg)
-                        .ok()
-                        .and_then(|v| v.get("sessionId")?.as_str().map(String::from));
-                    let _ = raw_tx_clone.send(RawCdpMessage {
-                        text: msg.clone(),
-                        session_id,
-                    });
-                }
-
                 let parsed: CdpMessage = match serde_json::from_str(&msg) {
                     Ok(m) => m,
-                    // Expected for inspect proxy messages with negative IDs
-                    // (CdpMessage.id is u64); handled via raw broadcast above.
                     Err(_) => continue,
                 };
 
@@ -163,33 +74,6 @@ impl CdpClient {
                     let _ = event_tx_clone.send(event);
                 }
             }
-
-            // Reader loop exited (connection closed or error). Drop all pending
-            // command senders so callers get an immediate channel-closed error
-            // instead of waiting for the 30-second timeout.
-            pending_clone.lock().await.clear();
-
-            // Stop the keepalive task — the connection is gone.
-            let _ = cancel_tx.send(true);
-        });
-
-        // Spawn a keepalive task that sends WebSocket Ping frames at a regular
-        // interval. This prevents intermediate proxies (Envoy, nginx, OpenResty,
-        // cloud load balancers) from closing idle WebSocket connections. If the
-        // send fails, the connection is dead and we stop pinging.
-        let keepalive_tx = ws_tx.clone();
-        let keepalive_handle = tokio::spawn(async move {
-            let interval = std::time::Duration::from_secs(WS_KEEPALIVE_INTERVAL_SECS);
-            loop {
-                tokio::select! {
-                    _ = tokio::time::sleep(interval) => {}
-                    _ = cancel_rx.changed() => break,
-                }
-                let mut tx = keepalive_tx.lock().await;
-                if tx.send(Message::Ping(Vec::new())).await.is_err() {
-                    break;
-                }
-            }
         });
 
         Ok(Self {
@@ -197,9 +81,7 @@ impl CdpClient {
             next_id: AtomicU64::new(1),
             pending,
             event_tx,
-            raw_tx,
             _reader_handle: reader_handle,
-            _keepalive_handle: keepalive_handle,
         })
     }
 
@@ -215,7 +97,7 @@ impl CdpClient {
             id,
             method: method.to_string(),
             params,
-            session_id: session_id.filter(|s| !s.is_empty()).map(|s| s.to_string()),
+            session_id: session_id.map(|s| s.to_string()),
         };
 
         let json = serde_json::to_string(&cmd)
@@ -256,21 +138,6 @@ impl CdpClient {
         self.event_tx.subscribe()
     }
 
-    /// Subscribe to all raw incoming CDP messages (responses + events).
-    /// Used by the inspect proxy to forward traffic to the DevTools frontend.
-    pub fn subscribe_raw(&self) -> broadcast::Receiver<RawCdpMessage> {
-        self.raw_tx.subscribe()
-    }
-
-    /// Create a lightweight handle for the inspect WebSocket proxy.
-    /// Contains only what's needed to forward messages bidirectionally.
-    pub fn inspect_handle(&self) -> InspectProxyHandle {
-        InspectProxyHandle {
-            ws_tx: self.ws_tx.clone(),
-            raw_tx: self.raw_tx.clone(),
-        }
-    }
-
     pub async fn send_command_typed<P: serde::Serialize, R: serde::de::DeserializeOwned>(
         &self,
         method: &str,
@@ -293,69 +160,4 @@ impl CdpClient {
     ) -> Result<Value, String> {
         self.send_command(method, None, session_id).await
     }
-
-    /// Send raw JSON through the WebSocket without tracking a response.
-    /// Used by the inspect proxy to forward DevTools frontend messages.
-    pub async fn send_raw(&self, json: String) -> Result<(), String> {
-        let mut ws_tx = self.ws_tx.lock().await;
-        ws_tx
-            .send(Message::Text(json))
-            .await
-            .map_err(|e| format!("Failed to send raw CDP message: {}", e))
-    }
-}
-
-type WsTx = Arc<
-    Mutex<
-        futures_util::stream::SplitSink<
-            tokio_tungstenite::WebSocketStream<
-                tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
-            >,
-            Message,
-        >,
-    >,
->;
-
-/// Lightweight handle for the inspect WebSocket proxy, holding only
-/// the cloneable parts of CdpClient needed for bidirectional message forwarding.
-pub struct InspectProxyHandle {
-    ws_tx: WsTx,
-    raw_tx: broadcast::Sender<RawCdpMessage>,
-}
-
-impl InspectProxyHandle {
-    pub async fn send_raw(&self, json: String) -> Result<(), String> {
-        let mut ws_tx = self.ws_tx.lock().await;
-        ws_tx
-            .send(Message::Text(json))
-            .await
-            .map_err(|e| format!("Failed to send raw CDP message: {}", e))
-    }
-
-    pub fn subscribe_raw(&self) -> broadcast::Receiver<RawCdpMessage> {
-        self.raw_tx.subscribe()
-    }
-}
-
-/// Enable TCP SO_KEEPALIVE on the underlying socket of a WebSocket connection.
-/// This is best-effort: failures are silently ignored since the WebSocket-level
-/// Ping keepalive provides the primary connection liveness mechanism.
-fn enable_tcp_keepalive(stream: &tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>) {
-    let tcp_stream = match stream {
-        tokio_tungstenite::MaybeTlsStream::Plain(s) => s,
-        tokio_tungstenite::MaybeTlsStream::Rustls(s) => s.get_ref().0,
-        _ => return,
-    };
-
-    // SockRef borrows the fd without taking ownership.
-    let sock = socket2::SockRef::from(tcp_stream);
-    let keepalive = socket2::TcpKeepalive::new().with_time(std::time::Duration::from_secs(30));
-
-    // with_interval sets TCP_KEEPINTVL — the time between probes after the
-    // first keepalive probe goes unanswered. Available on most platforms
-    // (Linux, macOS, Windows, FreeBSD, etc.) but not OpenBSD or Haiku.
-    #[cfg(not(any(target_os = "openbsd", target_os = "haiku")))]
-    let keepalive = keepalive.with_interval(std::time::Duration::from_secs(10));
-
-    let _ = sock.set_tcp_keepalive(&keepalive);
 }

cli/src/native/cdp/discovery.rs

@@ -1,387 +0,0 @@
-use std::time::Duration;
-
-use futures_util::{SinkExt, StreamExt};
-use tokio_tungstenite::tungstenite::Message;
-
-use super::types::BrowserVersionInfo;
-
-/// Default timeout for CDP discovery HTTP requests.
-const DEFAULT_DISCOVERY_TIMEOUT: Duration = Duration::from_secs(2);
-
-/// Discover the CDP WebSocket URL for the given host and port.
-///
-/// Tries three methods in order: `/json/version`, `/json/list`, and a direct
-/// WebSocket connection to `/devtools/browser`. The returned URL has its
-/// host/port rewritten to match the requested target.
-///
-/// An optional `query` string (without the leading `?`) is appended to the
-/// final WebSocket URL so that user-supplied URL parameters (e.g.
-/// `?mode=Hello`) are forwarded to the remote endpoint.
-pub async fn discover_cdp_url(
-    host: &str,
-    port: u16,
-    query: Option<&str>,
-) -> Result<String, String> {
-    discover_cdp_url_with_timeout(host, port, query, DEFAULT_DISCOVERY_TIMEOUT).await
-}
-
-/// Like [`discover_cdp_url`] but with a custom request timeout.
-pub async fn discover_cdp_url_with_timeout(
-    host: &str,
-    port: u16,
-    query: Option<&str>,
-    timeout: Duration,
-) -> Result<String, String> {
-    // Primary: /json/version (standard path)
-    let version_err = match fetch_cdp_info(host, port, timeout).await {
-        Ok(info) => {
-            if let Some(ws_url) = info.web_socket_debugger_url {
-                return Ok(append_query(&rewrite_ws_host(&ws_url, host, port), query));
-            }
-            format!(
-                "No webSocketDebuggerUrl in /json/version at {}:{}",
-                host, port
-            )
-        }
-        Err(e) => e,
-    };
-
-    // Fallback: /json/list (returns target list; look for the browser target)
-    let list_err = match fetch_cdp_list(host, port, timeout).await {
-        Ok(ws_url) => return Ok(append_query(&rewrite_ws_host(&ws_url, host, port), query)),
-        Err(e) => e,
-    };
-
-    // Final fallback: direct WebSocket at /devtools/browser.
-    // Chrome 136+ with UI-based remote debugging (chrome://inspect) exposes
-    // CDP over WebSocket but does not serve HTTP discovery endpoints.
-    match discover_cdp_ws(host, port, timeout).await {
-        Ok(ws_url) => Ok(append_query(&ws_url, query)),
-        Err(ws_err) => Err(format!(
-            "All CDP discovery methods failed for {}:{}: /json/version: {}; /json/list: {}; WebSocket: {}",
-            host, port, version_err, list_err, ws_err
-        )),
-    }
-}
-
-/// Bracket an IPv6 address for use in URLs. No-op for IPv4 or already-bracketed addresses.
-fn bracket_ipv6(host: &str) -> String {
-    if host.contains(':') && !host.starts_with('[') {
-        format!("[{}]", host)
-    } else {
-        host.to_string()
-    }
-}
-
-/// Fetch `/json/version` from the given host:port and parse the response.
-async fn fetch_cdp_info(
-    host: &str,
-    port: u16,
-    timeout: Duration,
-) -> Result<BrowserVersionInfo, String> {
-    let url = format!("http://{}:{}/json/version", bracket_ipv6(host), port);
-
-    let body = tokio::time::timeout(timeout, reqwest_get_string(&url))
-        .await
-        .map_err(|_| format!("Timeout connecting to CDP at {}:{}", host, port))?
-        .map_err(|e| format!("Failed to connect to CDP at {}:{}: {}", host, port, e))?;
-
-    serde_json::from_str(&body).map_err(|e| format!("Invalid /json/version response: {}", e))
-}
-
-/// Rewrite the host and port in a WebSocket URL to match the target we
-/// actually connected to. Chrome's `/json/version` always returns
-/// `ws://127.0.0.1:<local-port>/...` which is unreachable when the
-/// browser is on a remote machine or behind a port-forward.
-fn rewrite_ws_host(ws_url: &str, host: &str, port: u16) -> String {
-    if let Ok(mut parsed) = url::Url::parse(ws_url) {
-        let _ = parsed.set_host(Some(&bracket_ipv6(host)));
-        let _ = parsed.set_port(Some(port));
-        parsed.to_string()
-    } else {
-        ws_url.to_string()
-    }
-}
-
-/// Append a query string to a URL, preserving any existing query parameters.
-fn append_query(url: &str, query: Option<&str>) -> String {
-    match query {
-        Some(q) if !q.is_empty() => {
-            if let Ok(mut parsed) = url::Url::parse(url) {
-                {
-                    let mut pairs = parsed.query_pairs_mut();
-                    pairs.extend_pairs(url::form_urlencoded::parse(q.as_bytes()));
-                }
-                parsed.to_string()
-            } else {
-                // Fallback: raw string append
-                if url.contains('?') {
-                    format!("{}&{}", url, q)
-                } else {
-                    format!("{}?{}", url, q)
-                }
-            }
-        }
-        _ => url.to_string(),
-    }
-}
-
-/// Fetch `/json/list` and extract the `webSocketDebuggerUrl` from the first
-/// target with `type == "browser"`, or the first target if none has that type.
-async fn fetch_cdp_list(host: &str, port: u16, timeout: Duration) -> Result<String, String> {
-    let url = format!("http://{}:{}/json/list", bracket_ipv6(host), port);
-
-    let body = tokio::time::timeout(timeout, reqwest_get_string(&url))
-        .await
-        .map_err(|_| format!("Timeout connecting to /json/list at {}:{}", host, port))?
-        .map_err(|e| {
-            format!(
-                "Failed to connect to /json/list at {}:{}: {}",
-                host, port, e
-            )
-        })?;
-
-    let targets: Vec<serde_json::Value> =
-        serde_json::from_str(&body).map_err(|e| format!("Invalid /json/list response: {}", e))?;
-
-    // Prefer targets with type "browser", fall back to first target with a ws URL
-    let browser_target = targets
-        .iter()
-        .find(|t| t.get("type").and_then(|v| v.as_str()) == Some("browser"));
-
-    let target = browser_target.or_else(|| targets.first());
-
-    target
-        .and_then(|t| t.get("webSocketDebuggerUrl"))
-        .and_then(|v| v.as_str())
-        .map(|s| s.to_string())
-        .ok_or_else(|| "No webSocketDebuggerUrl found in /json/list targets".to_string())
-}
-
-/// Discover a CDP endpoint by connecting directly to `ws://host:port/devtools/browser`
-/// and verifying it responds to `Browser.getVersion`.
-/// Returns the WebSocket URL on success.
-async fn discover_cdp_ws(host: &str, port: u16, timeout: Duration) -> Result<String, String> {
-    let ws_url = format!("ws://{}:{}/devtools/browser", bracket_ipv6(host), port);
-
-    tokio::time::timeout(timeout, async {
-        let (mut ws_stream, _) = tokio_tungstenite::connect_async(&ws_url)
-            .await
-            .map_err(|e| format!("WebSocket connect failed at {}: {}", ws_url, e))?;
-
-        let cmd = r#"{"id":1,"method":"Browser.getVersion"}"#;
-        ws_stream
-            .send(Message::Text(cmd.into()))
-            .await
-            .map_err(|e| format!("Failed to send command: {}", e))?;
-
-        #[derive(serde::Deserialize)]
-        struct CdpReply {
-            id: u64,
-        }
-
-        let mut result: Result<(), String> = Err("No valid CDP response received".to_string());
-        while let Some(msg) = ws_stream.next().await {
-            match msg {
-                Ok(Message::Text(text)) => {
-                    if serde_json::from_str::<CdpReply>(&text).is_ok_and(|r| r.id == 1) {
-                        result = Ok(());
-                        break;
-                    }
-                }
-                Ok(Message::Close(_)) | Err(_) => break,
-                _ => continue,
-            }
-        }
-
-        let _ = ws_stream.close(None).await;
-        result
-    })
-    .await
-    .map_err(|_| format!("Timeout connecting to WebSocket at {}", ws_url))?
-    .map(|()| ws_url)
-}
-
-async fn reqwest_get_string(url: &str) -> Result<String, String> {
-    let resp = reqwest::get(url).await.map_err(|e| e.to_string())?;
-    resp.text().await.map_err(|e| e.to_string())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use tokio::io::{AsyncReadExt, AsyncWriteExt};
-    use tokio::net::TcpListener;
-
-    const HTTP_404: &str =
-        "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
-
-    fn http_200(body: &str) -> String {
-        format!(
-            "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\nContent-Type: application/json\r\n\r\n{}",
-            body.len(), body
-        )
-    }
-
-    async fn accept_http(listener: &TcpListener, response: &str) {
-        let (mut s, _) = listener.accept().await.unwrap();
-        let mut buf = [0u8; 1024];
-        let _ = s.read(&mut buf).await;
-        s.write_all(response.as_bytes()).await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn discovers_ws_url_from_json_version() {
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let port = listener.local_addr().unwrap().port();
-        let server = tokio::spawn(async move {
-            accept_http(
-                &listener,
-                &http_200(r#"{"webSocketDebuggerUrl":"ws://127.0.0.1:1234/"}"#),
-            )
-            .await;
-        });
-
-        let ws_url = discover_cdp_url("127.0.0.1", port, None).await.unwrap();
-        assert_eq!(ws_url, format!("ws://127.0.0.1:{}/", port));
-        server.await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn returns_error_when_version_returns_invalid_json() {
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let port = listener.local_addr().unwrap().port();
-        let server = tokio::spawn(async move {
-            accept_http(&listener, &http_200("not-json")).await;
-            // /json/list and ws fallback both fail (server closes)
-        });
-
-        let err = discover_cdp_url("127.0.0.1", port, None).await.unwrap_err();
-        assert!(err.contains("Invalid /json/version response"));
-        server.await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn falls_back_to_json_list_on_version_404() {
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let port = listener.local_addr().unwrap().port();
-        let server = tokio::spawn(async move {
-            accept_http(&listener, HTTP_404).await;
-            accept_http(
-                &listener,
-                &http_200(r#"[{"type":"browser","webSocketDebuggerUrl":"ws://127.0.0.1:1234/devtools/browser/abc"}]"#),
-            ).await;
-        });
-
-        let ws_url = discover_cdp_url("127.0.0.1", port, None).await.unwrap();
-        assert!(ws_url.contains("/devtools/browser/abc"));
-        assert!(ws_url.contains(&port.to_string()));
-        server.await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn falls_back_to_ws_when_http_returns_404() {
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let port = listener.local_addr().unwrap().port();
-        let server = tokio::spawn(async move {
-            // /json/version -> 404, /json/list -> 404
-            accept_http(&listener, HTTP_404).await;
-            accept_http(&listener, HTTP_404).await;
-
-            // WebSocket handshake + respond to Browser.getVersion
-            let (stream, _) = listener.accept().await.unwrap();
-            let mut ws = tokio_tungstenite::accept_async(stream).await.unwrap();
-            if let Some(Ok(Message::Text(text))) = ws.next().await {
-                let req: serde_json::Value = serde_json::from_str(&text).unwrap();
-                let id = req.get("id").unwrap();
-                let reply = format!(
-                    r#"{{"id":{},"result":{{"protocolVersion":"1.3","product":"Chrome/136"}}}}"#,
-                    id
-                );
-                ws.send(Message::Text(reply)).await.unwrap();
-            }
-            let _ = ws.close(None).await;
-        });
-
-        let ws_url = discover_cdp_url("127.0.0.1", port, None).await.unwrap();
-        assert_eq!(ws_url, format!("ws://127.0.0.1:{}/devtools/browser", port));
-        server.await.unwrap();
-    }
-
-    #[test]
-    fn rewrite_ws_host_replaces_host_and_port() {
-        let original = "ws://127.0.0.1:9222/devtools/browser/abc";
-        let rewritten = rewrite_ws_host(original, "10.211.55.12", 9223);
-        assert_eq!(rewritten, "ws://10.211.55.12:9223/devtools/browser/abc");
-    }
-
-    #[test]
-    fn rewrite_ws_host_handles_ipv6() {
-        let original = "ws://127.0.0.1:9222/devtools/browser/abc";
-        let rewritten = rewrite_ws_host(original, "::1", 9222);
-        assert_eq!(rewritten, "ws://[::1]:9222/devtools/browser/abc");
-    }
-
-    #[test]
-    fn append_query_adds_params_to_url_without_query() {
-        let url = "ws://127.0.0.1:9222/devtools/browser/abc";
-        let result = append_query(url, Some("mode=Hello"));
-        assert_eq!(
-            result,
-            "ws://127.0.0.1:9222/devtools/browser/abc?mode=Hello"
-        );
-    }
-
-    #[test]
-    fn append_query_merges_with_existing_query() {
-        let url = "ws://127.0.0.1:9222/devtools/browser/abc?token=xyz";
-        let result = append_query(url, Some("mode=Hello"));
-        assert_eq!(
-            result,
-            "ws://127.0.0.1:9222/devtools/browser/abc?token=xyz&mode=Hello"
-        );
-    }
-
-    #[test]
-    fn append_query_noop_for_none() {
-        let url = "ws://127.0.0.1:9222/devtools/browser/abc";
-        let result = append_query(url, None);
-        assert_eq!(result, url);
-    }
-
-    #[test]
-    fn append_query_noop_for_empty() {
-        let url = "ws://127.0.0.1:9222/devtools/browser/abc";
-        let result = append_query(url, Some(""));
-        assert_eq!(result, url);
-    }
-
-    #[test]
-    fn append_query_handles_multiple_params() {
-        let url = "ws://127.0.0.1:9222/devtools/browser/abc";
-        let result = append_query(url, Some("mode=Hello&token=abc"));
-        assert_eq!(
-            result,
-            "ws://127.0.0.1:9222/devtools/browser/abc?mode=Hello&token=abc"
-        );
-    }
-
-    #[tokio::test]
-    async fn discover_preserves_query_params() {
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let port = listener.local_addr().unwrap().port();
-        let server = tokio::spawn(async move {
-            accept_http(
-                &listener,
-                &http_200(r#"{"webSocketDebuggerUrl":"ws://127.0.0.1:1234/"}"#),
-            )
-            .await;
-        });
-
-        let ws_url = discover_cdp_url("127.0.0.1", port, Some("mode=Hello"))
-            .await
-            .unwrap();
-        assert_eq!(ws_url, format!("ws://127.0.0.1:{}/?mode=Hello", port));
-        server.await.unwrap();
-    }
-}

cli/src/native/cdp/lightpanda.rs

@@ -1,495 +0,0 @@
-use std::collections::VecDeque;
-use std::io::{BufRead, BufReader};
-use std::net::TcpListener;
-use std::path::PathBuf;
-use std::process::{Child, Command, Stdio};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-use super::discovery::discover_cdp_url_with_timeout;
-
-const LIGHTPANDA_STARTUP_TIMEOUT: Duration = Duration::from_secs(10);
-const LIGHTPANDA_POLL_INTERVAL: Duration = Duration::from_millis(100);
-const LIGHTPANDA_DISCOVERY_TIMEOUT: Duration = Duration::from_millis(500);
-const LIGHTPANDA_SESSION_TIMEOUT_SECS: u64 = 604800; // 1 week, the documented maximum
-const MAX_LOG_LINES: usize = 40;
-
-pub struct LightpandaProcess {
-    child: Child,
-    pub ws_url: String,
-    _log_drainers: Vec<std::thread::JoinHandle<()>>,
-}
-
-impl LightpandaProcess {
-    pub fn kill(&mut self) {
-        let _ = self.child.kill();
-        let _ = self.child.wait();
-    }
-}
-
-impl Drop for LightpandaProcess {
-    fn drop(&mut self) {
-        self.kill();
-    }
-}
-
-#[derive(Default)]
-pub struct LightpandaLaunchOptions {
-    pub executable_path: Option<String>,
-    pub proxy: Option<String>,
-    pub port: Option<u16>,
-}
-
-fn build_lightpanda_serve_args(port: u16, proxy: Option<&str>) -> Vec<String> {
-    let mut args = vec![
-        "serve".to_string(),
-        "--host".to_string(),
-        "127.0.0.1".to_string(),
-        "--port".to_string(),
-        port.to_string(),
-        "--timeout".to_string(),
-        LIGHTPANDA_SESSION_TIMEOUT_SECS.to_string(),
-    ];
-
-    if let Some(proxy) = proxy {
-        args.push("--http_proxy".to_string());
-        args.push(proxy.to_string());
-    }
-
-    args
-}
-
-#[derive(Clone, Default)]
-struct LaunchLogBuffer {
-    stdout: Arc<Mutex<VecDeque<String>>>,
-    stderr: Arc<Mutex<VecDeque<String>>>,
-}
-
-impl LaunchLogBuffer {
-    fn push_stdout(&self, line: String) {
-        push_bounded(&self.stdout, line);
-    }
-
-    fn push_stderr(&self, line: String) {
-        push_bounded(&self.stderr, line);
-    }
-
-    fn snapshot_stdout(&self) -> Vec<String> {
-        self.stdout
-            .lock()
-            .expect("stdout log buffer poisoned")
-            .iter()
-            .cloned()
-            .collect()
-    }
-
-    fn snapshot_stderr(&self) -> Vec<String> {
-        self.stderr
-            .lock()
-            .expect("stderr log buffer poisoned")
-            .iter()
-            .cloned()
-            .collect()
-    }
-}
-
-fn push_bounded(buffer: &Mutex<VecDeque<String>>, line: String) {
-    let mut guard = buffer.lock().expect("log buffer poisoned");
-    if guard.len() >= MAX_LOG_LINES {
-        guard.pop_front();
-    }
-    guard.push_back(line);
-}
-
-pub fn find_lightpanda() -> Option<PathBuf> {
-    #[cfg(unix)]
-    {
-        if let Ok(output) = Command::new("which").arg("lightpanda").output() {
-            if output.status.success() {
-                let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
-                if !path.is_empty() {
-                    return Some(PathBuf::from(path));
-                }
-            }
-        }
-    }
-
-    #[cfg(windows)]
-    {
-        if let Ok(output) = Command::new("where").arg("lightpanda").output() {
-            if output.status.success() {
-                let path = String::from_utf8_lossy(&output.stdout)
-                    .lines()
-                    .next()
-                    .unwrap_or("")
-                    .trim()
-                    .to_string();
-                if !path.is_empty() {
-                    return Some(PathBuf::from(path));
-                }
-            }
-        }
-    }
-
-    if let Some(home) = dirs::home_dir() {
-        let candidates = [
-            home.join(".lightpanda/lightpanda"),
-            home.join(".local/bin/lightpanda"),
-        ];
-        for c in &candidates {
-            if c.exists() {
-                return Some(c.clone());
-            }
-        }
-    }
-
-    None
-}
-
-pub async fn launch_lightpanda(
-    options: &LightpandaLaunchOptions,
-) -> Result<LightpandaProcess, String> {
-    let binary_path = match &options.executable_path {
-        Some(p) => PathBuf::from(p),
-        None => find_lightpanda().ok_or(
-            "Lightpanda not found. Install it from https://lightpanda.io/docs/open-source/installation or use --executable-path.",
-        )?,
-    };
-
-    let port = match options.port {
-        Some(p) => p,
-        None => TcpListener::bind("127.0.0.1:0")
-            .and_then(|l| l.local_addr())
-            .map(|a| a.port())
-            .map_err(|e| format!("Failed to find an available port for Lightpanda: {}", e))?,
-    };
-    let args = build_lightpanda_serve_args(port, options.proxy.as_deref());
-
-    let mut child = Command::new(&binary_path)
-        .args(&args)
-        .stdin(Stdio::null())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .spawn()
-        .map_err(|e| format!("Failed to launch Lightpanda at {:?}: {}", binary_path, e))?;
-
-    let (log_buffer, log_drainers) = start_log_drainers(&mut child)?;
-
-    let ws_url =
-        match wait_for_lightpanda_ready(&mut child, port, &log_buffer, LIGHTPANDA_STARTUP_TIMEOUT)
-            .await
-        {
-            Ok(url) => url,
-            Err(e) => {
-                let _ = child.kill();
-                let _ = child.wait();
-                return Err(e);
-            }
-        };
-
-    Ok(LightpandaProcess {
-        child,
-        ws_url,
-        _log_drainers: log_drainers,
-    })
-}
-
-fn start_log_drainers(
-    child: &mut Child,
-) -> Result<(LaunchLogBuffer, Vec<std::thread::JoinHandle<()>>), String> {
-    let stdout = child.stdout.take().ok_or_else(|| {
-        let _ = child.kill();
-        "Failed to capture Lightpanda stdout".to_string()
-    })?;
-    let stderr = child.stderr.take().ok_or_else(|| {
-        let _ = child.kill();
-        "Failed to capture Lightpanda stderr".to_string()
-    })?;
-
-    let logs = LaunchLogBuffer::default();
-    let stdout_logs = logs.clone();
-    let stderr_logs = logs.clone();
-
-    let stdout_handle =
-        std::thread::spawn(move || drain_reader(stdout, move |line| stdout_logs.push_stdout(line)));
-    let stderr_handle =
-        std::thread::spawn(move || drain_reader(stderr, move |line| stderr_logs.push_stderr(line)));
-
-    Ok((logs, vec![stdout_handle, stderr_handle]))
-}
-
-fn drain_reader<R, F>(reader: R, mut push: F)
-where
-    R: std::io::Read,
-    F: FnMut(String),
-{
-    for line in BufReader::new(reader).lines() {
-        match line {
-            Ok(line) => push(line),
-            Err(_) => break,
-        }
-    }
-}
-
-async fn wait_for_lightpanda_ready(
-    child: &mut Child,
-    port: u16,
-    logs: &LaunchLogBuffer,
-    startup_timeout: Duration,
-) -> Result<String, String> {
-    let deadline = std::time::Instant::now() + startup_timeout;
-    let mut last_probe_error = None;
-
-    loop {
-        if let Ok(Some(status)) = child.try_wait() {
-            // Give the drainer threads a brief window to flush the last log lines
-            // before we snapshot them.  This is best-effort: lines written just
-            // before exit may still be missing, but the most useful output (early
-            // startup errors) will already be in the buffer.
-            tokio::time::sleep(Duration::from_millis(25)).await;
-            return Err(lightpanda_launch_error(
-                &format!(
-                    "Lightpanda exited before CDP became ready (status: {})",
-                    status
-                ),
-                logs,
-                last_probe_error.as_deref(),
-            ));
-        }
-
-        match discover_cdp_url_with_timeout("127.0.0.1", port, None, LIGHTPANDA_DISCOVERY_TIMEOUT)
-            .await
-        {
-            Ok(ws_url) => return Ok(ws_url),
-            Err(err) => last_probe_error = Some(err),
-        }
-
-        if std::time::Instant::now() >= deadline {
-            return Err(lightpanda_launch_error(
-                &format!(
-                    "Timed out after {}ms waiting for Lightpanda CDP endpoint on port {}",
-                    startup_timeout.as_millis(),
-                    port
-                ),
-                logs,
-                last_probe_error.as_deref(),
-            ));
-        }
-
-        tokio::time::sleep(LIGHTPANDA_POLL_INTERVAL).await;
-    }
-}
-
-fn lightpanda_launch_error(
-    message: &str,
-    logs: &LaunchLogBuffer,
-    last_probe_error: Option<&str>,
-) -> String {
-    let stdout_lines = logs.snapshot_stdout();
-    let stderr_lines = logs.snapshot_stderr();
-    let mut details = Vec::new();
-
-    if let Some(err) = last_probe_error {
-        details.push(format!("Last probe error: {}", err));
-    }
-
-    if !stderr_lines.is_empty() {
-        details.push(format!(
-            "Lightpanda stderr (last {} lines):\n  {}",
-            stderr_lines.len(),
-            stderr_lines.join("\n  ")
-        ));
-    }
-
-    if !stdout_lines.is_empty() {
-        details.push(format!(
-            "Lightpanda stdout (last {} lines):\n  {}",
-            stdout_lines.len(),
-            stdout_lines.join("\n  ")
-        ));
-    }
-
-    if details.is_empty() {
-        format!("{} (no stdout/stderr output from Lightpanda)", message)
-    } else {
-        format!("{}\n{}", message, details.join("\n"))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use tokio::io::{AsyncReadExt, AsyncWriteExt};
-    use tokio::net::TcpListener as TokioTcpListener;
-
-    fn unused_port() -> u16 {
-        std::net::TcpListener::bind("127.0.0.1:0")
-            .unwrap()
-            .local_addr()
-            .unwrap()
-            .port()
-    }
-
-    async fn serve_json_version_once_after_delay(port: u16, delay_ms: u64, body: &'static str) {
-        tokio::time::sleep(Duration::from_millis(delay_ms)).await;
-        let listener = TokioTcpListener::bind(("127.0.0.1", port)).await.unwrap();
-        let (mut socket, _) = listener.accept().await.unwrap();
-        let mut buf = [0u8; 1024];
-        let _ = socket.read(&mut buf).await;
-        let response = format!(
-            "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\nContent-Type: application/json\r\n\r\n{}",
-            body.len(),
-            body
-        );
-        socket.write_all(response.as_bytes()).await.unwrap();
-    }
-
-    #[cfg(unix)]
-    #[tokio::test]
-    async fn waits_for_ready_without_logs() {
-        let port = unused_port();
-        tokio::spawn(serve_json_version_once_after_delay(
-            port,
-            150,
-            r#"{"webSocketDebuggerUrl":"ws://127.0.0.1:9222/"}"#,
-        ));
-
-        let mut child = Command::new("/bin/sh")
-            .args(["-c", "sleep 5"])
-            .stdin(Stdio::null())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .spawn()
-            .unwrap();
-
-        let (logs, _drainers) = start_log_drainers(&mut child).unwrap();
-        let ws_url = wait_for_lightpanda_ready(&mut child, port, &logs, LIGHTPANDA_STARTUP_TIMEOUT)
-            .await
-            .unwrap();
-
-        assert_eq!(ws_url, format!("ws://127.0.0.1:{}/", port));
-        let _ = child.kill();
-        let _ = child.wait();
-    }
-
-    #[cfg(unix)]
-    #[tokio::test]
-    async fn child_exit_surfaces_logs() {
-        let port = unused_port();
-        let mut child = Command::new("/bin/sh")
-            .args(["-c", "echo boom >&2; sleep 0.1; exit 23"])
-            .stdin(Stdio::null())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .spawn()
-            .unwrap();
-
-        let (logs, _drainers) = start_log_drainers(&mut child).unwrap();
-        let err = wait_for_lightpanda_ready(&mut child, port, &logs, LIGHTPANDA_STARTUP_TIMEOUT)
-            .await
-            .unwrap_err();
-
-        assert!(err.contains("Lightpanda exited before CDP became ready"));
-        assert!(err.contains("boom"));
-    }
-
-    #[cfg(unix)]
-    #[tokio::test]
-    async fn timeout_reports_last_probe_error() {
-        let port = unused_port();
-        let mut child = Command::new("/bin/sh")
-            .args(["-c", "sleep 30"])
-            .stdin(Stdio::null())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .spawn()
-            .unwrap();
-
-        let timeout = Duration::from_millis(300);
-        let (logs, _drainers) = start_log_drainers(&mut child).unwrap();
-        let err = tokio::time::timeout(
-            Duration::from_secs(2),
-            wait_for_lightpanda_ready(&mut child, port, &logs, timeout),
-        )
-        .await
-        .expect("ready wait should return before outer timeout")
-        .unwrap_err();
-
-        assert!(err.contains("Timed out after 300ms waiting for Lightpanda CDP endpoint"));
-        assert!(
-            err.contains("Failed to connect to CDP") || err.contains("Timeout connecting to CDP")
-        );
-
-        let _ = child.kill();
-        let _ = child.wait();
-    }
-
-    #[test]
-    fn test_find_lightpanda_returns_none_when_missing() {
-        let _ = find_lightpanda();
-    }
-
-    #[test]
-    fn test_lightpanda_launch_error_no_logs() {
-        let logs = LaunchLogBuffer::default();
-        let msg = lightpanda_launch_error("Lightpanda exited", &logs, None);
-        assert!(msg.contains("no stdout/stderr output"));
-    }
-
-    #[test]
-    fn test_lightpanda_launch_error_with_lines() {
-        let logs = LaunchLogBuffer::default();
-        logs.push_stdout("stdout line".to_string());
-        logs.push_stderr("stderr line".to_string());
-        let msg = lightpanda_launch_error("Lightpanda exited", &logs, Some("connect failed"));
-        assert!(msg.contains("stdout line"));
-        assert!(msg.contains("stderr line"));
-        assert!(msg.contains("Last probe error: connect failed"));
-    }
-
-    #[test]
-    fn test_default_options() {
-        let opts = LightpandaLaunchOptions::default();
-        assert!(opts.executable_path.is_none());
-        assert!(opts.proxy.is_none());
-        assert!(opts.port.is_none());
-    }
-
-    #[test]
-    fn test_build_lightpanda_serve_args_sets_explicit_session_timeout() {
-        let args = build_lightpanda_serve_args(9222, None);
-
-        assert_eq!(
-            args,
-            vec![
-                "serve".to_string(),
-                "--host".to_string(),
-                "127.0.0.1".to_string(),
-                "--port".to_string(),
-                "9222".to_string(),
-                "--timeout".to_string(),
-                "604800".to_string(),
-            ]
-        );
-    }
-
-    #[test]
-    fn test_build_lightpanda_serve_args_with_proxy() {
-        let args = build_lightpanda_serve_args(9333, Some("http://127.0.0.1:8080"));
-
-        assert_eq!(
-            args,
-            vec![
-                "serve".to_string(),
-                "--host".to_string(),
-                "127.0.0.1".to_string(),
-                "--port".to_string(),
-                "9333".to_string(),
-                "--timeout".to_string(),
-                "604800".to_string(),
-                "--http_proxy".to_string(),
-                "http://127.0.0.1:8080".to_string(),
-            ]
-        );
-    }
-}

cli/src/native/cdp/mod.rs

@@ -1,5 +1,3 @@
 pub mod chrome;
 pub mod client;
-pub mod discovery;
-pub mod lightpanda;
 pub mod types;

cli/src/native/cdp/types.rs

@@ -1,51 +1,6 @@
-use serde::{Deserialize, Deserializer, Serialize};
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-/// Deserialize a value that may be either a string or an integer into a String.
-/// Lightpanda sends numeric nodeIds/childIds in AX tree responses, while Chrome
-/// sends strings. This accepts both.
-fn string_or_int<'de, D>(deserializer: D) -> Result<String, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let v = Value::deserialize(deserializer)?;
-    match v {
-        Value::String(s) => Ok(s),
-        Value::Number(n) => Ok(n.to_string()),
-        other => Err(serde::de::Error::custom(format!(
-            "expected string or integer, got {}",
-            other
-        ))),
-    }
-}
-
-/// Deserialize an optional Vec where each element may be a string or integer.
-fn opt_vec_string_or_int<'de, D>(deserializer: D) -> Result<Option<Vec<String>>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let opt: Option<Vec<Value>> = Option::deserialize(deserializer)?;
-    match opt {
-        None => Ok(None),
-        Some(vec) => {
-            let mut result = Vec::with_capacity(vec.len());
-            for v in vec {
-                match v {
-                    Value::String(s) => result.push(s),
-                    Value::Number(n) => result.push(n.to_string()),
-                    other => {
-                        return Err(serde::de::Error::custom(format!(
-                            "expected string or integer in array, got {}",
-                            other
-                        )))
-                    }
-                }
-            }
-            Ok(Some(result))
-        }
-    }
-}
-
 // ---------------------------------------------------------------------------
 // CDP message envelope
 // ---------------------------------------------------------------------------
@@ -260,7 +215,6 @@ pub struct RemoteObject {
     pub object_id: Option<String>,
     pub class_name: Option<String>,
     pub unserializable_value: Option<String>,
-    pub preview: Option<Value>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -303,14 +257,12 @@ pub struct GetFullAXTreeResult {
 #[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct AXNode {
-    #[serde(deserialize_with = "string_or_int")]
     pub node_id: String,
     pub role: Option<AXValue>,
     pub name: Option<AXValue>,
     pub value: Option<AXValue>,
     pub description: Option<AXValue>,
     pub properties: Option<Vec<AXProperty>>,
-    #[serde(default, deserialize_with = "opt_vec_string_or_int")]
     pub child_ids: Option<Vec<String>>,
     pub backend_d_o_m_node_id: Option<i64>,
     pub ignored: Option<bool>,
@@ -580,7 +532,6 @@ pub struct BrowserVersionInfo {
 /// Chromium source) into `cli/cdp-protocol/` and rebuild.
 ///
 /// Usage: `use super::cdp::types::generated::cdp_page::*;`
-#[allow(clippy::upper_case_acronyms)]
 pub mod generated {
     include!(concat!(env!("OUT_DIR"), "/cdp_generated.rs"));
 }

cli/src/native/cookies.rs

@@ -24,19 +24,6 @@ pub struct Cookie {
     pub same_site: Option<String>,
 }
 
-pub async fn get_all_cookies(client: &CdpClient, session_id: &str) -> Result<Vec<Cookie>, String> {
-    let result = client
-        .send_command_no_params("Network.getAllCookies", Some(session_id))
-        .await?;
-
-    let cookies: Vec<Cookie> = result
-        .get("cookies")
-        .and_then(|v| serde_json::from_value(v.clone()).ok())
-        .unwrap_or_default();
-
-    Ok(cookies)
-}
-
 pub async fn get_cookies(
     client: &CdpClient,
     session_id: &str,

cli/src/native/daemon.rs

@@ -1,20 +1,14 @@
 use serde_json::Value;
 use std::env;
 use std::fs;
-use std::io::Write;
 use std::path::PathBuf;
 use std::process;
-use std::sync::Arc;
-use std::time::Duration;
 
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::signal;
-use tokio::sync::{mpsc, RwLock};
 
 use super::actions::{execute_command, DaemonState};
-use super::cdp::client::CdpClient;
 use super::state;
-use super::stream::StreamServer;
 
 pub async fn run_daemon(session: &str) {
     let socket_dir = get_daemon_socket_dir();
@@ -22,50 +16,15 @@ pub async fn run_daemon(session: &str) {
         let _ = fs::create_dir_all(&socket_dir);
     }
 
-    // When debug mode is on, redirect stderr to a log file so daemon
-    // output can be inspected (the daemon normally has stderr piped to its
-    // parent which drops the read end after startup).
-    #[cfg(unix)]
-    if env::var("AGENT_BROWSER_DEBUG").is_ok() {
-        let log_path = socket_dir.join(format!("{}.log", session));
-        if let Ok(file) = fs::File::create(&log_path) {
-            use std::os::unix::io::IntoRawFd;
-            let fd = file.into_raw_fd();
-            unsafe {
-                libc::dup2(fd, 2);
-                libc::close(fd);
-            }
-            let _ = writeln!(
-                std::io::stderr(),
-                "[daemon] Debug logging started for session: {}",
-                session
-            );
-        }
-    }
-
     let pid_path = socket_dir.join(format!("{}.pid", session));
     let _ = fs::write(&pid_path, process::id().to_string());
 
-    // On Unix the daemon listens on a Unix domain socket; on Windows it uses
-    // TCP, so there is no .sock file — only a .port file written by the server.
     let socket_path = socket_dir.join(format!("{}.sock", session));
 
-    #[cfg(unix)]
     if socket_path.exists() {
         let _ = fs::remove_file(&socket_path);
     }
 
-    #[cfg(windows)]
-    {
-        let _ = fs::remove_file(socket_dir.join(format!("{}.port", session)));
-    }
-
-    let stream_path = socket_dir.join(format!("{}.stream", session));
-    let _ = fs::remove_file(&stream_path);
-    let _ = fs::remove_file(socket_dir.join(format!("{}.engine", session)));
-    let _ = fs::remove_file(socket_dir.join(format!("{}.provider", session)));
-    let _ = fs::remove_file(socket_dir.join(format!("{}.extensions", session)));
-
     if let Ok(days_str) = env::var("AGENT_BROWSER_STATE_EXPIRE_DAYS") {
         if let Ok(days) = days_str.parse::<u64>() {
             if days > 0 {
@@ -74,140 +33,44 @@ pub async fn run_daemon(session: &str) {
         }
     }
 
-    let mut stream_client: Option<Arc<RwLock<Option<Arc<CdpClient>>>>> = None;
-    let mut stream_server_instance: Option<Arc<StreamServer>> = None;
-    let preferred_port = env::var("AGENT_BROWSER_STREAM_PORT")
-        .ok()
-        .and_then(|s| s.parse::<u16>().ok())
-        .unwrap_or(0);
-    match StreamServer::start_without_client(preferred_port, session.to_string(), true).await {
-        Ok((stream_server, client_slot)) => {
-            stream_client = Some(client_slot.clone());
-            if let Err(e) = fs::write(&stream_path, stream_server.port().to_string()) {
-                let _ = writeln!(std::io::stderr(), "Failed to write .stream file: {}", e);
-            }
-            stream_server_instance = Some(Arc::new(stream_server));
-        }
-        Err(e) => {
-            let _ = writeln!(std::io::stderr(), "Stream server failed to start: {}", e);
-        }
-    }
+    let result = run_socket_server(&socket_path, session).await;
 
-    // Auto-shutdown the daemon after this many ms of inactivity (no commands received).
-    // Disabled when unset or 0.
-    let idle_timeout_ms = env::var("AGENT_BROWSER_IDLE_TIMEOUT_MS")
-        .ok()
-        .and_then(|s| s.parse::<u64>().ok())
-        .filter(|&ms| ms > 0);
-
-    let result = run_socket_server(
-        &socket_path,
-        session,
-        stream_client,
-        stream_server_instance,
-        idle_timeout_ms,
-    )
-    .await;
-
-    #[cfg(unix)]
-    {
-        let _ = fs::remove_file(&socket_path);
-    }
-    #[cfg(windows)]
-    {
-        let _ = fs::remove_file(socket_dir.join(format!("{}.port", session)));
-    }
+    let _ = fs::remove_file(&socket_path);
     let _ = fs::remove_file(&pid_path);
+    let stream_path = socket_dir.join(format!("{}.stream", session));
     let _ = fs::remove_file(&stream_path);
-    let _ = fs::remove_file(socket_dir.join(format!("{}.engine", session)));
-    let _ = fs::remove_file(socket_dir.join(format!("{}.provider", session)));
-    let _ = fs::remove_file(socket_dir.join(format!("{}.extensions", session)));
 
     if let Err(e) = result {
-        let _ = writeln!(std::io::stderr(), "Daemon error: {}", e);
+        eprintln!("Daemon error: {}", e);
         process::exit(1);
     }
 }
 
 #[cfg(unix)]
-async fn run_socket_server(
-    socket_path: &PathBuf,
-    session: &str,
-    stream_client: Option<Arc<RwLock<Option<Arc<CdpClient>>>>>,
-    stream_server: Option<Arc<StreamServer>>,
-    idle_timeout_ms: Option<u64>,
-) -> Result<(), String> {
+async fn run_socket_server(socket_path: &PathBuf, _session: &str) -> Result<(), String> {
     use tokio::net::UnixListener;
 
     let listener =
         UnixListener::bind(socket_path).map_err(|e| format!("Failed to bind socket: {}", e))?;
 
-    let stream_file: Option<PathBuf> = if stream_server.is_some() {
-        let dir = socket_path.parent().unwrap_or(std::path::Path::new("."));
-        Some(dir.join(format!("{}.stream", session)))
-    } else {
-        None
-    };
-
-    let state: std::sync::Arc<tokio::sync::Mutex<DaemonState>> = std::sync::Arc::new(
-        tokio::sync::Mutex::new(DaemonState::new_with_stream(stream_client, stream_server)),
-    );
-
-    let (reset_tx, mut reset_rx) = mpsc::channel::<()>(64);
-    let reset_tx = idle_timeout_ms.map(|_| Arc::new(reset_tx));
-
-    let mut drain_interval = tokio::time::interval(Duration::from_millis(500));
-    drain_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+    let state: std::sync::Arc<tokio::sync::Mutex<DaemonState>> =
+        std::sync::Arc::new(tokio::sync::Mutex::new(DaemonState::new()));
 
     loop {
-        let sleep_future = idle_timeout_ms.map(|ms| tokio::time::sleep(Duration::from_millis(ms)));
-        let mut sleep_pin = sleep_future.map(Box::pin);
-
         tokio::select! {
             accept_result = listener.accept() => {
                 match accept_result {
                     Ok((stream, _)) => {
                         let state = state.clone();
-                        let reset_tx = reset_tx.clone();
-                        let sf = stream_file.clone();
                         tokio::spawn(async move {
-                            handle_connection(stream, state, reset_tx, sf).await;
+                            handle_connection(stream, state).await;
                         });
                     }
                     Err(e) => {
-                        let _ = writeln!(std::io::stderr(), "Accept error: {}", e);
+                        eprintln!("Accept error: {}", e);
                     }
                 }
             }
-            _ = drain_interval.tick() => {
-                let mut s = state.lock().await;
-                if let Some(ref mut mgr) = s.browser {
-                    if mgr.has_process_exited() {
-                        let _ = mgr.close().await;
-                        s.browser = None;
-                        s.screencasting = false;
-                        s.update_stream_client().await;
-                    } else {
-                        s.drain_cdp_events_background().await;
-                    }
-                }
-            }
-            _ = async {
-                if let Some(ref mut s) = sleep_pin {
-                    s.as_mut().await
-                } else {
-                    std::future::pending::<()>().await
-                }
-            }, if idle_timeout_ms.is_some() => {
-                let mut s = state.lock().await;
-                if let Some(ref mut mgr) = s.browser {
-                    let _ = mgr.close().await;
-                }
-                break;
-            }
-            _ = reset_rx.recv(), if idle_timeout_ms.is_some() => {
-                continue;
-            }
             _ = shutdown_signal() => {
                 let mut s = state.lock().await;
                 if let Some(ref mut mgr) = s.browser {
@@ -222,83 +85,36 @@ async fn run_socket_server(
 }
 
 #[cfg(windows)]
-async fn run_socket_server(
-    socket_path: &PathBuf,
-    session: &str,
-    stream_client: Option<Arc<RwLock<Option<Arc<CdpClient>>>>>,
-    stream_server: Option<Arc<StreamServer>>,
-    idle_timeout_ms: Option<u64>,
-) -> Result<(), String> {
+async fn run_socket_server(socket_path: &PathBuf, session: &str) -> Result<(), String> {
     use tokio::net::TcpListener;
 
-    let preferred_port = get_port_for_session(session);
-    // Try the hash-derived port first; if it is blocked (e.g. Windows Hyper-V
-    // excluded port range), fall back to an OS-assigned ephemeral port.
-    let listener = match TcpListener::bind(format!("127.0.0.1:{}", preferred_port)).await {
-        Ok(l) => l,
-        Err(_) => TcpListener::bind("127.0.0.1:0")
-            .await
-            .map_err(|e| format!("Failed to bind TCP: {}", e))?,
-    };
-    let actual_port = listener
-        .local_addr()
-        .map_err(|e| format!("Failed to get local address: {}", e))?
-        .port();
+    let port = get_port_for_session(session);
+    let listener = TcpListener::bind(format!("127.0.0.1:{}", port))
+        .await
+        .map_err(|e| format!("Failed to bind TCP: {}", e))?;
 
     let socket_dir = socket_path.parent().unwrap_or(std::path::Path::new("."));
     let port_path = socket_dir.join(format!("{}.port", session));
-    let _ = fs::write(&port_path, actual_port.to_string());
+    let _ = fs::write(&port_path, port.to_string());
 
-    let stream_file: Option<PathBuf> = if stream_server.is_some() {
-        Some(socket_dir.join(format!("{}.stream", session)))
-    } else {
-        None
-    };
-
-    let state: std::sync::Arc<tokio::sync::Mutex<DaemonState>> = std::sync::Arc::new(
-        tokio::sync::Mutex::new(DaemonState::new_with_stream(stream_client, stream_server)),
-    );
-
-    let (reset_tx, mut reset_rx) = mpsc::channel::<()>(64);
-    let reset_tx = idle_timeout_ms.map(|_| Arc::new(reset_tx));
+    let state: std::sync::Arc<tokio::sync::Mutex<DaemonState>> =
+        std::sync::Arc::new(tokio::sync::Mutex::new(DaemonState::new()));
 
     loop {
-        let sleep_future = idle_timeout_ms.map(|ms| tokio::time::sleep(Duration::from_millis(ms)));
-        let mut sleep_pin = sleep_future.map(Box::pin);
-
         tokio::select! {
             accept_result = listener.accept() => {
                 match accept_result {
                     Ok((stream, _)) => {
                         let state = state.clone();
-                        let reset_tx = reset_tx.clone();
-                        let sf = stream_file.clone();
                         tokio::spawn(async move {
-                            handle_connection(stream, state, reset_tx, sf).await;
+                            handle_connection(stream, state).await;
                         });
                     }
                     Err(e) => {
-                        let _ = writeln!(std::io::stderr(), "Accept error: {}", e);
+                        eprintln!("Accept error: {}", e);
                     }
                 }
             }
-            _ = async {
-                if let Some(ref mut s) = sleep_pin {
-                    s.as_mut().await
-                } else {
-                    std::future::pending::<()>().await
-                }
-            }, if idle_timeout_ms.is_some() => {
-                let mut s = state.lock().await;
-                if let Some(ref mut mgr) = s.browser {
-                    let _ = mgr.close().await;
-                }
-                let _ = fs::remove_file(&port_path);
-                break;
-            }
-            _ = reset_rx.recv(), if idle_timeout_ms.is_some() => {
-                continue;
-            }
             _ = shutdown_signal() => {
                 let mut s = state.lock().await;
                 if let Some(ref mut mgr) = s.browser {
@@ -313,12 +129,8 @@ async fn run_socket_server(
     Ok(())
 }
 
-async fn handle_connection<S>(
-    stream: S,
-    state: std::sync::Arc<tokio::sync::Mutex<DaemonState>>,
-    idle_reset_tx: Option<Arc<mpsc::Sender<()>>>,
-    stream_file_cleanup: Option<PathBuf>,
-) where
+async fn handle_connection<S>(stream: S, state: std::sync::Arc<tokio::sync::Mutex<DaemonState>>)
+where
     S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
 {
     let (reader, mut writer) = tokio::io::split(stream);
@@ -353,10 +165,6 @@ async fn handle_connection<S>(
                     }
                 };
 
-                if let Some(ref tx) = idle_reset_tx {
-                    let _ = tx.try_send(());
-                }
-
                 let is_close = cmd.get("action").and_then(|v| v.as_str()) == Some("close");
 
                 let response = {
@@ -371,9 +179,6 @@ async fn handle_connection<S>(
                 }
 
                 if is_close {
-                    if let Some(ref path) = stream_file_cleanup {
-                        let _ = fs::remove_file(path);
-                    }
                     tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
                     process::exit(0);
                 }
@@ -396,25 +201,21 @@ async fn shutdown_signal() {
         let mut sigint = match signal::unix::signal(signal::unix::SignalKind::interrupt()) {
             Ok(s) => s,
             Err(e) => {
-                let _ = writeln!(std::io::stderr(), "Failed to install SIGINT handler: {}", e);
+                eprintln!("Failed to install SIGINT handler: {}", e);
                 process::exit(1);
             }
         };
         let mut sigterm = match signal::unix::signal(signal::unix::SignalKind::terminate()) {
             Ok(s) => s,
             Err(e) => {
-                let _ = writeln!(
-                    std::io::stderr(),
-                    "Failed to install SIGTERM handler: {}",
-                    e
-                );
+                eprintln!("Failed to install SIGTERM handler: {}", e);
                 process::exit(1);
             }
         };
         let mut sighup = match signal::unix::signal(signal::unix::SignalKind::hangup()) {
             Ok(s) => s,
             Err(e) => {
-                let _ = writeln!(std::io::stderr(), "Failed to install SIGHUP handler: {}", e);
+                eprintln!("Failed to install SIGHUP handler: {}", e);
                 process::exit(1);
             }
         };
@@ -429,7 +230,7 @@ async fn shutdown_signal() {
     #[cfg(windows)]
     {
         if let Err(e) = signal::ctrl_c().await {
-            let _ = writeln!(std::io::stderr(), "Failed to install Ctrl+C handler: {}", e);
+            eprintln!("Failed to install Ctrl+C handler: {}", e);
             process::exit(1);
         }
     }
@@ -457,119 +258,9 @@ fn get_daemon_socket_dir() -> PathBuf {
 
 #[cfg(windows)]
 fn get_port_for_session(session: &str) -> u16 {
-    let mut hash: i32 = 0;
-    for c in session.chars() {
-        hash = ((hash << 5).wrapping_sub(hash)).wrapping_add(c as i32);
-    }
-    49152 + ((hash.unsigned_abs() as u32 % 16383) as u16)
-}
-
-#[cfg(test)]
-mod tests {
-    #[allow(unused_imports)]
-    use super::*;
-
-    #[cfg(windows)]
-    #[test]
-    fn test_port_matches_client_algorithm() {
-        assert_eq!(get_port_for_session("default"), 50838);
-        assert_eq!(get_port_for_session("my-session"), 63105);
-        assert_eq!(get_port_for_session("work"), 51184);
-        assert_eq!(get_port_for_session(""), 49152);
-    }
-
-    /// Guard against re-introducing `waitpid(-1)` in daemon code.
-    ///
-    /// Issue #1035: a SIGCHLD handler that called `waitpid(-1, WNOHANG)` was
-    /// added in v0.22.3 to reap zombie Chrome processes. This races with
-    /// Rust's `Child::try_wait()` / `Child::wait()` because `waitpid(-1)`
-    /// reaps *any* child, stealing the exit status before Rust can collect
-    /// it. The result is ECHILD errors in `BrowserManager::has_process_exited()`
-    /// and `ChromeProcess::kill()`, which can leave the daemon in a broken
-    /// state or cause hangs on certain Linux configurations.
-    ///
-    /// The fix uses the existing 500ms drain interval to call
-    /// `has_process_exited()` (which delegates to `Child::try_wait()`)
-    /// for targeted, race-free zombie detection.
-    #[test]
-    fn test_no_waitpid_minus_one_in_daemon() {
-        let source = include_str!("daemon.rs");
-        // Only check production code (everything before `#[cfg(test)]`)
-        let production_code = source.split("#[cfg(test)]").next().unwrap_or(source);
-        assert!(
-            !production_code.contains("waitpid(-1"),
-            "daemon.rs production code must not call waitpid(-1, ...). \
-             Use Child::try_wait() via has_process_exited() instead. \
-             See issue #1035."
-        );
-    }
-
-    /// Verify that `Child::try_wait()` correctly detects a crashed child
-    /// without needing a global SIGCHLD handler or `waitpid(-1)`.
-    /// This is what `has_process_exited()` uses in the fixed code.
-    #[cfg(unix)]
-    #[test]
-    fn test_child_try_wait_detects_exit_without_sigchld_handler() {
-        use std::process::{Command, Stdio};
-
-        let mut child = Command::new("/bin/sh")
-            .args(["-c", "exit 42"])
-            .stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .spawn()
-            .expect("failed to spawn child");
-
-        std::thread::sleep(std::time::Duration::from_millis(200));
-
-        match child.try_wait() {
-            Ok(Some(status)) => {
-                assert!(
-                    !status.success(),
-                    "child exited with code 42, should not be success"
-                );
-            }
-            Ok(None) => panic!("try_wait() returned None but child should have exited"),
-            Err(e) => panic!("try_wait() should succeed without waitpid(-1): {}", e),
-        }
-    }
-
-    /// Verify that `ChromeProcess::has_exited()` (which uses `Child::try_wait()`)
-    /// correctly detects a killed child, the same way the drain interval does
-    /// in the fixed daemon code. This ensures crash detection works without
-    /// a SIGCHLD handler.
-    #[cfg(unix)]
-    #[test]
-    fn test_has_exited_detects_killed_process() {
-        use std::process::{Command, Stdio};
-
-        let mut child = Command::new("/bin/sh")
-            .args(["-c", "sleep 60"])
-            .stdin(Stdio::null())
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .spawn()
-            .expect("failed to spawn child");
-
-        // Process should be running
-        match child.try_wait() {
-            Ok(None) => {} // expected
-            other => panic!("expected Ok(None) for running process, got {:?}", other),
-        }
-
-        // Kill it (simulates Chrome crash)
-        child.kill().expect("failed to kill child");
-        std::thread::sleep(std::time::Duration::from_millis(100));
-
-        // try_wait should detect the exit
-        match child.try_wait() {
-            Ok(Some(_)) => {} // expected: detected the crash
-            other => panic!(
-                "expected Ok(Some(_)) after kill, got {:?}. \
-                 Crash detection via try_wait() must work for the drain \
-                 interval fix (issue #1035) to function correctly.",
-                other
-            ),
-        }
+    let mut hash: i64 = 0;
+    for b in session.bytes() {
+        hash = hash.wrapping_mul(31).wrapping_add(b as i64);
     }
+    49152 + (hash.unsigned_abs() % 16383) as u16
 }

cli/src/native/diff.rs

@@ -101,21 +101,6 @@ pub fn diff_screenshot(
 
 /// Compute a snapshot diff using the Myers algorithm via the `similar` crate.
 pub fn diff_snapshots(before: &str, after: &str) -> SnapshotDiffResult {
-    // Fast path: identical inputs.
-    // This avoids constructing the `similar` TextDiff object and running the diff
-    // iteration when agents compare a snapshot to itself (common in retry/loop
-    // workloads).
-    if before == after {
-        let unchanged = before.lines().count();
-        return SnapshotDiffResult {
-            diff: String::new(),
-            additions: 0,
-            removals: 0,
-            unchanged,
-            changed: false,
-        };
-    }
-
     let text_diff = TextDiff::from_lines(before, after);
 
     let mut additions = 0usize;
@@ -207,68 +192,4 @@ mod tests {
         assert_eq!(result.unchanged, 1);
         assert!(!result.diff.is_empty());
     }
-
-    #[test]
-    fn test_diff_snapshots_identical_fast_path() {
-        let input = "hello\nworld\n";
-        let result = diff_snapshots(input, input);
-        assert!(!result.changed);
-        assert_eq!(result.additions, 0);
-        assert_eq!(result.removals, 0);
-        assert_eq!(result.unchanged, input.lines().count());
-        assert!(result.diff.is_empty());
-    }
-
-    #[test]
-    #[ignore]
-    fn bench_diff_snapshots_identical_and_changed() {
-        use std::hint::black_box;
-        use std::time::Instant;
-
-        let identical_a = (0..200)
-            .map(|i| format!("line {i}"))
-            .collect::<Vec<_>>()
-            .join("\n");
-        let identical_b = identical_a.clone();
-
-        let changed_a = identical_a.clone();
-        let changed_b = (0..200)
-            .map(|i| {
-                if i == 123 {
-                    format!("line {i} changed")
-                } else {
-                    format!("line {i}")
-                }
-            })
-            .collect::<Vec<_>>()
-            .join("\n");
-
-        // Keep the iteration count high enough to measure, but low enough
-        // to avoid long CI times when someone runs `--ignored`.
-        let iters = 50_000usize;
-
-        let start = Instant::now();
-        let mut acc_changed = 0usize;
-        for _ in 0..iters {
-            let r = diff_snapshots(black_box(&identical_a), black_box(&identical_b));
-            acc_changed ^= r.unchanged;
-        }
-        let identical_ms = start.elapsed().as_secs_f64() * 1000.0;
-
-        let start = Instant::now();
-        let mut acc_changed2 = 0usize;
-        for _ in 0..iters {
-            let r = diff_snapshots(black_box(&changed_a), black_box(&changed_b));
-            acc_changed2 ^= r.additions;
-        }
-        let changed_ms = start.elapsed().as_secs_f64() * 1000.0;
-
-        // Prevent the compiler from optimizing everything away.
-        black_box(acc_changed);
-        black_box(acc_changed2);
-
-        println!(
-            "bench_diff_snapshots_identical_and_changed: iters={iters} identical_ms={identical_ms:.2} changed_ms={changed_ms:.2}"
-        );
-    }
 }

cli/src/native/element.rs

@@ -12,7 +12,6 @@ pub struct RefEntry {
     pub name: String,
     pub nth: Option<usize>,
     pub selector: Option<String>,
-    pub frame_id: Option<String>,
 }
 
 pub struct RefMap {
@@ -35,18 +34,6 @@ impl RefMap {
         role: &str,
         name: &str,
         nth: Option<usize>,
-    ) {
-        self.add_with_frame(ref_id, backend_node_id, role, name, nth, None);
-    }
-
-    pub fn add_with_frame(
-        &mut self,
-        ref_id: String,
-        backend_node_id: Option<i64>,
-        role: &str,
-        name: &str,
-        nth: Option<usize>,
-        frame_id: Option<&str>,
     ) {
         self.map.insert(
             ref_id,
@@ -56,28 +43,6 @@ impl RefMap {
                 name: name.to_string(),
                 nth,
                 selector: None,
-                frame_id: frame_id.map(|s| s.to_string()),
-            },
-        );
-    }
-
-    pub fn add_selector(
-        &mut self,
-        ref_id: String,
-        selector: String,
-        role: &str,
-        name: &str,
-        nth: Option<usize>,
-    ) {
-        self.map.insert(
-            ref_id,
-            RefEntry {
-                backend_node_id: None,
-                role: role.to_string(),
-                name: name.to_string(),
-                nth,
-                selector: Some(selector),
-                frame_id: None,
             },
         );
     }
@@ -86,23 +51,6 @@ impl RefMap {
         self.map.get(ref_id)
     }
 
-    pub fn entries_sorted(&self) -> Vec<(String, RefEntry)> {
-        let mut entries = self
-            .map
-            .iter()
-            .map(|(ref_id, entry)| (ref_id.clone(), entry.clone()))
-            .collect::<Vec<_>>();
-
-        entries.sort_by_key(|(ref_id, _)| {
-            ref_id
-                .strip_prefix('e')
-                .and_then(|n| n.parse::<usize>().ok())
-                .unwrap_or(usize::MAX)
-        });
-
-        entries
-    }
-
     pub fn clear(&mut self) {
         self.map.clear();
         self.next_ref = 1;
@@ -147,19 +95,14 @@ pub async fn resolve_element_center(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
-) -> Result<(f64, f64, String), String> {
+) -> Result<(f64, f64), String> {
     if let Some(ref_id) = parse_ref(selector_or_ref) {
         let entry = ref_map
             .get(&ref_id)
             .ok_or_else(|| format!("Unknown ref: {}", ref_id))?;
 
-        let effective_session_id =
-            resolve_frame_session(entry.frame_id.as_deref(), session_id, iframe_sessions);
-
-        // Try cached backend_node_id first (fast path)
         if let Some(backend_node_id) = entry.backend_node_id {
-            let result: Result<DomGetBoxModelResult, String> = client
+            let result: DomGetBoxModelResult = client
                 .send_command_typed(
                     "DOM.getBoxModel",
                     &DomGetBoxModelParams {
@@ -167,46 +110,19 @@ pub async fn resolve_element_center(
                         node_id: None,
                         object_id: None,
                     },
-                    Some(effective_session_id),
+                    Some(session_id),
                 )
-                .await;
+                .await?;
 
-            if let Ok(r) = result {
-                let (x, y) = box_model_center(&r.model);
-                return Ok((x, y, effective_session_id.to_string()));
-            }
-            // backend_node_id is stale; re-query the accessibility tree below
+            return Ok(box_model_center(&result.model));
         }
 
-        // Fallback: re-query the accessibility tree to find a fresh node by role/name
-        let fresh_id = find_node_id_by_role_name(
-            client,
-            session_id,
-            &entry.role,
-            &entry.name,
-            entry.nth,
-            entry.frame_id.as_deref(),
-            iframe_sessions,
-        )
-        .await?;
-        let result: DomGetBoxModelResult = client
-            .send_command_typed(
-                "DOM.getBoxModel",
-                &DomGetBoxModelParams {
-                    backend_node_id: Some(fresh_id),
-                    node_id: None,
-                    object_id: None,
-                },
-                Some(effective_session_id),
-            )
-            .await?;
-        let (x, y) = box_model_center(&result.model);
-        return Ok((x, y, effective_session_id.to_string()));
+        // Fallback: use role/name to find via JS
+        return resolve_by_role_name(client, session_id, &entry.role, &entry.name, entry.nth).await;
     }
 
     // CSS selector
-    let (x, y) = resolve_by_selector(client, session_id, selector_or_ref).await?;
-    Ok((x, y, session_id.to_string()))
+    resolve_by_selector(client, session_id, selector_or_ref).await
 }
 
 pub async fn resolve_element_object_id(
@@ -214,19 +130,14 @@ pub async fn resolve_element_object_id(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
-) -> Result<(String, String), String> {
+) -> Result<String, String> {
     if let Some(ref_id) = parse_ref(selector_or_ref) {
         let entry = ref_map
             .get(&ref_id)
             .ok_or_else(|| format!("Unknown ref: {}", ref_id))?;
 
-        let effective_session_id =
-            resolve_frame_session(entry.frame_id.as_deref(), session_id, iframe_sessions);
-
-        // Try cached backend_node_id first (fast path)
         if let Some(backend_node_id) = entry.backend_node_id {
-            let result: Result<DomResolveNodeResult, String> = client
+            let result: DomResolveNodeResult = client
                 .send_command_typed(
                     "DOM.resolveNode",
                     &DomResolveNodeParams {
@@ -234,49 +145,22 @@ pub async fn resolve_element_object_id(
                         node_id: None,
                         object_group: Some("agent-browser".to_string()),
                     },
-                    Some(effective_session_id),
+                    Some(session_id),
                 )
-                .await;
+                .await?;
 
-            if let Ok(r) = result {
-                if let Some(object_id) = r.object.object_id {
-                    return Ok((object_id, effective_session_id.to_string()));
-                }
-            }
-            // backend_node_id is stale; re-query the accessibility tree below
+            return result
+                .object
+                .object_id
+                .ok_or_else(|| format!("No objectId for ref {}", ref_id));
         }
-
-        // Fallback: re-query the accessibility tree to find a fresh node by role/name
-        let fresh_id = find_node_id_by_role_name(
-            client,
-            session_id,
-            &entry.role,
-            &entry.name,
-            entry.nth,
-            entry.frame_id.as_deref(),
-            iframe_sessions,
-        )
-        .await?;
-        let result: DomResolveNodeResult = client
-            .send_command_typed(
-                "DOM.resolveNode",
-                &DomResolveNodeParams {
-                    backend_node_id: Some(fresh_id),
-                    node_id: None,
-                    object_group: Some("agent-browser".to_string()),
-                },
-                Some(effective_session_id),
-            )
-            .await?;
-        let object_id = result
-            .object
-            .object_id
-            .ok_or_else(|| format!("No objectId for ref {}", ref_id))?;
-        return Ok((object_id, effective_session_id.to_string()));
     }
 
-    // Selector fallback (CSS or XPath)
-    let js = build_find_element_js(selector_or_ref);
+    // CSS selector fallback
+    let js = format!(
+        "document.querySelector({})",
+        serde_json::to_string(selector_or_ref).unwrap_or_default()
+    );
     let result: EvaluateResult = client
         .send_command_typed(
             "Runtime.evaluate",
@@ -289,149 +173,63 @@ pub async fn resolve_element_object_id(
         )
         .await?;
 
-    let object_id = result
+    result
         .result
         .object_id
-        .ok_or_else(|| format!("Element not found: {}", selector_or_ref))?;
-    Ok((object_id, session_id.to_string()))
+        .ok_or_else(|| format!("Element not found: {}", selector_or_ref))
 }
 
-/// Determine which CDP session and parameters to use for an AX tree query.
-/// Cross-origin iframes have a dedicated session (no frameId needed);
-/// same-origin iframes use the parent session with a frameId parameter.
-pub(super) fn resolve_ax_session<'a>(
-    frame_id: Option<&str>,
-    session_id: &'a str,
-    iframe_sessions: &'a HashMap<String, String>,
-) -> (serde_json::Value, &'a str) {
-    if let Some(frame_id) = frame_id {
-        if let Some(iframe_sid) = iframe_sessions.get(frame_id) {
-            (serde_json::json!({}), iframe_sid.as_str())
-        } else {
-            (serde_json::json!({ "frameId": frame_id }), session_id)
-        }
-    } else {
-        (serde_json::json!({}), session_id)
-    }
-}
-
-/// Resolve the effective CDP session for an element's frame.
-/// If the element's frame_id has a dedicated cross-origin iframe session, return it.
-/// Otherwise, return the parent session.
-fn resolve_frame_session<'a>(
-    frame_id: Option<&str>,
-    session_id: &'a str,
-    iframe_sessions: &'a HashMap<String, String>,
-) -> &'a str {
-    frame_id
-        .and_then(|fid| iframe_sessions.get(fid))
-        .map(|s| s.as_str())
-        .unwrap_or(session_id)
-}
-
-/// Re-query the accessibility tree to find a node matching role+name+nth,
-/// returning its fresh backendDOMNodeId. This uses the same data source
-/// (Accessibility.getFullAXTree) that built the ref map during snapshot,
-/// so role/name matching is guaranteed to be consistent.
-async fn find_node_id_by_role_name(
+async fn resolve_by_role_name(
     client: &CdpClient,
     session_id: &str,
     role: &str,
     name: &str,
     nth: Option<usize>,
-    frame_id: Option<&str>,
-    iframe_sessions: &HashMap<String, String>,
-) -> Result<i64, String> {
-    let (ax_params, effective_session_id) =
-        resolve_ax_session(frame_id, session_id, iframe_sessions);
-    let ax_tree: GetFullAXTreeResult = client
-        .send_command_typed(
-            "Accessibility.getFullAXTree",
-            &ax_params,
-            Some(effective_session_id),
-        )
-        .await?;
-
+) -> Result<(f64, f64), String> {
     let nth_index = nth.unwrap_or(0);
-    let mut match_count: usize = 0;
-
-    for node in &ax_tree.nodes {
-        if node.ignored.unwrap_or(false) {
-            continue;
-        }
-        let node_role = extract_ax_string(&node.role);
-        let node_name = extract_ax_string(&node.name);
-        if node_role == role && node_name == name {
-            if match_count == nth_index {
-                return node.backend_d_o_m_node_id.ok_or_else(|| {
-                    format!(
-                        "AX node has no backendDOMNodeId for role={} name={}",
-                        role, name
-                    )
-                });
-            }
-            match_count += 1;
-        }
-    }
-
-    Err(format!(
-        "Could not locate element with role={} name={}",
-        role, name
-    ))
-}
-
-fn extract_ax_string(value: &Option<AXValue>) -> String {
-    match value {
-        Some(v) => match &v.value {
-            Some(Value::String(s)) => s.clone(),
-            Some(Value::Number(n)) => n.to_string(),
-            Some(Value::Bool(b)) => b.to_string(),
-            _ => String::new(),
-        },
-        None => String::new(),
-    }
-}
-
-/// Build a JS expression that finds a DOM element by CSS selector or XPath.
-fn build_find_element_js(selector: &str) -> String {
-    if let Some(xpath) = selector.strip_prefix("xpath=") {
-        format!(
-            "document.evaluate({}, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue",
-            serde_json::to_string(xpath).unwrap_or_default()
-        )
-    } else {
-        format!(
-            "document.querySelector({})",
-            serde_json::to_string(selector).unwrap_or_default()
-        )
-    }
-}
-
-/// Build a JS expression that counts matching DOM elements by CSS selector or XPath.
-fn build_count_elements_js(selector: &str) -> String {
-    if let Some(xpath) = selector.strip_prefix("xpath=") {
-        format!(
-            "document.evaluate({}, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null).snapshotLength",
-            serde_json::to_string(xpath).unwrap_or_default()
-        )
-    } else {
-        format!(
-            "document.querySelectorAll({}).length",
-            serde_json::to_string(selector).unwrap_or_default()
-        )
-    }
-}
-
-fn build_selector_js(selector: &str) -> String {
-    let find_expr = build_find_element_js(selector);
-    format!(
+    let js = format!(
         r#"(() => {{
-            const el = {find_expr};
+            const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT);
+            const matches = [];
+            let node;
+            while (node = walker.nextNode()) {{
+                const r = node.getAttribute('role') || node.tagName.toLowerCase();
+                const n = node.getAttribute('aria-label') || node.textContent.trim().slice(0, 100);
+                if (r === {role} && n === {name}) matches.push(node);
+            }}
+            const el = matches[{nth}];
             if (!el) return null;
             const rect = el.getBoundingClientRect();
             return {{ x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 }};
         }})()"#,
-    )
+        role = serde_json::to_string(role).unwrap_or_default(),
+        name = serde_json::to_string(name).unwrap_or_default(),
+        nth = nth_index,
+    );
+
+    let result: EvaluateResult = client
+        .send_command_typed(
+            "Runtime.evaluate",
+            &EvaluateParams {
+                expression: js,
+                return_by_value: Some(true),
+                await_promise: Some(false),
+            },
+            Some(session_id),
+        )
+        .await?;
+
+    let val = result.result.value.unwrap_or(Value::Null);
+    let x = val.get("x").and_then(|v| v.as_f64());
+    let y = val.get("y").and_then(|v| v.as_f64());
+
+    match (x, y) {
+        (Some(x), Some(y)) => Ok((x, y)),
+        _ => Err(format!(
+            "Could not locate element with role={} name={}",
+            role, name
+        )),
+    }
 }
 
 async fn resolve_by_selector(
@@ -439,7 +237,15 @@ async fn resolve_by_selector(
     session_id: &str,
     selector: &str,
 ) -> Result<(f64, f64), String> {
-    let js = build_selector_js(selector);
+    let js = format!(
+        r#"(() => {{
+            const el = document.querySelector({sel});
+            if (!el) return null;
+            const rect = el.getBoundingClientRect();
+            return {{ x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 }};
+        }})()"#,
+        sel = serde_json::to_string(selector).unwrap_or_default(),
+    );
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -479,16 +285,8 @@ pub async fn get_element_text(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<String, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -501,7 +299,7 @@ pub async fn get_element_text(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -518,16 +316,8 @@ pub async fn get_element_attribute(
     ref_map: &RefMap,
     selector_or_ref: &str,
     attribute: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<Value, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -542,7 +332,7 @@ pub async fn get_element_attribute(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -554,16 +344,8 @@ pub async fn is_element_visible(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<bool, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -583,7 +365,7 @@ pub async fn is_element_visible(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -599,16 +381,8 @@ pub async fn is_element_enabled(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<bool, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -620,7 +394,7 @@ pub async fn is_element_enabled(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -636,61 +410,20 @@ pub async fn is_element_checked(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<bool, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
-    // Mirrors Playwright's getChecked() with follow-label retargeting:
-    // 1. If element is a native checkbox/radio input, return .checked
-    // 2. If element has an ARIA checked role, return aria-checked
-    // 3. Follow label → input association (label.control)
-    // 4. Check for nested checkbox/radio input as last resort
     let result: EvaluateResult = client
         .send_command_typed(
             "Runtime.callFunctionOn",
             &CallFunctionOnParams {
-                function_declaration: r#"function() {
-                    var el = this;
-                    // Native checkbox/radio input
-                    var tag = el.tagName && el.tagName.toUpperCase();
-                    if (tag === 'INPUT' && (el.type === 'checkbox' || el.type === 'radio')) {
-                        return el.checked;
-                    }
-                    // ARIA role-based checked state
-                    var role = el.getAttribute && el.getAttribute('role');
-                    var ariaCheckedRoles = ['checkbox','radio','switch','menuitemcheckbox','menuitemradio','option','treeitem'];
-                    if (role && ariaCheckedRoles.indexOf(role) !== -1) {
-                        return el.getAttribute('aria-checked') === 'true';
-                    }
-                    // Follow label association (Playwright follow-label retarget)
-                    var label = el;
-                    if (tag !== 'LABEL') {
-                        label = el.closest && el.closest('label');
-                    }
-                    if (label && label.tagName && label.tagName.toUpperCase() === 'LABEL' && label.control) {
-                        var ctrl = label.control;
-                        if (ctrl.type === 'checkbox' || ctrl.type === 'radio') {
-                            return ctrl.checked;
-                        }
-                    }
-                    // Check for nested native input
-                    var input = el.querySelector && el.querySelector('input[type="checkbox"], input[type="radio"]');
-                    if (input) return input.checked;
-                    return false;
-                }"#.to_string(),
+                function_declaration: "function() { return !!this.checked; }".to_string(),
                 object_id: Some(object_id),
                 arguments: None,
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -706,16 +439,8 @@ pub async fn get_element_inner_text(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<String, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -727,7 +452,7 @@ pub async fn get_element_inner_text(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -743,16 +468,8 @@ pub async fn get_element_inner_html(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<String, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -764,7 +481,7 @@ pub async fn get_element_inner_html(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -780,16 +497,8 @@ pub async fn get_element_input_value(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<String, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -803,7 +512,7 @@ pub async fn get_element_input_value(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -820,16 +529,8 @@ pub async fn set_element_value(
     ref_map: &RefMap,
     selector_or_ref: &str,
     value: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let js = format!(
         "function() {{ this.value = {}; this.dispatchEvent(new Event('input', {{bubbles: true}})); this.dispatchEvent(new Event('change', {{bubbles: true}})); }}",
@@ -846,7 +547,7 @@ pub async fn set_element_value(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -858,16 +559,8 @@ pub async fn get_element_bounding_box(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<Value, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -883,7 +576,7 @@ pub async fn get_element_bounding_box(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -898,7 +591,10 @@ pub async fn get_element_count(
     session_id: &str,
     selector: &str,
 ) -> Result<i64, String> {
-    let js = build_count_elements_js(selector);
+    let js = format!(
+        "document.querySelectorAll({}).length",
+        serde_json::to_string(selector).unwrap_or_default()
+    );
 
     let result: EvaluateResult = client
         .send_command_typed(
@@ -921,16 +617,8 @@ pub async fn get_element_styles(
     ref_map: &RefMap,
     selector_or_ref: &str,
     properties: Option<Vec<String>>,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<Value, String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let js = match properties {
         Some(props) => {
@@ -968,7 +656,7 @@ pub async fn get_element_styles(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -1013,47 +701,6 @@ mod tests {
         assert!(map.get("e2").is_none());
     }
 
-    #[test]
-    fn test_build_selector_js_css() {
-        let js = build_selector_js("#submit-btn");
-        assert!(js.contains("document.querySelector(\"#submit-btn\")"));
-        assert!(!js.contains("document.evaluate"));
-    }
-
-    #[test]
-    fn test_build_selector_js_xpath() {
-        let js = build_selector_js("xpath=//button[@id='ok']");
-        assert!(js.contains("document.evaluate(\"//button[@id='ok']\", document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)"));
-        assert!(!js.contains("document.querySelector"));
-    }
-
-    #[test]
-    fn test_build_selector_js_xpath_empty() {
-        let js = build_selector_js("xpath=");
-        assert!(js.contains("document.evaluate"));
-    }
-
-    #[test]
-    fn test_build_selector_js_not_xpath_prefix() {
-        // "xpath" without "=" should be treated as CSS selector
-        let js = build_selector_js("xpath//div");
-        assert!(js.contains("document.querySelector"));
-    }
-
-    #[test]
-    fn test_build_count_elements_js_css() {
-        let js = build_count_elements_js(".item");
-        assert!(js.contains("document.querySelectorAll(\".item\").length"));
-        assert!(!js.contains("document.evaluate"));
-    }
-
-    #[test]
-    fn test_build_count_elements_js_xpath() {
-        let js = build_count_elements_js("xpath=//li");
-        assert!(js.contains("document.evaluate(\"//li\", document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null).snapshotLength"));
-        assert!(!js.contains("querySelectorAll"));
-    }
-
     #[test]
     fn test_box_model_center() {
         let model = BoxModel {
@@ -1068,48 +715,4 @@ mod tests {
         assert!((x - 60.0).abs() < 0.01);
         assert!((y - 40.0).abs() < 0.01);
     }
-
-    // -----------------------------------------------------------------------
-    // resolve_frame_session tests (Issue #925)
-    // Cross-origin iframe elements must resolve to the dedicated session.
-    // -----------------------------------------------------------------------
-
-    #[test]
-    fn test_cross_origin_element_uses_dedicated_session() {
-        let mut iframe_sessions = HashMap::new();
-        iframe_sessions.insert(
-            "cross-origin-frame".to_string(),
-            "iframe-session".to_string(),
-        );
-
-        let session = resolve_frame_session(
-            Some("cross-origin-frame"),
-            "parent-session",
-            &iframe_sessions,
-        );
-
-        assert_eq!(session, "iframe-session");
-    }
-
-    #[test]
-    fn test_same_origin_element_uses_parent_session() {
-        let iframe_sessions = HashMap::new();
-
-        let session = resolve_frame_session(
-            Some("same-origin-frame"),
-            "parent-session",
-            &iframe_sessions,
-        );
-
-        assert_eq!(session, "parent-session");
-    }
-
-    #[test]
-    fn test_main_frame_element_uses_parent_session() {
-        let iframe_sessions = HashMap::new();
-
-        let session = resolve_frame_session(None, "parent-session", &iframe_sessions);
-
-        assert_eq!(session, "parent-session");
-    }
 }

cli/src/native/inspect_server.rs

@@ -1,362 +0,0 @@
-use std::io::Write;
-use std::sync::atomic::{AtomicI64, Ordering};
-use std::sync::Arc;
-
-use futures_util::{SinkExt, StreamExt};
-use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-use tokio::net::TcpListener;
-use tokio::sync::Mutex;
-use tokio_tungstenite::tungstenite::Message;
-
-use super::cdp::client::InspectProxyHandle;
-
-/// Counter for unique attach IDs so concurrent connections don't collide.
-static ATTACH_ID: AtomicI64 = AtomicI64::new(-1000);
-
-/// Lightweight HTTP + WebSocket server for `agent-browser inspect`.
-///
-/// Serves two purposes:
-/// - `GET /` redirects to Chrome's built-in DevTools frontend with `ws=` pointing to this server
-/// - WebSocket connections create a dedicated CDP session via `Target.attachToTarget` and proxy
-///   CDP messages through the daemon's existing browser-level connection, injecting/stripping
-///   `sessionId` so the DevTools frontend sees a page-level view
-pub struct InspectServer {
-    port: u16,
-    _handle: tokio::task::JoinHandle<()>,
-}
-
-impl InspectServer {
-    /// Start the inspect proxy server.
-    ///
-    /// - `proxy_handle`: lightweight handle for sending/receiving raw CDP messages
-    /// - `target_id`: the CDP target ID of the page to inspect
-    /// - `chrome_host_port`: the Chrome debug server address (e.g. "127.0.0.1:9222")
-    pub async fn start(
-        proxy_handle: InspectProxyHandle,
-        target_id: String,
-        chrome_host_port: String,
-    ) -> Result<Self, String> {
-        let listener = TcpListener::bind("127.0.0.1:0")
-            .await
-            .map_err(|e| format!("Failed to bind inspect server: {}", e))?;
-        let port = listener
-            .local_addr()
-            .map_err(|e| format!("Failed to get local addr: {}", e))?
-            .port();
-
-        let proxy = Arc::new(proxy_handle);
-
-        let handle = tokio::spawn(accept_loop(
-            listener,
-            proxy,
-            target_id,
-            chrome_host_port,
-            port,
-        ));
-
-        Ok(Self {
-            port,
-            _handle: handle,
-        })
-    }
-
-    pub fn port(&self) -> u16 {
-        self.port
-    }
-
-    pub fn shutdown(self) {
-        self._handle.abort();
-    }
-}
-
-async fn accept_loop(
-    listener: TcpListener,
-    proxy: Arc<InspectProxyHandle>,
-    target_id: String,
-    chrome_host_port: String,
-    proxy_port: u16,
-) {
-    loop {
-        let (stream, _) = match listener.accept().await {
-            Ok(s) => s,
-            Err(_) => continue,
-        };
-
-        let proxy = proxy.clone();
-        let tid = target_id.clone();
-        let chp = chrome_host_port.clone();
-
-        tokio::spawn(async move {
-            if let Err(e) = handle_connection(stream, proxy, tid, chp, proxy_port).await {
-                let _ = writeln!(std::io::stderr(), "[inspect] connection error: {}", e);
-            }
-        });
-    }
-}
-
-async fn handle_connection(
-    stream: tokio::net::TcpStream,
-    proxy: Arc<InspectProxyHandle>,
-    target_id: String,
-    chrome_host_port: String,
-    proxy_port: u16,
-) -> Result<(), String> {
-    // Peek at the request line to determine routing WITHOUT consuming bytes.
-    // This is critical: tokio_tungstenite::accept_async needs to read the full
-    // HTTP upgrade request itself, so we must not consume anything for WS paths.
-    let mut peek_buf = [0u8; 32];
-    let n = stream
-        .peek(&mut peek_buf)
-        .await
-        .map_err(|e| e.to_string())?;
-    let peek = String::from_utf8_lossy(&peek_buf[..n]);
-
-    if peek.starts_with("GET /ws") {
-        return handle_ws_proxy(stream, proxy, target_id).await;
-    }
-
-    if peek.starts_with("GET / ") {
-        let buf_reader = BufReader::new(stream);
-        return handle_http_redirect(buf_reader, chrome_host_port, proxy_port).await;
-    }
-
-    // Unknown request -- consume and respond 404
-    let mut stream = stream;
-    let mut discard = [0u8; 4096];
-    let _ = stream.read(&mut discard).await;
-    let resp = "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
-    stream
-        .write_all(resp.as_bytes())
-        .await
-        .map_err(|e| e.to_string())?;
-    Ok(())
-}
-
-const MAX_HEADER_BYTES: usize = 8192;
-
-async fn handle_http_redirect(
-    buf_reader: BufReader<tokio::net::TcpStream>,
-    chrome_host_port: String,
-    proxy_port: u16,
-) -> Result<(), String> {
-    let mut br = buf_reader;
-    let mut total_bytes = 0usize;
-    loop {
-        let mut line = String::new();
-        let n = br.read_line(&mut line).await.map_err(|e| e.to_string())?;
-        total_bytes += n;
-        if line == "\r\n" || line == "\n" || line.is_empty() || total_bytes > MAX_HEADER_BYTES {
-            break;
-        }
-    }
-
-    let location = format!(
-        "http://{}/devtools/devtools_app.html?ws=127.0.0.1:{}/ws",
-        chrome_host_port, proxy_port
-    );
-    let body = format!(
-        "<html><body>Redirecting to <a href=\"{url}\">{url}</a></body></html>",
-        url = location
-    );
-    let resp = format!(
-        "HTTP/1.1 302 Found\r\nLocation: {}\r\nContent-Type: text/html\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
-        location,
-        body.len(),
-        body
-    );
-    let mut stream = br.into_inner();
-    stream
-        .write_all(resp.as_bytes())
-        .await
-        .map_err(|e| e.to_string())?;
-    Ok(())
-}
-
-async fn handle_ws_proxy(
-    stream: tokio::net::TcpStream,
-    proxy: Arc<InspectProxyHandle>,
-    target_id: String,
-) -> Result<(), String> {
-    let ws_stream = tokio_tungstenite::accept_async(stream)
-        .await
-        .map_err(|e| format!("WebSocket handshake failed: {}", e))?;
-
-    // Create a dedicated CDP session for this DevTools connection.
-    // Each connection gets its own session so domain enablements (DOM.enable, etc.)
-    // always trigger fresh initial state dumps from Chrome.
-    let attach_id = ATTACH_ID.fetch_sub(1, Ordering::SeqCst);
-    let attach_cmd = format!(
-        r#"{{"id":{},"method":"Target.attachToTarget","params":{{"targetId":"{}","flatten":true}}}}"#,
-        attach_id, target_id
-    );
-
-    // Subscribe BEFORE sending so we don't miss the response (tokio broadcast
-    // receivers only deliver messages to receivers that already exist).
-    let mut raw_rx = proxy.subscribe_raw();
-
-    proxy
-        .send_raw(attach_cmd)
-        .await
-        .map_err(|e| format!("Failed to send attachToTarget: {}", e))?;
-
-    // Wait for the attachToTarget response to extract the session ID
-    let session_id = tokio::time::timeout(std::time::Duration::from_secs(5), async {
-        while let Ok(raw_msg) = raw_rx.recv().await {
-            if let Ok(val) = serde_json::from_str::<serde_json::Value>(&raw_msg.text) {
-                if val.get("id").and_then(|v| v.as_i64()) == Some(attach_id) {
-                    if let Some(sid) = val
-                        .get("result")
-                        .and_then(|r| r.get("sessionId"))
-                        .and_then(|s| s.as_str())
-                    {
-                        return Ok(sid.to_string());
-                    }
-                    return Err("attachToTarget failed".to_string());
-                }
-            }
-        }
-        Err("raw message channel closed".to_string())
-    })
-    .await
-    .map_err(|_| "Timed out waiting for attachToTarget response".to_string())?
-    .map_err(|e| format!("Failed to create DevTools session: {}", e))?;
-
-    let (ws_tx, mut ws_rx) = ws_stream.split();
-    let ws_tx = Arc::new(Mutex::new(ws_tx));
-
-    let mut raw_rx = proxy.subscribe_raw();
-    let ws_tx_clone = ws_tx.clone();
-    let session_id_clone = session_id.clone();
-
-    // Chrome -> DevTools: forward messages matching our session, strip sessionId
-    let mut chrome_to_devtools = tokio::spawn(async move {
-        loop {
-            let raw_msg = match raw_rx.recv().await {
-                Ok(msg) => msg,
-                Err(tokio::sync::broadcast::error::RecvError::Lagged(n)) => {
-                    let _ = writeln!(
-                        std::io::stderr(),
-                        "[inspect] warning: dropped {} CDP messages (channel lag)",
-                        n
-                    );
-                    continue;
-                }
-                Err(_) => break,
-            };
-
-            if raw_msg.session_id.as_deref() != Some(&session_id_clone) {
-                continue;
-            }
-
-            let stripped = strip_session_id(&raw_msg.text);
-
-            let mut tx = ws_tx_clone.lock().await;
-            if tx.send(Message::Text(stripped)).await.is_err() {
-                break;
-            }
-        }
-    });
-
-    // DevTools -> Chrome: inject sessionId and forward
-    let proxy_for_send = proxy.clone();
-    let session_id_for_send = session_id.clone();
-    let mut devtools_to_chrome = tokio::spawn(async move {
-        while let Some(Ok(msg)) = ws_rx.next().await {
-            let text = match msg {
-                Message::Text(t) => t,
-                Message::Close(_) => break,
-                _ => continue,
-            };
-
-            let injected = inject_session_id(&text, &session_id_for_send);
-            if proxy_for_send.send_raw(injected).await.is_err() {
-                break;
-            }
-        }
-    });
-
-    tokio::select! {
-        _ = &mut chrome_to_devtools => {
-            devtools_to_chrome.abort();
-        },
-        _ = &mut devtools_to_chrome => {
-            chrome_to_devtools.abort();
-        },
-    }
-
-    // Clean up the CDP session so Chrome doesn't leak attached targets
-    let detach_cmd = format!(
-        r#"{{"id":{},"method":"Target.detachFromTarget","params":{{"sessionId":"{}"}}}}"#,
-        ATTACH_ID.fetch_sub(1, Ordering::SeqCst),
-        session_id
-    );
-    let _ = proxy.send_raw(detach_cmd).await;
-
-    Ok(())
-}
-
-fn inject_session_id(json: &str, session_id: &str) -> String {
-    if let Ok(mut val) = serde_json::from_str::<serde_json::Value>(json) {
-        if let Some(obj) = val.as_object_mut() {
-            obj.insert(
-                "sessionId".to_string(),
-                serde_json::Value::String(session_id.to_string()),
-            );
-        }
-        serde_json::to_string(&val).unwrap_or_else(|_| json.to_string())
-    } else {
-        json.to_string()
-    }
-}
-
-fn strip_session_id(json: &str) -> String {
-    if let Ok(mut val) = serde_json::from_str::<serde_json::Value>(json) {
-        if let Some(obj) = val.as_object_mut() {
-            obj.remove("sessionId");
-        }
-        serde_json::to_string(&val).unwrap_or_else(|_| json.to_string())
-    } else {
-        json.to_string()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_inject_session_id() {
-        let input = r#"{"id":1,"method":"DOM.getDocument"}"#;
-        let result = inject_session_id(input, "abc123");
-        let parsed: serde_json::Value = serde_json::from_str(&result).expect("valid JSON");
-        assert_eq!(parsed["sessionId"], "abc123");
-        assert_eq!(parsed["method"], "DOM.getDocument");
-        assert_eq!(parsed["id"], 1);
-    }
-
-    #[test]
-    fn test_inject_session_id_empty_object() {
-        let result = inject_session_id("{}", "abc");
-        let parsed: serde_json::Value = serde_json::from_str(&result).expect("valid JSON");
-        assert_eq!(parsed["sessionId"], "abc");
-    }
-
-    #[test]
-    fn test_strip_session_id() {
-        let input = r#"{"id":1,"result":{},"sessionId":"abc123"}"#;
-        let result = strip_session_id(input);
-        let parsed: serde_json::Value = serde_json::from_str(&result).expect("valid JSON");
-        assert!(parsed.get("sessionId").is_none());
-        assert_eq!(parsed["id"], 1);
-    }
-
-    #[test]
-    fn test_inject_then_strip_roundtrip() {
-        let input = r#"{"id":42,"method":"Runtime.evaluate"}"#;
-        let injected = inject_session_id(input, "sess1");
-        let stripped = strip_session_id(&injected);
-        let original: serde_json::Value = serde_json::from_str(input).unwrap();
-        let result: serde_json::Value = serde_json::from_str(&stripped).unwrap();
-        assert_eq!(original, result);
-    }
-}

cli/src/native/interaction.rs

@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use serde_json::Value;
 
 use super::cdp::client::CdpClient;
@@ -13,17 +11,9 @@ pub async fn click(
     selector_or_ref: &str,
     button: &str,
     click_count: i32,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (x, y, effective_session_id) = resolve_element_center(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
-    dispatch_click(client, &effective_session_id, x, y, button, click_count).await
+    let (x, y) = resolve_element_center(client, session_id, ref_map, selector_or_ref).await?;
+    dispatch_click(client, session_id, x, y, button, click_count).await
 }
 
 pub async fn dblclick(
@@ -31,18 +21,8 @@ pub async fn dblclick(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    click(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        "left",
-        2,
-        iframe_sessions,
-    )
-    .await
+    click(client, session_id, ref_map, selector_or_ref, "left", 2).await
 }
 
 pub async fn hover(
@@ -50,16 +30,8 @@ pub async fn hover(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (x, y, effective_session_id) = resolve_element_center(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let (x, y) = resolve_element_center(client, session_id, ref_map, selector_or_ref).await?;
     client
         .send_command_typed::<_, Value>(
             "Input.dispatchMouseEvent",
@@ -74,7 +46,7 @@ pub async fn hover(
                 delta_y: None,
                 modifiers: None,
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
     Ok(())
@@ -86,16 +58,8 @@ pub async fn fill(
     ref_map: &RefMap,
     selector_or_ref: &str,
     value: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     // Focus the element
     client
@@ -108,7 +72,7 @@ pub async fn fill(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -128,11 +92,11 @@ pub async fn fill(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
-    // Insert text (keyboard input dispatched at page level, use parent session_id)
+    // Insert text
     client
         .send_command_typed::<_, Value>(
             "Input.insertText",
@@ -146,7 +110,6 @@ pub async fn fill(
     Ok(())
 }
 
-#[allow(clippy::too_many_arguments)]
 pub async fn type_text(
     client: &CdpClient,
     session_id: &str,
@@ -155,16 +118,8 @@ pub async fn type_text(
     text: &str,
     clear: bool,
     delay_ms: Option<u64>,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     // Focus
     client
@@ -177,7 +132,7 @@ pub async fn type_text(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -197,73 +152,50 @@ pub async fn type_text(
                     return_by_value: Some(true),
                     await_promise: Some(false),
                 },
-                Some(&effective_session_id),
+                Some(session_id),
             )
             .await?;
     }
 
-    type_text_into_active_context(client, session_id, text, delay_ms).await
-}
-
-pub async fn type_text_into_active_context(
-    client: &CdpClient,
-    session_id: &str,
-    text: &str,
-    delay_ms: Option<u64>,
-) -> Result<(), String> {
     let delay = delay_ms.unwrap_or(0);
 
     for ch in text.chars() {
-        if matches!(ch, '\n' | '\r' | '\t') {
-            let (key, code, key_code) = char_to_key_info(ch);
-            let text_str = key_text(&key);
-            client
-                .send_command_typed::<_, Value>(
-                    "Input.dispatchKeyEvent",
-                    &DispatchKeyEventParams {
-                        event_type: "keyDown".to_string(),
-                        key: Some(key.clone()),
-                        code: Some(code.clone()),
-                        text: text_str.clone(),
-                        unmodified_text: text_str,
-                        windows_virtual_key_code: Some(key_code),
-                        native_virtual_key_code: Some(key_code),
-                        modifiers: None,
-                    },
-                    Some(session_id),
-                )
-                .await?;
+        let text_str = ch.to_string();
+        let (key, code, key_code) = char_to_key_info(ch);
 
-            client
-                .send_command_typed::<_, Value>(
-                    "Input.dispatchKeyEvent",
-                    &DispatchKeyEventParams {
-                        event_type: "keyUp".to_string(),
-                        key: Some(key),
-                        code: Some(code),
-                        text: None,
-                        unmodified_text: None,
-                        windows_virtual_key_code: Some(key_code),
-                        native_virtual_key_code: Some(key_code),
-                        modifiers: None,
-                    },
-                    Some(session_id),
-                )
-                .await?;
-        } else {
-            // VS Code/Electron webviews reject repeated dispatchKeyEvent calls
-            // carrying printable `text`. Insert printable characters directly
-            // and reserve key events for controls like Enter and Tab.
-            client
-                .send_command_typed::<_, Value>(
-                    "Input.insertText",
-                    &InsertTextParams {
-                        text: ch.to_string(),
-                    },
-                    Some(session_id),
-                )
-                .await?;
-        }
+        client
+            .send_command_typed::<_, Value>(
+                "Input.dispatchKeyEvent",
+                &DispatchKeyEventParams {
+                    event_type: "keyDown".to_string(),
+                    key: Some(key.clone()),
+                    code: Some(code.clone()),
+                    text: Some(text_str.clone()),
+                    unmodified_text: Some(text_str.clone()),
+                    windows_virtual_key_code: Some(key_code),
+                    native_virtual_key_code: Some(key_code),
+                    modifiers: None,
+                },
+                Some(session_id),
+            )
+            .await?;
+
+        client
+            .send_command_typed::<_, Value>(
+                "Input.dispatchKeyEvent",
+                &DispatchKeyEventParams {
+                    event_type: "keyUp".to_string(),
+                    key: Some(key),
+                    code: Some(code),
+                    text: None,
+                    unmodified_text: None,
+                    windows_virtual_key_code: Some(key_code),
+                    native_virtual_key_code: Some(key_code),
+                    modifiers: None,
+                },
+                Some(session_id),
+            )
+            .await?;
 
         if delay > 0 {
             tokio::time::sleep(tokio::time::Duration::from_millis(delay)).await;
@@ -274,33 +206,8 @@ pub async fn type_text_into_active_context(
 }
 
 pub async fn press_key(client: &CdpClient, session_id: &str, key: &str) -> Result<(), String> {
-    press_key_with_modifiers(client, session_id, key, None).await
-}
-
-/// Dispatch a keyDown+keyUp sequence for `key` with an optional CDP modifier bitmask.
-///
-/// Modifier values follow the CDP `Input.dispatchKeyEvent` spec:
-/// 1 = Alt, 2 = Control, 4 = Meta (Cmd), 8 = Shift.
-///
-/// Callers that need a platform-appropriate modifier (e.g. Cmd on macOS,
-/// Ctrl elsewhere) must choose the value themselves -- see `cfg!(target_os)`.
-pub async fn press_key_with_modifiers(
-    client: &CdpClient,
-    session_id: &str,
-    key: &str,
-    modifiers: Option<i32>,
-) -> Result<(), String> {
     let (key_name, code, key_code) = named_key_info(key);
 
-    // Suppress text insertion when Control (2) or Meta (4) modifiers are active,
-    // since these are command chords (e.g. Ctrl+A = select-all), not text input.
-    let has_command_modifier = modifiers.is_some_and(|m| m & (2 | 4) != 0);
-    let text = if has_command_modifier {
-        None
-    } else {
-        key_text(&key_name)
-    };
-
     client
         .send_command_typed::<_, Value>(
             "Input.dispatchKeyEvent",
@@ -308,11 +215,11 @@ pub async fn press_key_with_modifiers(
                 event_type: "keyDown".to_string(),
                 key: Some(key_name.clone()),
                 code: Some(code.clone()),
-                text: text.clone(),
-                unmodified_text: text.clone(),
+                text: None,
+                unmodified_text: None,
                 windows_virtual_key_code: Some(key_code),
                 native_virtual_key_code: Some(key_code),
-                modifiers,
+                modifiers: None,
             },
             Some(session_id),
         )
@@ -329,7 +236,7 @@ pub async fn press_key_with_modifiers(
                 unmodified_text: None,
                 windows_virtual_key_code: Some(key_code),
                 native_virtual_key_code: Some(key_code),
-                modifiers,
+                modifiers: None,
             },
             Some(session_id),
         )
@@ -345,11 +252,9 @@ pub async fn scroll(
     selector_or_ref: Option<&str>,
     delta_x: f64,
     delta_y: f64,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
     if let Some(sel) = selector_or_ref {
-        let (object_id, effective_session_id) =
-            resolve_element_object_id(client, session_id, ref_map, sel, iframe_sessions).await?;
+        let object_id = resolve_element_object_id(client, session_id, ref_map, sel).await?;
         let js = "function(dx, dy) { this.scrollBy(dx, dy); }".to_string();
         client
             .send_command_typed::<_, Value>(
@@ -370,7 +275,7 @@ pub async fn scroll(
                     return_by_value: Some(true),
                     await_promise: Some(false),
                 },
-                Some(&effective_session_id),
+                Some(session_id),
             )
             .await?;
     } else {
@@ -396,16 +301,8 @@ pub async fn select_option(
     ref_map: &RefMap,
     selector_or_ref: &str,
     values: &[String],
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let js = r#"function(vals) {
             const options = Array.from(this.options);
@@ -429,7 +326,7 @@ pub async fn select_option(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -441,49 +338,11 @@ pub async fn check(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let is_checked = super::element::is_element_checked(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let is_checked =
+        super::element::is_element_checked(client, session_id, ref_map, selector_or_ref).await?;
     if !is_checked {
-        click(
-            client,
-            session_id,
-            ref_map,
-            selector_or_ref,
-            "left",
-            1,
-            iframe_sessions,
-        )
-        .await?;
-
-        // Verify the click changed the state (Playwright parity: _setChecked re-checks).
-        // If the coordinate-based click missed (e.g. hidden input, overlay), retry
-        // with a JS .click() on the element and its associated input.
-        if !super::element::is_element_checked(
-            client,
-            session_id,
-            ref_map,
-            selector_or_ref,
-            iframe_sessions,
-        )
-        .await?
-        {
-            js_click_checkbox(
-                client,
-                session_id,
-                ref_map,
-                selector_or_ref,
-                iframe_sessions,
-            )
-            .await?;
-        }
+        click(client, session_id, ref_map, selector_or_ref, "left", 1).await?;
     }
     Ok(())
 }
@@ -493,132 +352,22 @@ pub async fn uncheck(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let is_checked = super::element::is_element_checked(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let is_checked =
+        super::element::is_element_checked(client, session_id, ref_map, selector_or_ref).await?;
     if is_checked {
-        click(
-            client,
-            session_id,
-            ref_map,
-            selector_or_ref,
-            "left",
-            1,
-            iframe_sessions,
-        )
-        .await?;
-
-        // Same verify-and-retry as check().
-        if super::element::is_element_checked(
-            client,
-            session_id,
-            ref_map,
-            selector_or_ref,
-            iframe_sessions,
-        )
-        .await?
-        {
-            js_click_checkbox(
-                client,
-                session_id,
-                ref_map,
-                selector_or_ref,
-                iframe_sessions,
-            )
-            .await?;
-        }
+        click(client, session_id, ref_map, selector_or_ref, "left", 1).await?;
     }
     Ok(())
 }
 
-/// Fallback for when the coordinate-based CDP click did not toggle the
-/// checkbox/radio state. This mirrors how Playwright dispatches clicks
-/// through the DOM rather than via raw Input.dispatchMouseEvent coordinates.
-///
-/// Uses the same follow-label resolution as `is_element_checked`:
-/// 1. If the element is a native input → `.click()` it directly.
-/// 2. If the element is inside a `<label>` → `.click()` the label's `.control`.
-/// 3. If the element has a nested `<input>` → `.click()` that input.
-/// 4. Otherwise → `.click()` the element itself (handles ARIA role controls).
-async fn js_click_checkbox(
-    client: &CdpClient,
-    session_id: &str,
-    ref_map: &RefMap,
-    selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
-) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
-
-    let js = r#"function() {
-            var el = this;
-            var tag = el.tagName && el.tagName.toUpperCase();
-            // 1. Native input — click it directly
-            if (tag === 'INPUT' && (el.type === 'checkbox' || el.type === 'radio')) {
-                el.click();
-                return;
-            }
-            // 2. Follow label → control association
-            var label = tag === 'LABEL' ? el : (el.closest && el.closest('label'));
-            if (label && label.tagName && label.tagName.toUpperCase() === 'LABEL' && label.control) {
-                label.control.click();
-                return;
-            }
-            // 3. Nested native input
-            var input = el.querySelector && el.querySelector('input[type="checkbox"], input[type="radio"]');
-            if (input) {
-                input.click();
-                return;
-            }
-            // 4. ARIA role control — click the element itself
-            el.click();
-        }"#;
-
-    client
-        .send_command_typed::<_, Value>(
-            "Runtime.callFunctionOn",
-            &CallFunctionOnParams {
-                function_declaration: js.to_string(),
-                object_id: Some(object_id),
-                arguments: None,
-                return_by_value: Some(true),
-                await_promise: Some(false),
-            },
-            Some(&effective_session_id),
-        )
-        .await?;
-
-    Ok(())
-}
-
 pub async fn focus(
     client: &CdpClient,
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     client
         .send_command_typed::<_, Value>(
@@ -630,7 +379,7 @@ pub async fn focus(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -642,16 +391,8 @@ pub async fn clear(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     client
         .send_command_typed::<_, Value>(
@@ -669,7 +410,7 @@ pub async fn clear(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -681,16 +422,8 @@ pub async fn select_all(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     client
         .send_command_typed::<_, Value>(
@@ -714,7 +447,7 @@ pub async fn select_all(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -726,16 +459,8 @@ pub async fn scroll_into_view(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     client
         .send_command_typed::<_, Value>(
@@ -749,7 +474,7 @@ pub async fn scroll_into_view(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -763,16 +488,8 @@ pub async fn dispatch_event(
     selector_or_ref: &str,
     event_type: &str,
     event_init: Option<&Value>,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     let init_json = event_init
         .map(|v| serde_json::to_string(v).unwrap_or("{}".to_string()))
@@ -794,7 +511,7 @@ pub async fn dispatch_event(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -806,16 +523,8 @@ pub async fn highlight(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (object_id, effective_session_id) = resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let object_id = resolve_element_object_id(client, session_id, ref_map, selector_or_ref).await?;
 
     client
         .send_command_typed::<_, Value>(
@@ -836,7 +545,7 @@ pub async fn highlight(
                 return_by_value: Some(true),
                 await_promise: Some(false),
             },
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -848,16 +557,8 @@ pub async fn tap_touch(
     session_id: &str,
     ref_map: &RefMap,
     selector_or_ref: &str,
-    iframe_sessions: &HashMap<String, String>,
 ) -> Result<(), String> {
-    let (x, y, effective_session_id) = resolve_element_center(
-        client,
-        session_id,
-        ref_map,
-        selector_or_ref,
-        iframe_sessions,
-    )
-    .await?;
+    let (x, y) = resolve_element_center(client, session_id, ref_map, selector_or_ref).await?;
 
     client
         .send_command(
@@ -866,7 +567,7 @@ pub async fn tap_touch(
                 "type": "touchStart",
                 "touchPoints": [{ "x": x, "y": y }],
             })),
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -877,7 +578,7 @@ pub async fn tap_touch(
                 "type": "touchEnd",
                 "touchPoints": [],
             })),
-            Some(&effective_session_id),
+            Some(session_id),
         )
         .await?;
 
@@ -965,75 +666,15 @@ fn char_to_key_info(ch: char) -> (String, String, i32) {
         ' ' => (" ".to_string(), "Space".to_string(), 32),
         _ => {
             let key = ch.to_string();
-            if ch.is_ascii_alphabetic() {
-                // For letters the Windows VK code equals the uppercase ASCII value.
-                let upper = ch.to_ascii_uppercase();
-                let code = format!("Key{}", upper);
-                let key_code = upper as i32;
-                (key, code, key_code)
+            let code = if ch.is_ascii_alphabetic() {
+                format!("Key{}", ch.to_uppercase())
             } else if ch.is_ascii_digit() {
-                let code = format!("Digit{}", ch);
-                let key_code = ch as i32;
-                (key, code, key_code)
+                format!("Digit{}", ch)
             } else {
-                let (code, key_code) = punctuation_key_info(ch);
-                (key, code.to_string(), key_code)
-            }
-        }
-    }
-}
-
-/// Return the DOM `KeyboardEvent.code` value and Windows virtual-key code for
-/// a punctuation / symbol character assuming a US keyboard layout.
-///
-/// The Windows virtual-key codes (VK_OEM_*) differ from ASCII values for
-/// punctuation.  Using the raw ASCII code would misidentify characters – e.g.
-/// '.' (ASCII 46) collides with VK_DELETE (0x2E = 46), causing the period to
-/// be swallowed.
-fn punctuation_key_info(ch: char) -> (&'static str, i32) {
-    match ch {
-        // VK_OEM_1 (0xBA = 186) — ";:" key on US layout
-        ';' | ':' => ("Semicolon", 186),
-        // VK_OEM_PLUS (0xBB = 187) — "=+" key
-        '=' | '+' => ("Equal", 187),
-        // VK_OEM_COMMA (0xBC = 188) — ",<" key
-        ',' | '<' => ("Comma", 188),
-        // VK_OEM_MINUS (0xBD = 189) — "-_" key
-        '-' | '_' => ("Minus", 189),
-        // VK_OEM_PERIOD (0xBE = 190) — ".>" key
-        '.' | '>' => ("Period", 190),
-        // VK_OEM_2 (0xBF = 191) — "/?" key
-        '/' | '?' => ("Slash", 191),
-        // VK_OEM_3 (0xC0 = 192) — "`~" key
-        '`' | '~' => ("Backquote", 192),
-        // VK_OEM_4 (0xDB = 219) — "[{" key
-        '[' | '{' => ("BracketLeft", 219),
-        // VK_OEM_5 (0xDC = 220) — "\\|" key
-        '\\' | '|' => ("Backslash", 220),
-        // VK_OEM_6 (0xDD = 221) — "]}" key
-        ']' | '}' => ("BracketRight", 221),
-        // VK_OEM_7 (0xDE = 222) — "'\""" key
-        '\'' | '"' => ("Quote", 222),
-        _ => ("", 0),
-    }
-}
-
-/// Return the `text` value that CDP `Input.dispatchKeyEvent` needs on the
-/// `keyDown` event so that Chrome performs the default action for the key.
-/// For example Enter needs `"\r"` to actually submit a form, and Tab needs
-/// `"\t"` to move focus.  Non-printable / navigation keys return `None`.
-fn key_text(key_name: &str) -> Option<String> {
-    match key_name {
-        "Enter" => Some("\r".to_string()),
-        "Tab" => Some("\t".to_string()),
-        " " => Some(" ".to_string()),
-        _ => {
-            // Single printable characters carry themselves as text.
-            if key_name.len() == 1 {
-                Some(key_name.to_string())
-            } else {
-                None
-            }
+                String::new()
+            };
+            let key_code = ch as i32;
+            (key, code, key_code)
         }
     }
 }
@@ -1064,120 +705,3 @@ fn named_key_info(key: &str) -> (String, String, i32) {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// Verify that `char_to_key_info` returns the correct (key, code,
-    /// windowsVirtualKeyCode) triple for every character in Playwright's
-    /// USKeyboardLayout.  The expected values below are taken verbatim from
-    /// playwright-core/lib/server/usKeyboardLayout.js so that any drift from
-    /// Playwright's behaviour is caught immediately.
-    #[test]
-    fn test_char_to_key_info_matches_playwright_layout() {
-        // (character, expected_code, expected_vk_code)
-        let cases: &[(char, &str, i32)] = &[
-            // Letters – VK code must equal the uppercase ASCII value.
-            ('a', "KeyA", 65),
-            ('z', "KeyZ", 90),
-            ('A', "KeyA", 65),
-            // Digits
-            ('0', "Digit0", 48),
-            ('9', "Digit9", 57),
-            // Punctuation – these are the values from Playwright's layout.
-            // The bug that prompted this test sent '.' as VK 46 (= VK_DELETE).
-            ('.', "Period", 190),
-            (',', "Comma", 188),
-            ('/', "Slash", 191),
-            (';', "Semicolon", 186),
-            ('\'', "Quote", 222),
-            ('[', "BracketLeft", 219),
-            (']', "BracketRight", 221),
-            ('\\', "Backslash", 220),
-            ('`', "Backquote", 192),
-            ('-', "Minus", 189),
-            ('=', "Equal", 187),
-            // Shifted variants produced by the same physical keys.
-            ('>', "Period", 190),
-            ('<', "Comma", 188),
-            ('?', "Slash", 191),
-            (':', "Semicolon", 186),
-            ('"', "Quote", 222),
-            ('{', "BracketLeft", 219),
-            ('}', "BracketRight", 221),
-            ('|', "Backslash", 220),
-            ('~', "Backquote", 192),
-            ('_', "Minus", 189),
-            ('+', "Equal", 187),
-            // Whitespace / control
-            (' ', "Space", 32),
-            ('\n', "Enter", 13),
-            ('\t', "Tab", 9),
-        ];
-
-        for &(ch, expected_code, expected_vk) in cases {
-            let (key, code, vk) = char_to_key_info(ch);
-            assert_eq!(
-                code, expected_code,
-                "char {:?}: expected code {:?}, got {:?}",
-                ch, expected_code, code
-            );
-            assert_eq!(
-                vk, expected_vk,
-                "char {:?}: expected VK {}, got {} (ASCII would be {})",
-                ch, expected_vk, vk, ch as i32
-            );
-            // key should be the character itself (except control chars).
-            if !ch.is_control() {
-                assert_eq!(key, ch.to_string(), "char {:?}: key mismatch", ch);
-            }
-        }
-    }
-
-    /// Regression test: period must NEVER map to VK 46 (VK_DELETE).
-    #[test]
-    fn test_period_is_not_vk_delete() {
-        let (_, _, vk) = char_to_key_info('.');
-        assert_ne!(
-            vk, 46,
-            "Period must not use VK code 46 (VK_DELETE); expected 190 (VK_OEM_PERIOD)"
-        );
-        assert_eq!(vk, 190);
-    }
-
-    /// Characters outside the US keyboard layout should return (key, "", 0)
-    /// so that `type_text` falls back to `Input.insertText`.
-    #[test]
-    fn test_unmapped_chars_return_zero_keycode() {
-        for ch in ['@', '#', '$', '%', '^', '&', '*', '(', ')', '€', '£', '你'] {
-            let (key, code, vk) = char_to_key_info(ch);
-            assert_eq!(
-                code, "",
-                "char {:?}: unmapped char should have empty code, got {:?}",
-                ch, code
-            );
-            assert_eq!(
-                vk, 0,
-                "char {:?}: unmapped char should have VK 0, got {}",
-                ch, vk
-            );
-            assert_eq!(key, ch.to_string());
-        }
-    }
-
-    #[test]
-    fn test_key_text_returns_correct_text_for_special_keys() {
-        assert_eq!(key_text("Enter"), Some("\r".to_string()));
-        assert_eq!(key_text("Tab"), Some("\t".to_string()));
-        assert_eq!(key_text(" "), Some(" ".to_string()));
-        // Single printable characters carry themselves.
-        assert_eq!(key_text("a"), Some("a".to_string()));
-        assert_eq!(key_text("Z"), Some("Z".to_string()));
-        // Non-printable named keys return None.
-        assert_eq!(key_text("Escape"), None);
-        assert_eq!(key_text("ArrowUp"), None);
-        assert_eq!(key_text("Backspace"), None);
-        assert_eq!(key_text("Delete"), None);
-    }
-}

cli/src/native/mod.rs

@@ -15,8 +15,6 @@ pub mod diff;
 #[allow(dead_code)]
 pub mod element;
 #[allow(dead_code)]
-pub mod inspect_server;
-#[allow(dead_code)]
 pub mod interaction;
 #[allow(dead_code)]
 pub mod network;

cli/src/native/network.rs

@@ -184,7 +184,7 @@ pub async fn install_domain_filter_script(
             const OrigWS = window.WebSocket;
             window.WebSocket = function(url, protocols) {{
                 try {{
-                    const u = new URL(url, location.href);
+                    const u = new URL(url);
                     if (!_isDomainAllowed(u.hostname)) throw new DOMException('WebSocket blocked: ' + u.hostname, 'SecurityError');
                 }} catch(e) {{ if (e instanceof DOMException) throw e; }}
                 return new OrigWS(url, protocols);
@@ -233,16 +233,15 @@ pub async fn install_domain_filter_script(
 pub async fn install_domain_filter_fetch(
     client: &CdpClient,
     session_id: &str,
-    handle_auth_requests: bool,
 ) -> Result<(), String> {
-    let mut params = json!({
-        "patterns": [{ "urlPattern": "*" }]
-    });
-    if handle_auth_requests {
-        params["handleAuthRequests"] = json!(true);
-    }
     client
-        .send_command("Fetch.enable", Some(params), Some(session_id))
+        .send_command(
+            "Fetch.enable",
+            Some(json!({
+                "patterns": [{ "urlPattern": "*" }]
+            })),
+            Some(session_id),
+        )
         .await?;
     Ok(())
 }
@@ -254,103 +253,12 @@ pub async fn install_domain_filter(
     client: &CdpClient,
     session_id: &str,
     allowed_domains: &[String],
-    handle_auth_requests: bool,
 ) -> Result<(), String> {
     install_domain_filter_script(client, session_id, allowed_domains).await?;
-    install_domain_filter_fetch(client, session_id, handle_auth_requests).await?;
+    install_domain_filter_fetch(client, session_id).await?;
     Ok(())
 }
 
-// ---------------------------------------------------------------------------
-// Console arg formatting (CDP RemoteObject → human-readable string)
-// ---------------------------------------------------------------------------
-
-/// Format a single CDP RemoteObject arg into a human-readable string.
-/// Priority: value → preview → description.
-pub fn format_console_arg(arg: &Value) -> Option<String> {
-    let obj_type = arg.get("type").and_then(|v| v.as_str()).unwrap_or("");
-    let subtype = arg.get("subtype").and_then(|v| v.as_str());
-
-    if obj_type == "undefined" {
-        return Some("undefined".to_string());
-    }
-
-    if subtype == Some("null") {
-        return Some("null".to_string());
-    }
-
-    // Primitive value
-    if let Some(v) = arg.get("value") {
-        return Some(match v {
-            Value::String(s) => s.clone(),
-            Value::Null => "null".to_string(),
-            other => other.to_string(),
-        });
-    }
-
-    // Skip preview for Map/Set — their description ("Map(1)", "Set(3)") is more useful
-    // than their preview properties (which only show "size")
-    if let Some(preview) = arg.get("preview") {
-        let preview_subtype = preview.get("subtype").and_then(|v| v.as_str());
-        if matches!(preview_subtype, Some("map" | "set" | "weakmap" | "weakset")) {
-            return arg
-                .get("description")
-                .and_then(|v| v.as_str())
-                .map(|s| s.to_string());
-        }
-        let is_array = subtype == Some("array") || preview_subtype == Some("array");
-        if let Some(props) = preview.get("properties").and_then(|v| v.as_array()) {
-            let overflow = preview
-                .get("overflow")
-                .and_then(|v| v.as_bool())
-                .unwrap_or(false);
-            let formatted_props: Vec<String> = props
-                .iter()
-                .filter_map(|p| {
-                    let value_str = p.get("value").and_then(|v| v.as_str())?;
-                    let prop_type = p.get("type").and_then(|v| v.as_str()).unwrap_or("");
-                    let formatted_value = if prop_type == "string" {
-                        format!("\"{}\"", value_str)
-                    } else {
-                        value_str.to_string()
-                    };
-                    if is_array {
-                        Some(formatted_value)
-                    } else {
-                        let name = p.get("name").and_then(|v| v.as_str()).unwrap_or("?");
-                        Some(format!("{}: {}", name, formatted_value))
-                    }
-                })
-                .collect();
-
-            let inner = if overflow {
-                format!("{}, ...", formatted_props.join(", "))
-            } else {
-                formatted_props.join(", ")
-            };
-
-            return if is_array {
-                Some(format!("[{}]", inner))
-            } else {
-                Some(format!("{{{}}}", inner))
-            };
-        }
-    }
-
-    // Fallback to description
-    arg.get("description")
-        .and_then(|v| v.as_str())
-        .map(|s| s.to_string())
-}
-
-/// Format an array of CDP RemoteObject args into a single space-separated string.
-pub fn format_console_args(args: &[Value]) -> String {
-    args.iter()
-        .filter_map(format_console_arg)
-        .collect::<Vec<_>>()
-        .join(" ")
-}
-
 // ---------------------------------------------------------------------------
 // Console and error tracking
 // ---------------------------------------------------------------------------
@@ -359,7 +267,6 @@ pub fn format_console_args(args: &[Value]) -> String {
 pub struct ConsoleEntry {
     pub level: String,
     pub text: String,
-    pub args: Vec<Value>,
 }
 
 #[derive(Debug, Clone)]
@@ -385,14 +292,13 @@ impl EventTracker {
         }
     }
 
-    pub fn add_console(&mut self, level: &str, text: &str, args: Vec<Value>) {
+    pub fn add_console(&mut self, level: &str, text: &str) {
         if self.console_entries.len() >= self.max_entries {
             self.console_entries.remove(0);
         }
         self.console_entries.push(ConsoleEntry {
             level: level.to_string(),
             text: text.to_string(),
-            args,
         });
     }
 
@@ -414,25 +320,13 @@ impl EventTracker {
         });
     }
 
-    pub fn clear_console(&mut self) {
-        self.console_entries.clear();
-    }
-
     pub fn get_console_json(&self) -> Value {
-        let messages: Vec<Value> = self
+        let entries: Vec<Value> = self
             .console_entries
             .iter()
-            .map(|e| {
-                let mut msg = json!({ "type": e.level, "text": e.text });
-                if !e.args.is_empty() {
-                    msg.as_object_mut()
-                        .unwrap()
-                        .insert("args".to_string(), Value::Array(e.args.clone()));
-                }
-                msg
-            })
+            .map(|e| json!({ "level": e.level, "text": e.text }))
             .collect();
-        json!({ "messages": messages })
+        json!({ "entries": entries })
     }
 
     pub fn get_errors_json(&self) -> Value {
@@ -496,177 +390,10 @@ mod tests {
     #[test]
     fn test_event_tracker() {
         let mut tracker = EventTracker::new();
-        tracker.add_console("log", "hello", vec![]);
+        tracker.add_console("log", "hello");
         tracker.add_error("oops", Some("test.js"), Some(1), Some(5));
 
         assert_eq!(tracker.console_entries.len(), 1);
         assert_eq!(tracker.error_entries.len(), 1);
     }
-
-    #[test]
-    fn test_console_json_includes_args() {
-        let mut tracker = EventTracker::new();
-        let raw_args = vec![
-            json!({"type": "string", "value": "hello"}),
-            json!({"type": "number", "value": 42}),
-        ];
-        tracker.add_console("log", "hello 42", raw_args);
-
-        let result = tracker.get_console_json();
-        let messages = result.get("messages").unwrap().as_array().unwrap();
-        assert_eq!(messages.len(), 1);
-        assert_eq!(messages[0].get("text").unwrap(), "hello 42");
-        let args = messages[0].get("args").unwrap().as_array().unwrap();
-        assert_eq!(args.len(), 2);
-        assert_eq!(args[0], json!({"type": "string", "value": "hello"}));
-        assert_eq!(args[1], json!({"type": "number", "value": 42}));
-    }
-
-    #[test]
-    fn test_console_json_empty_args_omits_field() {
-        let mut tracker = EventTracker::new();
-        tracker.add_console("log", "text only", vec![]);
-
-        let result = tracker.get_console_json();
-        let messages = result.get("messages").unwrap().as_array().unwrap();
-        assert!(messages[0].get("args").is_none());
-    }
-
-    // -- format_console_arg: primitives --
-
-    #[test]
-    fn test_format_arg_string() {
-        let arg = json!({"type": "string", "value": "hello"});
-        assert_eq!(format_console_arg(&arg), Some("hello".to_string()));
-    }
-
-    #[test]
-    fn test_format_arg_number() {
-        let arg = json!({"type": "number", "value": 42});
-        assert_eq!(format_console_arg(&arg), Some("42".to_string()));
-    }
-
-    #[test]
-    fn test_format_arg_null() {
-        let arg = json!({"type": "object", "subtype": "null", "value": null});
-        assert_eq!(format_console_arg(&arg), Some("null".to_string()));
-    }
-
-    #[test]
-    fn test_format_arg_undefined() {
-        let arg = json!({"type": "undefined"});
-        assert_eq!(format_console_arg(&arg), Some("undefined".to_string()));
-    }
-
-    // -- format_console_arg: objects with preview --
-
-    #[test]
-    fn test_format_arg_object_preview() {
-        let arg = json!({
-            "type": "object",
-            "preview": {
-                "properties": [
-                    {"name": "userId", "type": "string", "value": "abc123"},
-                    {"name": "count", "type": "number", "value": "42"}
-                ],
-                "overflow": false
-            }
-        });
-        assert_eq!(
-            format_console_arg(&arg),
-            Some("{userId: \"abc123\", count: 42}".to_string())
-        );
-    }
-
-    #[test]
-    fn test_format_arg_object_preview_overflow() {
-        let arg = json!({
-            "type": "object",
-            "preview": {
-                "properties": [
-                    {"name": "a", "type": "number", "value": "1"}
-                ],
-                "overflow": true
-            }
-        });
-        assert_eq!(format_console_arg(&arg), Some("{a: 1, ...}".to_string()));
-    }
-
-    // -- format_console_arg: arrays with preview --
-
-    #[test]
-    fn test_format_arg_array_preview() {
-        let arg = json!({
-            "type": "object",
-            "subtype": "array",
-            "preview": {
-                "subtype": "array",
-                "properties": [
-                    {"name": "0", "type": "number", "value": "1"},
-                    {"name": "1", "type": "number", "value": "2"},
-                    {"name": "2", "type": "number", "value": "3"}
-                ],
-                "overflow": false
-            }
-        });
-        assert_eq!(format_console_arg(&arg), Some("[1, 2, 3]".to_string()));
-    }
-
-    // -- format_console_arg: map/set use description --
-
-    #[test]
-    fn test_format_arg_map_uses_description() {
-        let arg = json!({
-            "type": "object",
-            "subtype": "map",
-            "description": "Map(1)",
-            "preview": {
-                "subtype": "map",
-                "properties": [{"name": "size", "type": "number", "value": "1"}]
-            }
-        });
-        assert_eq!(format_console_arg(&arg), Some("Map(1)".to_string()));
-    }
-
-    // -- format_console_arg: fallback --
-
-    #[test]
-    fn test_format_arg_description_fallback() {
-        let arg = json!({"type": "object", "description": "RegExp"});
-        assert_eq!(format_console_arg(&arg), Some("RegExp".to_string()));
-    }
-
-    #[test]
-    fn test_format_arg_no_value_no_preview_no_description() {
-        let arg = json!({"type": "object"});
-        assert_eq!(format_console_arg(&arg), None);
-    }
-
-    // -- format_console_args --
-
-    #[test]
-    fn test_format_console_args_join() {
-        let args = vec![
-            json!({"type": "string", "value": "user"}),
-            json!({
-                "type": "object",
-                "preview": {
-                    "properties": [{"name": "id", "type": "number", "value": "1"}],
-                    "overflow": false
-                }
-            }),
-        ];
-        assert_eq!(format_console_args(&args), "user {id: 1}");
-    }
-
-    #[test]
-    fn test_format_console_args_filters_none() {
-        // An arg that returns None should be skipped, not produce empty string
-        let args = vec![
-            json!({"type": "string", "value": "before"}),
-            json!({"type": "object"}), // no value, preview, or description → None
-            json!({"type": "string", "value": "after"}),
-        ];
-        assert_eq!(format_console_args(&args), "before after");
-    }
 }

cli/src/native/parity_tests.rs

@@ -9,38 +9,6 @@ use serde_json::{json, Value};
 
 use super::actions::{execute_command, DaemonState};
 
-const ENCRYPTION_KEY_ENV: &str = "AGENT_BROWSER_ENCRYPTION_KEY";
-
-struct TestKeyGuard {
-    _lock: std::sync::MutexGuard<'static, ()>,
-    original: Option<String>,
-}
-
-impl TestKeyGuard {
-    fn new() -> Self {
-        let lock = super::auth::AUTH_TEST_MUTEX
-            .lock()
-            .unwrap_or_else(|e| e.into_inner());
-        let original = std::env::var(ENCRYPTION_KEY_ENV).ok();
-        // SAFETY: AUTH_TEST_MUTEX serializes all test access so no concurrent mutation.
-        unsafe { std::env::set_var(ENCRYPTION_KEY_ENV, "a".repeat(64)) };
-        Self {
-            _lock: lock,
-            original,
-        }
-    }
-}
-
-impl Drop for TestKeyGuard {
-    fn drop(&mut self) {
-        // SAFETY: AUTH_TEST_MUTEX is held via _lock.
-        match &self.original {
-            Some(val) => unsafe { std::env::set_var(ENCRYPTION_KEY_ENV, val) },
-            None => unsafe { std::env::remove_var(ENCRYPTION_KEY_ENV) },
-        }
-    }
-}
-
 /// All documented action names that should be implemented.
 const DOCUMENTED_ACTIONS: &[&str] = &[
     "launch",
@@ -172,7 +140,6 @@ const DOCUMENTED_ACTIONS: &[&str] = &[
     "route",
     "unroute",
     "requests",
-    "request_detail",
     "credentials",
     "auth_save",
     "auth_login",
@@ -344,7 +311,7 @@ fn minimal_command(action: &str, id: &str) -> Value {
             obj.insert("script".to_string(), json!("h => h"));
         }
         "drag" => {
-            obj.insert("source".to_string(), json!("body"));
+            obj.insert("selector".to_string(), json!("body"));
             obj.insert("target".to_string(), json!("body"));
         }
         "swipe" => {
@@ -457,7 +424,6 @@ async fn test_credentials_list_without_browser() {
 #[tokio::test]
 async fn test_auth_profile_name_validation() {
     use super::auth;
-    let _key_guard = TestKeyGuard::new();
     let valid = auth::credentials_set("valid-name_123", "u", "p", None);
     assert!(valid.is_ok());
     let invalid = auth::credentials_set("invalid/name", "u", "p", None);
@@ -473,7 +439,6 @@ async fn test_auth_profile_name_validation() {
 #[tokio::test]
 async fn test_auth_save_and_show() {
     use super::auth;
-    let _key_guard = TestKeyGuard::new();
     let result = auth::auth_save(
         "parity-roundtrip",
         "https://example.com",
@@ -534,7 +499,6 @@ async fn test_daemon_state_new_defaults() {
     assert!(state.tracked_requests.is_empty());
     assert!(state.active_frame_id.is_none());
     assert!(state.webdriver_backend.is_none());
-    assert!(state.stream_client.is_none());
 }
 
 #[tokio::test]
@@ -546,11 +510,6 @@ async fn test_tracked_request_struct() {
         headers: json!({"Accept": "text/html"}),
         timestamp: 12345,
         resource_type: "Document".to_string(),
-        request_id: "1.1".to_string(),
-        post_data: None,
-        status: Some(200),
-        response_headers: None,
-        mime_type: Some("text/html".to_string()),
     };
     let serialized = serde_json::to_value(&tr).unwrap();
     assert_eq!(serialized["url"], "https://example.com/api");
@@ -571,11 +530,6 @@ async fn test_request_tracking_state() {
         headers: json!({}),
         timestamp: 1,
         resource_type: "Document".to_string(),
-        request_id: "1.1".to_string(),
-        post_data: None,
-        status: None,
-        response_headers: None,
-        mime_type: None,
     });
     state.tracked_requests.push(super::actions::TrackedRequest {
         url: "https://other.com".to_string(),
@@ -583,11 +537,6 @@ async fn test_request_tracking_state() {
         headers: json!({}),
         timestamp: 2,
         resource_type: "XHR".to_string(),
-        request_id: "1.2".to_string(),
-        post_data: None,
-        status: None,
-        response_headers: None,
-        mime_type: None,
     });
     assert_eq!(state.tracked_requests.len(), 2);
 
@@ -605,30 +554,6 @@ async fn test_request_tracking_state() {
     assert!(state.tracked_requests.is_empty());
 }
 
-#[test]
-fn test_matches_status_filter() {
-    use super::actions::matches_status_filter;
-
-    // Exact match
-    assert!(matches_status_filter(Some(200), "200"));
-    assert!(!matches_status_filter(Some(201), "200"));
-
-    // Class match (Nxx)
-    assert!(matches_status_filter(Some(200), "2xx"));
-    assert!(matches_status_filter(Some(299), "2xx"));
-    assert!(!matches_status_filter(Some(301), "2xx"));
-    assert!(matches_status_filter(Some(404), "4xx"));
-
-    // Range match
-    assert!(matches_status_filter(Some(400), "400-499"));
-    assert!(matches_status_filter(Some(499), "400-499"));
-    assert!(!matches_status_filter(Some(500), "400-499"));
-
-    // None status
-    assert!(!matches_status_filter(None, "200"));
-    assert!(!matches_status_filter(None, "2xx"));
-}
-
 #[tokio::test]
 async fn test_addscript_and_addinitscript_separate_dispatch() {
     let mut state = DaemonState::new();

cli/src/native/policy.rs

@@ -135,7 +135,6 @@ impl ActionPolicy {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::EnvGuard;
 
     #[test]
     fn test_policy_allow_whitelist() {
@@ -206,12 +205,12 @@ mod tests {
 
     #[test]
     fn test_confirm_actions_from_env() {
-        let _guard = EnvGuard::new(&["AGENT_BROWSER_CONFIRM_ACTIONS"]);
-        _guard.set("AGENT_BROWSER_CONFIRM_ACTIONS", "navigate,click,fill");
+        env::set_var("AGENT_BROWSER_CONFIRM_ACTIONS", "navigate,click,fill");
         let ca = ConfirmActions::from_env().unwrap();
         assert!(ca.requires_confirmation("navigate"));
         assert!(ca.requires_confirmation("click"));
         assert!(ca.requires_confirmation("fill"));
         assert!(!ca.requires_confirmation("screenshot"));
+        env::remove_var("AGENT_BROWSER_CONFIRM_ACTIONS");
     }
 }

cli/src/native/providers.rs

@@ -1,72 +1,28 @@
 //! Browser provider connections for remote CDP sessions.
 //!
-//! Supports AgentCore, Browserbase, Browserless, Browser Use, and Kernel providers.
-//! Each provider returns a CDP WebSocket URL for connecting via BrowserManager.
+//! Supports Browserbase, Browser Use, and Kernel providers. Each provider
+//! returns a CDP WebSocket URL for connecting via BrowserManager.
 
 use serde_json::{json, Value};
 use std::env;
 
 /// Provider session info for cleanup on failure.
-#[derive(Debug)]
 pub struct ProviderSession {
     pub provider: String,
     pub session_id: String,
 }
 
-#[derive(Debug)]
-pub struct ProviderConnection {
-    pub ws_url: String,
-    pub session: Option<ProviderSession>,
-    /// If true, the WebSocket IS the page session (no Target.* commands).
-    pub direct_page: bool,
-}
-
 /// Connects to the specified browser provider and returns a CDP WebSocket URL
 /// along with session info for cleanup on failure.
-pub async fn connect_provider(provider_name: &str) -> Result<ProviderConnection, String> {
+pub async fn connect_provider(
+    provider_name: &str,
+) -> Result<(String, Option<ProviderSession>), String> {
     match provider_name.to_lowercase().as_str() {
-        "browserbase" => {
-            let (url, session) = connect_browserbase().await?;
-            Ok(ProviderConnection {
-                ws_url: url,
-                session,
-                direct_page: false,
-            })
-        }
-        "browserless" => {
-            let (url, session) = connect_browserless().await?;
-            Ok(ProviderConnection {
-                ws_url: url,
-                session,
-                direct_page: false,
-            })
-        }
-        "browser-use" | "browseruse" => {
-            let (url, session) = connect_browser_use().await?;
-            Ok(ProviderConnection {
-                ws_url: url,
-                session,
-                direct_page: false,
-            })
-        }
-        "kernel" => {
-            let (url, session) = connect_kernel().await?;
-            Ok(ProviderConnection {
-                ws_url: url,
-                session,
-                direct_page: false,
-            })
-        }
-        "agentcore" => {
-            let (url, session) = connect_agentcore().await?;
-            Ok(ProviderConnection {
-                ws_url: url,
-                session,
-                direct_page: false,
-            })
-        }
+        "browserbase" => connect_browserbase().await,
+        "browser-use" | "browseruse" => connect_browser_use().await,
+        "kernel" => connect_kernel().await,
         _ => Err(format!(
-            "Unknown provider '{}'. Supported: browserbase, browserless, browser-use, kernel, agentcore",
+            "Unknown provider '{}'. Supported: browserbase, browser-use, kernel",
             provider_name
         )),
     }
@@ -79,13 +35,11 @@ pub async fn close_provider_session(session: &ProviderSession) {
         "browserbase" => {
             if let Ok(api_key) = env::var("BROWSERBASE_API_KEY") {
                 let _ = client
-                    .post(format!(
+                    .delete(format!(
                         "https://api.browserbase.com/v1/sessions/{}",
                         session.session_id
                     ))
-                    .header("Content-Type", "application/json")
                     .header("X-BB-API-Key", &api_key)
-                    .json(&serde_json::json!({ "status": "REQUEST_RELEASE" }))
                     .send()
                     .await;
             }
@@ -104,10 +58,6 @@ pub async fn close_provider_session(session: &ProviderSession) {
                     .await;
             }
         }
-        "browserless" => {
-            // session_id holds the stop URL for browserless
-            let _ = client.delete(&session.session_id).send().await;
-        }
         "kernel" => {
             if let Ok(api_key) = env::var("KERNEL_API_KEY") {
                 let endpoint = env::var("KERNEL_ENDPOINT")
@@ -123,10 +73,6 @@ pub async fn close_provider_session(session: &ProviderSession) {
                     .await;
             }
         }
-        "agentcore" => {
-            // AgentCore session cleanup is handled via signed DELETE request
-            let _ = close_agentcore_session(&session.session_id).await;
-        }
         _ => {}
     }
 }
@@ -134,13 +80,15 @@ pub async fn close_provider_session(session: &ProviderSession) {
 async fn connect_browserbase() -> Result<(String, Option<ProviderSession>), String> {
     let api_key = env::var("BROWSERBASE_API_KEY")
         .map_err(|_| "BROWSERBASE_API_KEY environment variable is not set")?;
+    let project_id = env::var("BROWSERBASE_PROJECT_ID")
+        .map_err(|_| "BROWSERBASE_PROJECT_ID environment variable is not set")?;
 
     let client = reqwest::Client::new();
     let response = client
         .post("https://api.browserbase.com/v1/sessions")
-        .header("content-type", "application/json")
-        .header("x-bb-api-key", &api_key)
-        .body("{}")
+        .header("Content-Type", "application/json")
+        .header("X-BB-API-Key", &api_key)
+        .json(&json!({ "projectId": project_id }))
         .send()
         .await
         .map_err(|e| format!("Browserbase request failed: {}", e))?;
@@ -183,98 +131,62 @@ async fn connect_browserbase() -> Result<(String, Option<ProviderSession>), Stri
     ))
 }
 
-async fn connect_browserless() -> Result<(String, Option<ProviderSession>), String> {
-    let api_key = env::var("BROWSERLESS_API_KEY")
-        .map_err(|_| "BROWSERLESS_API_KEY environment variable is not set")?;
-
-    let api_url = env::var("BROWSERLESS_API_URL")
-        .unwrap_or_else(|_| "https://production-sfo.browserless.io".to_string());
-    let browser_type =
-        env::var("BROWSERLESS_BROWSER_TYPE").unwrap_or_else(|_| "chromium".to_string());
-
-    let supported = ["chromium", "chrome"];
-    if !supported.contains(&browser_type.as_str()) {
-        return Err(format!(
-            "BROWSERLESS_BROWSER_TYPE \"{}\" is not supported. Only {} are allowed.",
-            browser_type,
-            supported.join(", ")
-        ));
-    }
-
-    let ttl: u64 = env::var("BROWSERLESS_TTL")
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(300000);
-    let stealth = env::var("BROWSERLESS_STEALTH")
-        .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
-        .unwrap_or(true);
-
-    let url = format!("{}/session", api_url.trim_end_matches('/'));
+async fn connect_browser_use() -> Result<(String, Option<ProviderSession>), String> {
+    let api_key = env::var("BROWSER_USE_API_KEY")
+        .map_err(|_| "BROWSER_USE_API_KEY environment variable is not set")?;
 
     let client = reqwest::Client::new();
     let response = client
-        .post(&url)
-        .query(&[("token", &api_key)])
+        .post("https://api.browser-use.com/api/v2/browsers")
         .header("Content-Type", "application/json")
-        .json(&json!({
-            "ttl": ttl,
-            "stealth": stealth,
-            "browser": browser_type,
-        }))
+        .header("X-Browser-Use-API-Key", &api_key)
+        .json(&json!({}))
         .send()
         .await
-        .map_err(|e| format!("Browserless request failed: {}", e))?;
+        .map_err(|e| format!("Browser Use request failed: {}", e))?;
 
     let status = response.status();
     let body = response
         .text()
         .await
-        .map_err(|e| format!("Failed to read Browserless response: {}", e))?;
+        .map_err(|e| format!("Failed to read Browser Use response: {}", e))?;
 
     if !status.is_success() {
         return Err(format!(
-            "Browserless API error ({}): {}",
+            "Browser Use API error ({}): {}",
             status.as_u16(),
             body
         ));
     }
 
     let json: Value =
-        serde_json::from_str(&body).map_err(|e| format!("Invalid Browserless response: {}", e))?;
+        serde_json::from_str(&body).map_err(|e| format!("Invalid Browser Use response: {}", e))?;
 
-    let connect_url = json
-        .get("connect")
+    let session_id = json
+        .get("id")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    let ws_url = json
+        .get("cdp_url")
+        .or_else(|| json.get("cdpUrl"))
         .and_then(|v| v.as_str())
         .map(String::from)
-        .ok_or_else(|| "Browserless response missing 'connect' URL".to_string())?;
-
-    let stop_url = json
-        .get("stop")
-        .and_then(|v| v.as_str())
-        .map(String::from)
-        .ok_or_else(|| "Browserless response missing 'stop' URL".to_string())?;
+        .ok_or_else(|| "Browser Use response missing cdp_url or cdpUrl".to_string())?;
 
     Ok((
-        connect_url,
+        ws_url,
         Some(ProviderSession {
-            provider: "browserless".to_string(),
-            // Store the stop URL as the session_id for cleanup
-            session_id: stop_url,
+            provider: "browser-use".to_string(),
+            session_id,
         }),
     ))
 }
 
-async fn connect_browser_use() -> Result<(String, Option<ProviderSession>), String> {
-    let api_key = env::var("BROWSER_USE_API_KEY")
-        .map_err(|_| "BROWSER_USE_API_KEY environment variable is not set")?;
-
-    let ws_url = format!("wss://connect.browser-use.com?apiKey={}", api_key);
-
-    Ok((ws_url, None))
-}
-
 async fn connect_kernel() -> Result<(String, Option<ProviderSession>), String> {
-    let api_key = env::var("KERNEL_API_KEY").ok();
+    let api_key =
+        env::var("KERNEL_API_KEY").map_err(|_| "KERNEL_API_KEY environment variable is not set")?;
     let endpoint =
         env::var("KERNEL_ENDPOINT").unwrap_or_else(|_| "https://api.onkernel.com".to_string());
 
@@ -306,11 +218,10 @@ async fn connect_kernel() -> Result<(String, Option<ProviderSession>), String> {
     }
 
     let client = reqwest::Client::new();
-    let mut request = client.post(&url).header("Content-Type", "application/json");
-    if let Some(ref key) = api_key {
-        request = request.header("Authorization", format!("Bearer {}", key));
-    }
-    let response = request
+    let response = client
+        .post(&url)
+        .header("Content-Type", "application/json")
+        .header("Authorization", format!("Bearer {}", api_key))
         .json(&body)
         .send()
         .await
@@ -361,456 +272,3 @@ async fn connect_kernel() -> Result<(String, Option<ProviderSession>), String> {
         }),
     ))
 }
-
-// ============================================================================
-// AgentCore Provider (AWS Bedrock AgentCore Browser)
-// ============================================================================
-
-mod agentcore {
-    use super::*;
-
-    /// AgentCore-specific session info for Live View URL
-    pub struct AgentCoreSessionInfo {
-        pub session_id: String,
-        pub browser_identifier: String,
-        pub region: String,
-        pub live_view_url: String,
-    }
-
-    thread_local! {
-        static AGENTCORE_INFO: std::cell::RefCell<Option<AgentCoreSessionInfo>> = const { std::cell::RefCell::new(None) };
-        static AGENTCORE_WS_HEADERS: std::cell::RefCell<Option<Vec<(String, String)>>> = const { std::cell::RefCell::new(None) };
-    }
-
-    pub fn set_agentcore_info(info: AgentCoreSessionInfo) {
-        AGENTCORE_INFO.with(|cell| *cell.borrow_mut() = Some(info));
-    }
-
-    pub fn get_agentcore_info() -> Option<AgentCoreSessionInfo> {
-        AGENTCORE_INFO.with(|cell| {
-            cell.borrow().as_ref().map(|i| AgentCoreSessionInfo {
-                session_id: i.session_id.clone(),
-                browser_identifier: i.browser_identifier.clone(),
-                region: i.region.clone(),
-                live_view_url: i.live_view_url.clone(),
-            })
-        })
-    }
-
-    pub fn set_agentcore_ws_headers(headers: Vec<(String, String)>) {
-        AGENTCORE_WS_HEADERS.with(|cell| *cell.borrow_mut() = Some(headers));
-    }
-
-    pub fn take_agentcore_ws_headers() -> Option<Vec<(String, String)>> {
-        AGENTCORE_WS_HEADERS.with(|cell| cell.borrow_mut().take())
-    }
-
-    pub async fn connect() -> Result<(String, Option<ProviderSession>), String> {
-        let region = env::var("AGENTCORE_REGION")
-            .or_else(|_| env::var("AWS_REGION"))
-            .or_else(|_| env::var("AWS_DEFAULT_REGION"))
-            .unwrap_or_else(|_| "us-east-1".to_string());
-        let browser_id =
-            env::var("AGENTCORE_BROWSER_ID").unwrap_or_else(|_| "aws.browser.v1".to_string());
-        let timeout_secs: u64 = env::var("AGENTCORE_SESSION_TIMEOUT")
-            .ok()
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(3600);
-
-        let host = format!("bedrock-agentcore.{}.amazonaws.com", region);
-        let path = format!(
-            "/browsers/{}/sessions/start",
-            urlencoding::encode(&browser_id)
-        );
-        let url = format!("https://{}{}", host, path);
-
-        // Generate a unique session name
-        let session_name = format!("agent-browser-{}", &uuid::Uuid::new_v4().to_string()[..8]);
-
-        let mut body_json = json!({
-            "name": session_name,
-            "sessionTimeoutSeconds": timeout_secs
-        });
-        if let Ok(profile_id) = env::var("AGENTCORE_PROFILE_ID") {
-            if !profile_id.is_empty() {
-                body_json.as_object_mut().unwrap().insert(
-                    "profileConfiguration".to_string(),
-                    json!({ "profileIdentifier": profile_id }),
-                );
-            }
-        }
-        let body = serde_json::to_string(&body_json)
-            .map_err(|e| format!("Failed to serialize request body: {}", e))?;
-
-        let signed_headers = sign_request("PUT", &url, &region, Some(&body)).await?;
-
-        let client = reqwest::Client::new();
-        let mut req = client.put(&url).body(body.clone());
-        for (key, value) in &signed_headers {
-            req = req.header(key.as_str(), value.as_str());
-        }
-
-        let response = req
-            .send()
-            .await
-            .map_err(|e| format!("AgentCore request failed: {}", e))?;
-
-        let status = response.status();
-        let resp_body = response
-            .text()
-            .await
-            .map_err(|e| format!("Failed to read AgentCore response: {}", e))?;
-
-        if !status.is_success() {
-            return Err(format!(
-                "AgentCore API error ({}): {}",
-                status.as_u16(),
-                resp_body
-            ));
-        }
-
-        let json: Value = serde_json::from_str(&resp_body)
-            .map_err(|e| format!("Invalid AgentCore response: {}", e))?;
-
-        let session_id = json
-            .get("sessionId")
-            .and_then(|v| v.as_str())
-            .ok_or_else(|| "AgentCore response missing sessionId".to_string())?
-            .to_string();
-
-        let browser_identifier = json
-            .get("browserIdentifier")
-            .and_then(|v| v.as_str())
-            .unwrap_or(&browser_id)
-            .to_string();
-
-        let live_view_url = format!(
-            "https://{}.console.aws.amazon.com/bedrock-agentcore/browser/{}/session/{}#",
-            region, browser_identifier, session_id
-        );
-
-        set_agentcore_info(AgentCoreSessionInfo {
-            session_id: session_id.clone(),
-            browser_identifier: browser_identifier.clone(),
-            region: region.clone(),
-            live_view_url: live_view_url.clone(),
-        });
-
-        eprintln!("Session: {}", session_id);
-        eprintln!("Live View: {}", live_view_url);
-
-        let ws_path = format!(
-            "/browser-streams/{}/sessions/{}/automation",
-            browser_identifier, session_id
-        );
-        let ws_url = format!("wss://{}{}", host, ws_path);
-
-        let ws_headers = sign_request(
-            "GET",
-            &format!("https://{}{}", host, ws_path),
-            &region,
-            None,
-        )
-        .await?;
-        set_agentcore_ws_headers(ws_headers);
-
-        Ok((
-            ws_url,
-            Some(ProviderSession {
-                provider: "agentcore".to_string(),
-                session_id,
-            }),
-        ))
-    }
-
-    /// Get AWS credentials from environment variables or AWS CLI
-    fn get_aws_credentials() -> Result<(String, String, Option<String>), String> {
-        // First try environment variables
-        if let (Ok(access_key), Ok(secret_key)) = (
-            env::var("AWS_ACCESS_KEY_ID"),
-            env::var("AWS_SECRET_ACCESS_KEY"),
-        ) {
-            return Ok((access_key, secret_key, env::var("AWS_SESSION_TOKEN").ok()));
-        }
-
-        // Fall back to AWS CLI
-        let mut cmd = std::process::Command::new("aws");
-        cmd.args(["configure", "export-credentials", "--format", "env"]);
-
-        // Honor AWS_PROFILE
-        if let Ok(profile) = env::var("AWS_PROFILE") {
-            cmd.args(["--profile", &profile]);
-        }
-
-        let output = cmd.output()
-            .map_err(|e| format!("Failed to run aws CLI: {}. Install AWS CLI or set AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY", e))?;
-
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            return Err(format!(
-                "AWS CLI failed: {}. Run 'aws sso login' or set credentials",
-                stderr.trim()
-            ));
-        }
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let mut access_key = None;
-        let mut secret_key = None;
-        let mut session_token = None;
-
-        for line in stdout.lines() {
-            if let Some(val) = line.strip_prefix("export AWS_ACCESS_KEY_ID=") {
-                access_key = Some(val.to_string());
-            } else if let Some(val) = line.strip_prefix("export AWS_SECRET_ACCESS_KEY=") {
-                secret_key = Some(val.to_string());
-            } else if let Some(val) = line.strip_prefix("export AWS_SESSION_TOKEN=") {
-                session_token = Some(val.to_string());
-            }
-        }
-
-        match (access_key, secret_key) {
-            (Some(ak), Some(sk)) => Ok((ak, sk, session_token)),
-            _ => Err("Failed to parse credentials from AWS CLI output".to_string()),
-        }
-    }
-
-    async fn sign_request(
-        method: &str,
-        url: &str,
-        region: &str,
-        body: Option<&str>,
-    ) -> Result<Vec<(String, String)>, String> {
-        use hmac::{Hmac, Mac};
-        use sha2::{Digest, Sha256};
-
-        // Get credentials from environment or AWS CLI
-        let (access_key, secret_key, session_token) = get_aws_credentials()?;
-
-        let parsed_url = url::Url::parse(url).map_err(|e| format!("Invalid URL: {}", e))?;
-        let host = parsed_url.host_str().unwrap_or("");
-
-        // Get current time
-        let now = chrono::Utc::now();
-        let amz_date = now.format("%Y%m%dT%H%M%SZ").to_string();
-        let date_stamp = now.format("%Y%m%d").to_string();
-
-        // Create canonical request
-        let payload_hash = if let Some(b) = body {
-            let mut hasher = Sha256::new();
-            hasher.update(b.as_bytes());
-            hex::encode(hasher.finalize())
-        } else {
-            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855".to_string()
-            // empty string hash
-        };
-
-        let canonical_uri = parsed_url.path();
-        let canonical_querystring = parsed_url.query().unwrap_or("");
-
-        let mut signed_headers = "content-type;host;x-amz-date".to_string();
-        let mut canonical_headers = format!(
-            "content-type:application/json\nhost:{}\nx-amz-date:{}\n",
-            host, amz_date
-        );
-
-        if let Some(ref token) = session_token {
-            signed_headers = "content-type;host;x-amz-date;x-amz-security-token".to_string();
-            canonical_headers = format!(
-                "content-type:application/json\nhost:{}\nx-amz-date:{}\nx-amz-security-token:{}\n",
-                host, amz_date, token
-            );
-        }
-
-        let canonical_request = format!(
-            "{}\n{}\n{}\n{}\n{}\n{}",
-            method,
-            canonical_uri,
-            canonical_querystring,
-            canonical_headers,
-            signed_headers,
-            payload_hash
-        );
-
-        // Create string to sign
-        let algorithm = "AWS4-HMAC-SHA256";
-        let credential_scope = format!("{}/{}/bedrock-agentcore/aws4_request", date_stamp, region);
-
-        let mut hasher = Sha256::new();
-        hasher.update(canonical_request.as_bytes());
-        let canonical_request_hash = hex::encode(hasher.finalize());
-
-        let string_to_sign = format!(
-            "{}\n{}\n{}\n{}",
-            algorithm, amz_date, credential_scope, canonical_request_hash
-        );
-
-        // Calculate signature
-        type HmacSha256 = Hmac<Sha256>;
-
-        let k_date = HmacSha256::new_from_slice(format!("AWS4{}", secret_key).as_bytes())
-            .unwrap()
-            .chain_update(date_stamp.as_bytes())
-            .finalize()
-            .into_bytes();
-
-        let k_region = HmacSha256::new_from_slice(&k_date)
-            .unwrap()
-            .chain_update(region.as_bytes())
-            .finalize()
-            .into_bytes();
-
-        let k_service = HmacSha256::new_from_slice(&k_region)
-            .unwrap()
-            .chain_update(b"bedrock-agentcore")
-            .finalize()
-            .into_bytes();
-
-        let k_signing = HmacSha256::new_from_slice(&k_service)
-            .unwrap()
-            .chain_update(b"aws4_request")
-            .finalize()
-            .into_bytes();
-
-        let signature = hex::encode(
-            HmacSha256::new_from_slice(&k_signing)
-                .unwrap()
-                .chain_update(string_to_sign.as_bytes())
-                .finalize()
-                .into_bytes(),
-        );
-
-        // Build authorization header
-        let authorization = format!(
-            "{} Credential={}/{}, SignedHeaders={}, Signature={}",
-            algorithm, access_key, credential_scope, signed_headers, signature
-        );
-
-        let mut headers = vec![
-            ("host".to_string(), host.to_string()),
-            ("content-type".to_string(), "application/json".to_string()),
-            ("x-amz-date".to_string(), amz_date),
-            ("authorization".to_string(), authorization),
-        ];
-
-        if let Some(token) = session_token {
-            headers.push(("x-amz-security-token".to_string(), token));
-        }
-
-        Ok(headers)
-    }
-
-    pub async fn close_session(session_id: &str) -> Result<(), String> {
-        let info = get_agentcore_info();
-        let (region, browser_id) = match &info {
-            Some(i) => (i.region.clone(), i.browser_identifier.clone()),
-            None => {
-                let region = env::var("AGENTCORE_REGION")
-                    .or_else(|_| env::var("AWS_REGION"))
-                    .or_else(|_| env::var("AWS_DEFAULT_REGION"))
-                    .unwrap_or_else(|_| "us-east-1".to_string());
-                let browser_id = env::var("AGENTCORE_BROWSER_ID")
-                    .unwrap_or_else(|_| "aws.browser.v1".to_string());
-                (region, browser_id)
-            }
-        };
-
-        let host = format!("bedrock-agentcore.{}.amazonaws.com", region);
-        let path = format!(
-            "/browsers/{}/sessions/stop",
-            urlencoding::encode(&browser_id)
-        );
-        let url = format!("https://{}{}", host, path);
-
-        let body = serde_json::to_string(&json!({ "sessionId": session_id }))
-            .map_err(|e| format!("Failed to serialize close request: {}", e))?;
-
-        let signed_headers = sign_request("PUT", &url, &region, Some(&body)).await?;
-
-        let client = reqwest::Client::new();
-        let mut req = client.put(&url).body(body);
-        for (key, value) in &signed_headers {
-            req = req.header(key.as_str(), value.as_str());
-        }
-
-        let _ = req.send().await;
-        Ok(())
-    }
-}
-
-pub use agentcore::{get_agentcore_info, take_agentcore_ws_headers};
-
-async fn connect_agentcore() -> Result<(String, Option<ProviderSession>), String> {
-    agentcore::connect().await
-}
-
-async fn close_agentcore_session(session_id: &str) -> Result<(), String> {
-    agentcore::close_session(session_id).await
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_connect_provider_unknown() {
-        let rt = tokio::runtime::Runtime::new().unwrap();
-        let result = rt.block_on(connect_provider("unknown-provider"));
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("Unknown provider"));
-    }
-
-    #[test]
-    fn test_agentcore_env_defaults() {
-        // Test that default values are used when env vars not set
-        std::env::remove_var("AGENTCORE_REGION");
-        std::env::remove_var("AGENTCORE_BROWSER_ID");
-        std::env::remove_var("AGENTCORE_SESSION_TIMEOUT");
-
-        // These would be used in connect() - just verify they don't panic
-        let region = std::env::var("AGENTCORE_REGION")
-            .or_else(|_| std::env::var("AWS_REGION"))
-            .unwrap_or_else(|_| "us-east-1".to_string());
-        assert_eq!(region, "us-east-1");
-
-        let browser_id =
-            std::env::var("AGENTCORE_BROWSER_ID").unwrap_or_else(|_| "aws.browser.v1".to_string());
-        assert_eq!(browser_id, "aws.browser.v1");
-    }
-
-    #[test]
-    fn test_agentcore_session_info_storage() {
-        let info = agentcore::AgentCoreSessionInfo {
-            session_id: "test-session".to_string(),
-            browser_identifier: "aws.browser.v1".to_string(),
-            region: "us-east-1".to_string(),
-            live_view_url: "https://example.com".to_string(),
-        };
-
-        agentcore::set_agentcore_info(info);
-        let retrieved = get_agentcore_info();
-        assert!(retrieved.is_some());
-        let retrieved = retrieved.unwrap();
-        assert_eq!(retrieved.session_id, "test-session");
-        assert_eq!(retrieved.region, "us-east-1");
-    }
-
-    #[test]
-    fn test_agentcore_ws_headers_storage() {
-        let headers = vec![
-            (
-                "Authorization".to_string(),
-                "AWS4-HMAC-SHA256...".to_string(),
-            ),
-            ("X-Amz-Date".to_string(), "20260304T180000Z".to_string()),
-        ];
-
-        agentcore::set_agentcore_ws_headers(headers);
-        let taken = take_agentcore_ws_headers();
-        assert!(taken.is_some());
-        assert_eq!(taken.unwrap().len(), 2);
-
-        // Should be None after take
-        let taken_again = take_agentcore_ws_headers();
-        assert!(taken_again.is_none());
-    }
-}

cli/src/native/recording.rs

@@ -1,24 +1,12 @@
 use serde_json::{json, Value};
-use std::process::Stdio;
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::io::AsyncWriteExt;
-use tokio::sync::oneshot;
-
-use super::cdp::client::CdpClient;
-use super::cdp::types::{CaptureScreenshotParams, CaptureScreenshotResult};
-
-const CAPTURE_INTERVAL_MS: u64 = 100;
-const CAPTURE_FPS: u32 = 10;
+use std::path::PathBuf;
+use std::process::Command;
 
 pub struct RecordingState {
     pub active: bool,
     pub output_path: String,
+    pub temp_dir: PathBuf,
     pub frame_count: u64,
-    pub capture_task: Option<tokio::task::JoinHandle<Result<(), String>>>,
-    pub shared_frame_count: Option<Arc<AtomicU64>>,
-    pub cancel_tx: Option<oneshot::Sender<()>>,
 }
 
 impl RecordingState {
@@ -26,10 +14,8 @@ impl RecordingState {
         Self {
             active: false,
             output_path: String::new(),
+            temp_dir: PathBuf::new(),
             frame_count: 0,
-            capture_task: None,
-            shared_frame_count: None,
-            cancel_tx: None,
         }
     }
 }
@@ -39,13 +25,34 @@ pub fn recording_start(state: &mut RecordingState, path: &str) -> Result<Value,
         return Err("Recording already active".to_string());
     }
 
+    let timestamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis();
+
+    let temp_dir = std::env::temp_dir().join(format!("agent-browser-recording-{}", timestamp));
+    let _ = std::fs::create_dir_all(&temp_dir);
+
     state.active = true;
     state.output_path = path.to_string();
+    state.temp_dir = temp_dir;
     state.frame_count = 0;
 
     Ok(json!({ "started": true, "path": path }))
 }
 
+pub fn recording_add_frame(state: &mut RecordingState, frame_data: &[u8]) {
+    if !state.active {
+        return;
+    }
+
+    let frame_path = state
+        .temp_dir
+        .join(format!("frame_{:06}.jpg", state.frame_count));
+    let _ = std::fs::write(&frame_path, frame_data);
+    state.frame_count += 1;
+}
+
 pub fn recording_stop(state: &mut RecordingState) -> Result<Value, String> {
     if !state.active {
         return Err("No recording in progress".to_string());
@@ -54,183 +61,55 @@ pub fn recording_stop(state: &mut RecordingState) -> Result<Value, String> {
     state.active = false;
 
     if state.frame_count == 0 {
+        let _ = std::fs::remove_dir_all(&state.temp_dir);
         return Err("No frames captured".to_string());
     }
 
-    Ok(json!({ "path": &state.output_path, "frames": state.frame_count }))
-}
+    let frame_pattern = state
+        .temp_dir
+        .join("frame_%06d.jpg")
+        .to_string_lossy()
+        .to_string();
 
-pub fn recording_restart(state: &mut RecordingState, path: &str) -> Result<Value, String> {
-    let previous = if state.active {
-        let stop_result = recording_stop(state);
-        stop_result
-            .ok()
-            .and_then(|v| v.get("path").and_then(|p| p.as_str()).map(String::from))
-    } else {
-        None
-    };
+    let output = &state.output_path;
 
-    recording_start(state, path)?;
-
-    Ok(json!({
-        "restarted": true,
-        "previousPath": previous,
-        "path": path,
-    }))
-}
-
-fn build_ffmpeg_command(output_path: &str) -> tokio::process::Command {
-    let mut cmd = tokio::process::Command::new("ffmpeg");
-
-    cmd.args(["-y"])
-        .args(["-avioflags", "direct"])
+    // Encode with ffmpeg
+    let result = Command::new("ffmpeg")
         .args([
-            "-fpsprobesize",
-            "0",
-            "-probesize",
-            "32",
-            "-analyzeduration",
-            "0",
-        ])
-        .args([
-            "-f",
-            "image2pipe",
-            "-c:v",
-            "mjpeg",
+            "-y",
             "-framerate",
-            &CAPTURE_FPS.to_string(),
+            "30",
             "-i",
-            "pipe:0",
+            &frame_pattern,
+            "-c:v",
+            "libx264",
+            "-pix_fmt",
+            "yuv420p",
+            "-preset",
+            "fast",
+            output,
         ])
-        .args(["-vf", "pad=ceil(iw/2)*2:ceil(ih/2)*2"]);
+        .output();
 
-    if output_path.ends_with(".webm") {
-        cmd.args(["-c:v", "libvpx", "-crf", "30", "-b:v", "1M"]);
-    } else {
-        cmd.args(["-c:v", "libx264", "-preset", "ultrafast"]);
-    }
+    let _ = std::fs::remove_dir_all(&state.temp_dir);
 
-    cmd.args(["-pix_fmt", "yuv420p", "-threads", "1"])
-        .arg(output_path)
-        .stdin(Stdio::piped())
-        .stdout(Stdio::null())
-        .stderr(Stdio::piped())
-        .kill_on_drop(true);
-
-    cmd
-}
-
-/// Spawn a background task that captures screenshots at a fixed interval
-/// and pipes them to ffmpeg in real-time.
-pub fn spawn_recording_task(
-    client: Arc<CdpClient>,
-    session_id: String,
-    output_path: String,
-    shared_count: Arc<AtomicU64>,
-    cancel_rx: oneshot::Receiver<()>,
-) -> tokio::task::JoinHandle<Result<(), String>> {
-    tokio::spawn(async move {
-        let mut cancel_rx = std::pin::pin!(cancel_rx);
-
-        let mut ffmpeg = build_ffmpeg_command(&output_path).spawn().map_err(|e| {
-            format!(
-                "ffmpeg not found or failed to execute: {}. Install ffmpeg to enable recording.",
-                e
-            )
-        })?;
-
-        let mut stdin = ffmpeg
-            .stdin
-            .take()
-            .ok_or_else(|| "Failed to open ffmpeg stdin".to_string())?;
-
-        let mut interval = tokio::time::interval(Duration::from_millis(CAPTURE_INTERVAL_MS));
-        interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
-
-        let params = CaptureScreenshotParams {
-            format: Some("jpeg".to_string()),
-            quality: Some(80),
-            clip: None,
-            from_surface: Some(true),
-            capture_beyond_viewport: None,
-        };
-
-        loop {
-            tokio::select! {
-                _ = &mut cancel_rx => break,
-                _ = interval.tick() => {}
+    match result {
+        Ok(output_result) => {
+            if output_result.status.success() {
+                Ok(json!({ "path": output, "frames": state.frame_count }))
+            } else {
+                let stderr = String::from_utf8_lossy(&output_result.stderr);
+                Err(format!(
+                    "ffmpeg failed: {}",
+                    stderr.chars().take(200).collect::<String>()
+                ))
             }
-
-            let result: Result<CaptureScreenshotResult, _> = client
-                .send_command_typed("Page.captureScreenshot", &params, Some(&session_id))
-                .await;
-
-            let screenshot = match result {
-                Ok(s) => s,
-                Err(e) => {
-                    if e.contains("Target closed") || e.contains("not found") {
-                        break;
-                    }
-                    continue;
-                }
-            };
-
-            let bytes = match base64::Engine::decode(
-                &base64::engine::general_purpose::STANDARD,
-                &screenshot.data,
-            ) {
-                Ok(b) => b,
-                Err(_) => continue,
-            };
-
-            if stdin.write_all(&bytes).await.is_err() {
-                break;
-            }
-            shared_count.fetch_add(1, Ordering::Relaxed);
         }
-
-        drop(stdin);
-
-        let output = ffmpeg
-            .wait_with_output()
-            .await
-            .map_err(|e| format!("ffmpeg wait failed: {}", e))?;
-
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            return Err(format!(
-                "ffmpeg failed: {}",
-                stderr.chars().take(300).collect::<String>()
-            ));
-        }
-
-        Ok(())
-    })
-}
-
-pub async fn stop_recording_task(state: &mut RecordingState) -> Result<(), String> {
-    if let Some(tx) = state.cancel_tx.take() {
-        let _ = tx.send(());
+        Err(e) => Err(format!(
+            "ffmpeg not found or failed to execute: {}. Install ffmpeg to enable recording.",
+            e
+        )),
     }
-
-    let counter = state.shared_frame_count.take();
-    let handle = state.capture_task.take();
-
-    let result = if let Some(h) = handle {
-        match h.await {
-            Ok(Ok(())) => Ok(()),
-            Ok(Err(e)) => Err(e),
-            Err(e) => Err(format!("Recording task panicked: {}", e)),
-        }
-    } else {
-        Ok(())
-    };
-
-    if let Some(c) = counter {
-        state.frame_count = c.load(Ordering::Relaxed);
-    }
-
-    result
 }
 
 #[cfg(test)]
@@ -253,15 +132,19 @@ mod tests {
         assert!(state.active);
         assert_eq!(state.output_path, "/tmp/test.mp4");
         assert_eq!(state.frame_count, 0);
+        // Cleanup
+        let _ = std::fs::remove_dir_all(&state.temp_dir);
     }
 
     #[test]
     fn test_recording_start_while_active() {
         let mut state = RecordingState::new();
         recording_start(&mut state, "/tmp/test1.mp4").unwrap();
+        let temp_dir = state.temp_dir.clone();
         let result = recording_start(&mut state, "/tmp/test2.mp4");
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("already active"));
+        let _ = std::fs::remove_dir_all(&temp_dir);
     }
 
     #[test]
@@ -283,41 +166,38 @@ mod tests {
     }
 
     #[test]
-    fn test_recording_restart_while_inactive() {
+    fn test_recording_add_frame_inactive() {
         let mut state = RecordingState::new();
-        let result = recording_restart(&mut state, "/tmp/new.webm");
-        assert!(result.is_ok());
-        assert!(state.active);
-        assert_eq!(state.output_path, "/tmp/new.webm");
-    }
-
-    #[test]
-    fn test_recording_restart_while_active() {
-        let mut state = RecordingState::new();
-        recording_start(&mut state, "/tmp/old.webm").unwrap();
-        state.frame_count = 10;
-        let result = recording_restart(&mut state, "/tmp/new.webm").unwrap();
-        assert!(state.active);
-        assert_eq!(state.output_path, "/tmp/new.webm");
+        recording_add_frame(&mut state, b"fake-frame");
         assert_eq!(state.frame_count, 0);
-        assert_eq!(result["previousPath"], "/tmp/old.webm");
     }
 
     #[test]
-    fn test_build_ffmpeg_command_webm() {
-        let cmd = build_ffmpeg_command("/tmp/out.webm");
-        let args: Vec<&std::ffi::OsStr> = cmd.as_std().get_args().collect();
-        let args_str: Vec<&str> = args.iter().filter_map(|a| a.to_str()).collect();
-        assert!(args_str.contains(&"libvpx"));
-        assert!(args_str.contains(&"/tmp/out.webm"));
-    }
-
-    #[test]
-    fn test_build_ffmpeg_command_mp4() {
-        let cmd = build_ffmpeg_command("/tmp/out.mp4");
-        let args: Vec<&std::ffi::OsStr> = cmd.as_std().get_args().collect();
-        let args_str: Vec<&str> = args.iter().filter_map(|a| a.to_str()).collect();
-        assert!(args_str.contains(&"libx264"));
-        assert!(args_str.contains(&"/tmp/out.mp4"));
+    fn test_recording_add_frame_active() {
+        let mut state = RecordingState::new();
+        recording_start(&mut state, "/tmp/test.mp4").unwrap();
+        recording_add_frame(&mut state, b"fake-frame-1");
+        recording_add_frame(&mut state, b"fake-frame-2");
+        assert_eq!(state.frame_count, 2);
+        let _ = std::fs::remove_dir_all(&state.temp_dir);
     }
 }
+
+pub fn recording_restart(state: &mut RecordingState, path: &str) -> Result<Value, String> {
+    let previous = if state.active {
+        let stop_result = recording_stop(state);
+        stop_result
+            .ok()
+            .and_then(|v| v.get("path").and_then(|p| p.as_str()).map(String::from))
+    } else {
+        None
+    };
+
+    recording_start(state, path)?;
+
+    Ok(json!({
+        "restarted": true,
+        "previousPath": previous,
+        "path": path,
+    }))
+}

cli/src/native/screenshot.rs

@@ -1,65 +1,16 @@
-use serde::Serialize;
 use serde_json::Value;
 use std::path::PathBuf;
 
-use std::collections::HashMap;
-
 use super::cdp::client::CdpClient;
 use super::cdp::types::*;
 use super::element::RefMap;
 
-const ANNOTATION_OVERLAY_ID: &str = "__agent_browser_annotations__";
-
-#[derive(Debug, Clone)]
-struct Rect {
-    x: f64,
-    y: f64,
-    width: f64,
-    height: f64,
-}
-
-#[derive(Debug, Clone)]
-struct RawAnnotation {
-    ref_id: String,
-    number: u64,
-    role: String,
-    name: Option<String>,
-    rect: Rect,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct AnnotationBox {
-    pub x: i64,
-    pub y: i64,
-    pub width: i64,
-    pub height: i64,
-}
-
-#[derive(Debug, Clone)]
-pub struct ScreenshotAnnotation {
-    pub ref_id: String,
-    pub number: u64,
-    pub role: String,
-    pub name: Option<String>,
-    pub box_: AnnotationBox,
-}
-
-#[derive(Debug, Clone)]
-pub struct ScreenshotResult {
-    pub path: String,
-    pub base64: String,
-    pub annotations: Vec<ScreenshotAnnotation>,
-}
-
-#[derive(Debug, Clone)]
 pub struct ScreenshotOptions {
     pub selector: Option<String>,
     pub path: Option<String>,
     pub full_page: bool,
     pub format: String,
     pub quality: Option<i32>,
-    pub annotate: bool,
-    pub output_dir: Option<String>,
 }
 
 impl Default for ScreenshotOptions {
@@ -70,111 +21,16 @@ impl Default for ScreenshotOptions {
             full_page: false,
             format: "png".to_string(),
             quality: None,
-            annotate: false,
-            output_dir: None,
         }
     }
 }
 
-impl Serialize for ScreenshotAnnotation {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-
-        let mut state = serializer.serialize_struct("ScreenshotAnnotation", 5)?;
-        state.serialize_field("ref", &self.ref_id)?;
-        state.serialize_field("number", &self.number)?;
-        state.serialize_field("role", &self.role)?;
-        if let Some(name) = &self.name {
-            state.serialize_field("name", name)?;
-        }
-        state.serialize_field("box", &self.box_)?;
-        state.end()
-    }
-}
-
-/// Captures a screenshot via CDP and optionally overlays numbered annotations
-/// that mirror the Node.js screenshot `annotate` mode.
 pub async fn take_screenshot(
     client: &CdpClient,
     session_id: &str,
     ref_map: &RefMap,
     options: &ScreenshotOptions,
-    iframe_sessions: &HashMap<String, String>,
-) -> Result<ScreenshotResult, String> {
-    let target_rect = if options.annotate {
-        match options.selector.as_deref() {
-            Some(selector) => {
-                get_rect_for_selector(client, session_id, ref_map, selector, iframe_sessions)
-                    .await?
-            }
-            None => None,
-        }
-    } else {
-        None
-    };
-
-    let raw_annotations = if options.annotate {
-        collect_annotations(client, session_id, ref_map).await?
-    } else {
-        Vec::new()
-    };
-
-    let overlay_items = filter_annotations(raw_annotations, target_rect.as_ref());
-    let overlay_injected = if options.annotate && !overlay_items.is_empty() {
-        inject_annotation_overlay(client, session_id, &overlay_items).await?;
-        true
-    } else {
-        false
-    };
-
-    let base64 =
-        capture_screenshot_base64(client, session_id, ref_map, options, iframe_sessions).await;
-
-    if overlay_injected {
-        let _ = remove_annotation_overlay(client, session_id).await;
-    }
-
-    let base64 = base64?;
-    let annotations = if options.annotate {
-        let scroll = if options.full_page {
-            Some(get_scroll_offsets(client, session_id).await?)
-        } else {
-            None
-        };
-        project_annotations(&overlay_items, target_rect.as_ref(), scroll)
-    } else {
-        Vec::new()
-    };
-
-    let ext = if options.format == "jpeg" {
-        "jpg"
-    } else {
-        "png"
-    };
-    let path = save_screenshot(
-        &base64,
-        options.path.as_deref(),
-        ext,
-        options.output_dir.as_deref(),
-    )?;
-
-    Ok(ScreenshotResult {
-        path,
-        base64,
-        annotations,
-    })
-}
-
-async fn capture_screenshot_base64(
-    client: &CdpClient,
-    session_id: &str,
-    ref_map: &RefMap,
-    options: &ScreenshotOptions,
-    iframe_sessions: &HashMap<String, String>,
-) -> Result<String, String> {
+) -> Result<(String, String), String> {
     let mut params = CaptureScreenshotParams {
         format: Some(options.format.clone()),
         quality: if options.format == "jpeg" {
@@ -208,14 +64,40 @@ async fn capture_screenshot_base64(
             });
         }
     } else if let Some(ref selector) = options.selector {
-        if let Some(rect) =
-            get_rect_for_selector(client, session_id, ref_map, selector, iframe_sessions).await?
-        {
+        // Element screenshot via bounding box
+        let object_id =
+            super::element::resolve_element_object_id(client, session_id, ref_map, selector)
+                .await?;
+
+        let result: EvaluateResult = client
+            .send_command_typed(
+                "Runtime.callFunctionOn",
+                &CallFunctionOnParams {
+                    function_declaration: r#"function() {
+                        const rect = this.getBoundingClientRect();
+                        return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+                    }"#
+                    .to_string(),
+                    object_id: Some(object_id),
+                    arguments: None,
+                    return_by_value: Some(true),
+                    await_promise: Some(false),
+                },
+                Some(session_id),
+            )
+            .await?;
+
+        if let Some(rect) = result.result.value {
+            let x = rect.get("x").and_then(|v| v.as_f64()).unwrap_or(0.0);
+            let y = rect.get("y").and_then(|v| v.as_f64()).unwrap_or(0.0);
+            let w = rect.get("width").and_then(|v| v.as_f64()).unwrap_or(100.0);
+            let h = rect.get("height").and_then(|v| v.as_f64()).unwrap_or(100.0);
+
             params.clip = Some(Viewport {
-                x: rect.x,
-                y: rect.y,
-                width: rect.width,
-                height: rect.height,
+                x,
+                y,
+                width: w,
+                height: h,
                 scale: 1.0,
             });
         }
@@ -225,345 +107,16 @@ async fn capture_screenshot_base64(
         .send_command_typed("Page.captureScreenshot", &params, Some(session_id))
         .await?;
 
-    Ok(result.data)
-}
+    let ext = if options.format == "jpeg" {
+        "jpg"
+    } else {
+        "png"
+    };
 
-async fn collect_annotations(
-    client: &CdpClient,
-    session_id: &str,
-    ref_map: &RefMap,
-) -> Result<Vec<RawAnnotation>, String> {
-    let entries = ref_map.entries_sorted();
-    if entries.is_empty() {
-        return Ok(Vec::new());
-    }
-
-    // Collect entries that have backend_node_ids for batch resolution.
-    let with_backend_ids: Vec<(String, super::element::RefEntry, i64)> = entries
-        .iter()
-        .filter_map(|(ref_id, entry)| {
-            entry
-                .backend_node_id
-                .map(|bid| (ref_id.clone(), entry.clone(), bid))
-        })
-        .collect();
-
-    if with_backend_ids.is_empty() {
-        return Ok(Vec::new());
-    }
-
-    // Batch-resolve all backend_node_ids to object IDs using concurrent CDP calls.
-    let resolve_futures: Vec<_> = with_backend_ids
-        .iter()
-        .map(|(_, _, backend_node_id)| {
-            client.send_command(
-                "DOM.resolveNode",
-                Some(serde_json::json!({
-                    "backendNodeId": backend_node_id,
-                    "objectGroup": "agent-browser-annotate"
-                })),
-                Some(session_id),
-            )
-        })
-        .collect();
-
-    let resolve_results = futures_util::future::join_all(resolve_futures).await;
-
-    // Collect resolved object IDs paired with their ref info.
-    let mut resolved: Vec<(String, super::element::RefEntry, String)> = Vec::new();
-    for (i, result) in resolve_results.into_iter().enumerate() {
-        if let Ok(val) = result {
-            if let Some(oid) = val
-                .get("object")
-                .and_then(|o| o.get("objectId"))
-                .and_then(|v| v.as_str())
-            {
-                let (ref_id, entry, _) = &with_backend_ids[i];
-                resolved.push((ref_id.clone(), entry.clone(), oid.to_string()));
-            }
-        }
-    }
-
-    if resolved.is_empty() {
-        return Ok(Vec::new());
-    }
-
-    // Batch-get bounding rects for all resolved elements using concurrent CDP calls.
-    let rect_futures: Vec<_> = resolved
-        .iter()
-        .map(|(_, _, object_id)| get_rect_for_object(client, session_id, object_id))
-        .collect();
-
-    let rect_results = futures_util::future::join_all(rect_futures).await;
-
-    let mut annotations = Vec::new();
-    for (i, rect_result) in rect_results.into_iter().enumerate() {
-        let rect = match rect_result {
-            Ok(Some(r)) if r.width > 0.0 && r.height > 0.0 => r,
-            _ => continue,
-        };
-
-        let (ref_id, entry, _) = &resolved[i];
-        let number = ref_id
-            .strip_prefix('e')
-            .and_then(|n| n.parse::<u64>().ok())
-            .unwrap_or(0);
-
-        annotations.push(RawAnnotation {
-            ref_id: ref_id.clone(),
-            number,
-            role: entry.role.clone(),
-            name: (!entry.name.is_empty()).then_some(entry.name.clone()),
-            rect,
-        });
-    }
-
-    Ok(annotations)
-}
-
-async fn get_rect_for_selector(
-    client: &CdpClient,
-    session_id: &str,
-    ref_map: &RefMap,
-    selector: &str,
-    iframe_sessions: &HashMap<String, String>,
-) -> Result<Option<Rect>, String> {
-    let (object_id, effective_session_id) = super::element::resolve_element_object_id(
-        client,
-        session_id,
-        ref_map,
-        selector,
-        iframe_sessions,
-    )
-    .await?;
-    get_rect_for_object(client, &effective_session_id, &object_id).await
-}
-
-async fn get_rect_for_object(
-    client: &CdpClient,
-    session_id: &str,
-    object_id: &str,
-) -> Result<Option<Rect>, String> {
-    let result: EvaluateResult = client
-        .send_command_typed(
-            "Runtime.callFunctionOn",
-            &CallFunctionOnParams {
-                function_declaration: r#"function() {
-                    const rect = this.getBoundingClientRect();
-                    return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
-                }"#
-                .to_string(),
-                object_id: Some(object_id.to_string()),
-                arguments: None,
-                return_by_value: Some(true),
-                await_promise: Some(false),
-            },
-            Some(session_id),
-        )
-        .await?;
-
-    Ok(result.result.value.as_ref().and_then(parse_rect))
-}
-
-fn parse_rect(value: &Value) -> Option<Rect> {
-    Some(Rect {
-        x: value.get("x")?.as_f64()?,
-        y: value.get("y")?.as_f64()?,
-        width: value.get("width")?.as_f64()?,
-        height: value.get("height")?.as_f64()?,
-    })
-}
-
-fn filter_annotations(
-    annotations: Vec<RawAnnotation>,
-    target_rect: Option<&Rect>,
-) -> Vec<RawAnnotation> {
-    let mut items = annotations
-        .into_iter()
-        .filter(|annotation| match target_rect {
-            Some(target) => overlaps(&annotation.rect, target),
-            None => true,
-        })
-        .collect::<Vec<_>>();
-
-    items.sort_by_key(|annotation| annotation.number);
-    items
-}
-
-fn overlaps(left: &Rect, right: &Rect) -> bool {
-    let left_x2 = left.x + left.width;
-    let left_y2 = left.y + left.height;
-    let right_x2 = right.x + right.width;
-    let right_y2 = right.y + right.height;
-
-    left.x < right_x2 && left_x2 > right.x && left.y < right_y2 && left_y2 > right.y
-}
-
-async fn inject_annotation_overlay(
-    client: &CdpClient,
-    session_id: &str,
-    annotations: &[RawAnnotation],
-) -> Result<(), String> {
-    let overlay_data = annotations
-        .iter()
-        .map(|annotation| {
-            serde_json::json!({
-                "number": annotation.number,
-                "x": round(annotation.rect.x),
-                "y": round(annotation.rect.y),
-                "width": round(annotation.rect.width),
-                "height": round(annotation.rect.height),
-            })
-        })
-        .collect::<Vec<_>>();
-
-    let expression = format!(
-        r#"(() => {{
-            var items = {items};
-            var id = {overlay_id};
-            var existing = document.getElementById(id);
-            if (existing) existing.remove();
-            var sx = window.scrollX || 0;
-            var sy = window.scrollY || 0;
-            var c = document.createElement('div');
-            c.id = id;
-            c.style.cssText = 'position:absolute;top:0;left:0;width:0;height:0;pointer-events:none;z-index:2147483647;';
-            for (var i = 0; i < items.length; i++) {{
-                var it = items[i];
-                var dx = it.x + sx;
-                var dy = it.y + sy;
-                var b = document.createElement('div');
-                b.style.cssText = 'position:absolute;left:' + dx + 'px;top:' + dy + 'px;width:' + it.width + 'px;height:' + it.height + 'px;border:2px solid rgba(255,0,0,0.8);box-sizing:border-box;pointer-events:none;';
-                var l = document.createElement('div');
-                l.textContent = String(it.number);
-                var labelTop = dy < 14 ? '2px' : '-14px';
-                l.style.cssText = 'position:absolute;top:' + labelTop + ';left:-2px;background:rgba(255,0,0,0.9);color:#fff;font:bold 11px/14px monospace;padding:0 4px;border-radius:2px;white-space:nowrap;';
-                b.appendChild(l);
-                c.appendChild(b);
-            }}
-            document.documentElement.appendChild(c);
-            return true;
-        }})()"#,
-        items = serde_json::to_string(&overlay_data).unwrap_or_else(|_| "[]".to_string()),
-        overlay_id =
-            serde_json::to_string(ANNOTATION_OVERLAY_ID).unwrap_or_else(|_| "\"\"".to_string()),
-    );
-
-    let _: EvaluateResult = client
-        .send_command_typed(
-            "Runtime.evaluate",
-            &EvaluateParams {
-                expression,
-                return_by_value: Some(true),
-                await_promise: Some(false),
-            },
-            Some(session_id),
-        )
-        .await?;
-
-    Ok(())
-}
-
-async fn remove_annotation_overlay(client: &CdpClient, session_id: &str) -> Result<(), String> {
-    let expression = format!(
-        r#"(() => {{
-            var el = document.getElementById({overlay_id});
-            if (el) el.remove();
-            return true;
-        }})()"#,
-        overlay_id =
-            serde_json::to_string(ANNOTATION_OVERLAY_ID).unwrap_or_else(|_| "\"\"".to_string()),
-    );
-
-    let _: EvaluateResult = client
-        .send_command_typed(
-            "Runtime.evaluate",
-            &EvaluateParams {
-                expression,
-                return_by_value: Some(true),
-                await_promise: Some(false),
-            },
-            Some(session_id),
-        )
-        .await?;
-
-    Ok(())
-}
-
-async fn get_scroll_offsets(client: &CdpClient, session_id: &str) -> Result<(f64, f64), String> {
-    let result: EvaluateResult = client
-        .send_command_typed(
-            "Runtime.evaluate",
-            &EvaluateParams {
-                expression: "({x: window.scrollX || 0, y: window.scrollY || 0})".to_string(),
-                return_by_value: Some(true),
-                await_promise: Some(false),
-            },
-            Some(session_id),
-        )
-        .await?;
-
-    let value = result.result.value.unwrap_or(Value::Null);
-    let x = value.get("x").and_then(|v| v.as_f64()).unwrap_or(0.0);
-    let y = value.get("y").and_then(|v| v.as_f64()).unwrap_or(0.0);
-    Ok((x, y))
-}
-
-fn project_annotations(
-    annotations: &[RawAnnotation],
-    target_rect: Option<&Rect>,
-    scroll: Option<(f64, f64)>,
-) -> Vec<ScreenshotAnnotation> {
-    annotations
-        .iter()
-        .map(|annotation| {
-            let rect = if let Some(target) = target_rect {
-                Rect {
-                    x: annotation.rect.x - target.x,
-                    y: annotation.rect.y - target.y,
-                    width: annotation.rect.width,
-                    height: annotation.rect.height,
-                }
-            } else if let Some((scroll_x, scroll_y)) = scroll {
-                Rect {
-                    x: annotation.rect.x + scroll_x,
-                    y: annotation.rect.y + scroll_y,
-                    width: annotation.rect.width,
-                    height: annotation.rect.height,
-                }
-            } else {
-                annotation.rect.clone()
-            };
-
-            ScreenshotAnnotation {
-                ref_id: annotation.ref_id.clone(),
-                number: annotation.number,
-                role: annotation.role.clone(),
-                name: annotation.name.clone(),
-                box_: AnnotationBox {
-                    x: round(rect.x),
-                    y: round(rect.y),
-                    width: round(rect.width),
-                    height: round(rect.height),
-                },
-            }
-        })
-        .collect()
-}
-
-fn save_screenshot(
-    base64_data: &str,
-    explicit_path: Option<&str>,
-    ext: &str,
-    output_dir: Option<&str>,
-) -> Result<String, String> {
-    let save_path = match explicit_path {
-        Some(path) => path.to_string(),
+    let save_path = match &options.path {
+        Some(p) => p.clone(),
         None => {
-            let dir = match output_dir {
-                Some(d) => PathBuf::from(d),
-                None => get_screenshot_dir(),
-            };
+            let dir = get_screenshot_dir();
             let _ = std::fs::create_dir_all(&dir);
             let timestamp = std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
@@ -574,17 +127,13 @@ fn save_screenshot(
         }
     };
 
-    let bytes = base64::Engine::decode(&base64::engine::general_purpose::STANDARD, base64_data)
+    let bytes = base64::Engine::decode(&base64::engine::general_purpose::STANDARD, &result.data)
         .map_err(|e| format!("Failed to decode screenshot: {}", e))?;
 
     std::fs::write(&save_path, &bytes)
         .map_err(|e| format!("Failed to save screenshot to {}: {}", save_path, e))?;
 
-    Ok(save_path)
-}
-
-fn round(value: f64) -> i64 {
-    value.round() as i64
+    Ok((save_path, result.data))
 }
 
 fn get_screenshot_dir() -> PathBuf {
@@ -596,96 +145,3 @@ fn get_screenshot_dir() -> PathBuf {
             .join("screenshots")
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn filters_annotations_to_target_overlap() {
-        let annotations = vec![
-            RawAnnotation {
-                ref_id: "e1".to_string(),
-                number: 1,
-                role: "button".to_string(),
-                name: Some("Inside".to_string()),
-                rect: Rect {
-                    x: 10.0,
-                    y: 10.0,
-                    width: 50.0,
-                    height: 20.0,
-                },
-            },
-            RawAnnotation {
-                ref_id: "e2".to_string(),
-                number: 2,
-                role: "button".to_string(),
-                name: Some("Outside".to_string()),
-                rect: Rect {
-                    x: 200.0,
-                    y: 200.0,
-                    width: 40.0,
-                    height: 20.0,
-                },
-            },
-        ];
-
-        let target = Rect {
-            x: 0.0,
-            y: 0.0,
-            width: 100.0,
-            height: 100.0,
-        };
-
-        let filtered = filter_annotations(annotations, Some(&target));
-        assert_eq!(filtered.len(), 1);
-        assert_eq!(filtered[0].ref_id, "e1");
-    }
-
-    #[test]
-    fn projects_selector_annotations_relative_to_target() {
-        let annotations = vec![RawAnnotation {
-            ref_id: "e1".to_string(),
-            number: 1,
-            role: "button".to_string(),
-            name: Some("Inside".to_string()),
-            rect: Rect {
-                x: 25.0,
-                y: 35.0,
-                width: 40.0,
-                height: 20.0,
-            },
-        }];
-
-        let target = Rect {
-            x: 10.0,
-            y: 15.0,
-            width: 100.0,
-            height: 100.0,
-        };
-
-        let projected = project_annotations(&annotations, Some(&target), None);
-        assert_eq!(projected[0].box_.x, 15);
-        assert_eq!(projected[0].box_.y, 20);
-    }
-
-    #[test]
-    fn projects_full_page_annotations_to_document_space() {
-        let annotations = vec![RawAnnotation {
-            ref_id: "e1".to_string(),
-            number: 1,
-            role: "button".to_string(),
-            name: Some("Bottom".to_string()),
-            rect: Rect {
-                x: 5.0,
-                y: 12.0,
-                width: 40.0,
-                height: 20.0,
-            },
-        }];
-
-        let projected = project_annotations(&annotations, None, Some((10.0, 1000.0)));
-        assert_eq!(projected[0].box_.x, 15);
-        assert_eq!(projected[0].box_.y, 1012);
-    }
-}

cli/src/native/state.rs

@@ -1,17 +1,12 @@
 use aes_gcm::{aead::Aead, aead::KeyInit, Aes256Gcm};
-use base64::Engine;
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use sha2::{Digest, Sha256};
-use std::collections::HashSet;
 use std::fs;
 use std::path::PathBuf;
 
 use super::cdp::client::CdpClient;
-use super::cdp::types::{
-    AttachToTargetParams, AttachToTargetResult, CloseTargetParams, CreateTargetParams,
-    CreateTargetResult, EvaluateParams,
-};
+use super::cdp::types::EvaluateParams;
 use super::cookies::{self, Cookie};
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -37,223 +32,16 @@ pub struct StorageEntry {
     pub value: String,
 }
 
-fn collect_frame_origins(tree: &Value, origins: &mut HashSet<String>) {
-    if let Some(frame) = tree.get("frame") {
-        if let Some(url_str) = frame.get("url").and_then(|v| v.as_str()) {
-            if let Ok(parsed) = url::Url::parse(url_str) {
-                let origin = parsed.origin().ascii_serialization();
-                if origin != "null" && !origin.is_empty() {
-                    origins.insert(origin);
-                }
-            }
-        }
-    }
-    if let Some(children) = tree.get("childFrames").and_then(|v| v.as_array()) {
-        for child in children {
-            collect_frame_origins(child, origins);
-        }
-    }
-}
-
-/// Parse the JS-evaluated origin storage data into an OriginStorage struct.
-fn parse_origin_storage(data: &Value) -> Option<OriginStorage> {
-    if !data.is_object() {
-        return None;
-    }
-    let origin = data
-        .get("origin")
-        .and_then(|v| v.as_str())
-        .unwrap_or("")
-        .to_string();
-    if origin.is_empty() || origin == "null" {
-        return None;
-    }
-    let local_storage: Vec<StorageEntry> = data
-        .get("localStorage")
-        .and_then(|v| serde_json::from_value(v.clone()).ok())
-        .unwrap_or_default();
-    let session_storage: Vec<StorageEntry> = data
-        .get("sessionStorage")
-        .and_then(|v| serde_json::from_value(v.clone()).ok())
-        .unwrap_or_default();
-
-    Some(OriginStorage {
-        origin,
-        local_storage,
-        session_storage,
-    })
-}
-
-/// Evaluate the storage-collection JS snippet and parse the result.
-async fn eval_origin_storage(
-    client: &CdpClient,
-    session_id: &str,
-    origin_js: &str,
-) -> Option<OriginStorage> {
-    let result = client
-        .send_command_typed::<_, super::cdp::types::EvaluateResult>(
-            "Runtime.evaluate",
-            &EvaluateParams {
-                expression: origin_js.to_string(),
-                return_by_value: Some(true),
-                await_promise: Some(false),
-            },
-            Some(session_id),
-        )
-        .await
-        .ok()?;
-    let data = result.result.value.unwrap_or(Value::Null);
-    parse_origin_storage(&data)
-}
-
-/// Create a temporary CDP target, navigate it to each origin to collect localStorage,
-/// then close it. Uses Fetch interception to serve blank HTML instead of making real
-/// network requests.
-async fn collect_storage_via_temp_target(
-    client: &CdpClient,
-    origins: &[String],
-    origin_js: &str,
-) -> Result<Vec<OriginStorage>, String> {
-    let create_result: CreateTargetResult = client
-        .send_command_typed(
-            "Target.createTarget",
-            &CreateTargetParams {
-                url: "about:blank".to_string(),
-            },
-            None,
-        )
-        .await?;
-
-    let target_id = create_result.target_id;
-
-    // Ensure the target is closed even if attach or later steps fail
-    let result = collect_storage_in_target(client, &target_id, origins, origin_js).await;
-
-    let _ = client
-        .send_command_typed::<_, Value>(
-            "Target.closeTarget",
-            &CloseTargetParams { target_id },
-            None,
-        )
-        .await;
-
-    result
-}
-
-async fn collect_storage_in_target(
-    client: &CdpClient,
-    target_id: &str,
-    origins: &[String],
-    origin_js: &str,
-) -> Result<Vec<OriginStorage>, String> {
-    let attach_result: AttachToTargetResult = client
-        .send_command_typed(
-            "Target.attachToTarget",
-            &AttachToTargetParams {
-                target_id: target_id.to_string(),
-                flatten: true,
-            },
-            None,
-        )
-        .await?;
-
-    let temp_session = &attach_result.session_id;
-
-    client
-        .send_command_no_params("Page.enable", Some(temp_session))
-        .await?;
-    client
-        .send_command_no_params("Runtime.enable", Some(temp_session))
-        .await?;
-
-    // Blank HTML response body, pre-encoded to avoid repeated base64 work per request
-    let blank_html_b64 = base64::engine::general_purpose::STANDARD.encode("<html></html>");
-
-    let _ = client
-        .send_command(
-            "Fetch.enable",
-            Some(json!({ "patterns": [{ "urlPattern": "*" }] })),
-            Some(temp_session),
-        )
-        .await;
-
-    let mut event_rx = client.subscribe();
-    let mut results = Vec::new();
-
-    for target_origin in origins {
-        let nav_url = format!("{}/", target_origin.trim_end_matches('/'));
-        if client
-            .send_command(
-                "Page.navigate",
-                Some(json!({ "url": nav_url })),
-                Some(temp_session),
-            )
-            .await
-            .is_err()
-        {
-            continue;
-        }
-
-        // Fulfill intercepted requests with blank HTML until the page loads
-        let deadline = tokio::time::Instant::now() + tokio::time::Duration::from_secs(5);
-        let mut page_loaded = false;
-        while tokio::time::Instant::now() < deadline {
-            match tokio::time::timeout(tokio::time::Duration::from_secs(2), event_rx.recv()).await {
-                Ok(Ok(evt)) if evt.session_id.as_deref() == Some(temp_session) => {
-                    if evt.method == "Fetch.requestPaused" {
-                        if let Some(request_id) =
-                            evt.params.get("requestId").and_then(|v| v.as_str())
-                        {
-                            let _ = client
-                                .send_command(
-                                    "Fetch.fulfillRequest",
-                                    Some(json!({
-                                        "requestId": request_id,
-                                        "responseCode": 200,
-                                        "responseHeaders": [
-                                            { "name": "Content-Type", "value": "text/html" }
-                                        ],
-                                        "body": &blank_html_b64
-                                    })),
-                                    Some(temp_session),
-                                )
-                                .await;
-                        }
-                    } else if evt.method == "Page.loadEventFired" {
-                        page_loaded = true;
-                        break;
-                    }
-                }
-                Ok(Ok(_)) => continue,  // event for a different session
-                Ok(Err(_)) => continue, // lagged or closed — retry within deadline
-                Err(_) => break,        // outer timeout elapsed
-            }
-        }
-
-        if !page_loaded {
-            continue;
-        }
-
-        if let Some(storage) = eval_origin_storage(client, temp_session, origin_js).await {
-            if !storage.local_storage.is_empty() || !storage.session_storage.is_empty() {
-                results.push(storage);
-            }
-        }
-    }
-
-    Ok(results)
-}
-
 pub async fn save_state(
     client: &CdpClient,
     session_id: &str,
     path: Option<&str>,
     session_name: Option<&str>,
     session_id_str: &str,
-    visited_origins: &HashSet<String>,
 ) -> Result<String, String> {
-    let cookies = cookies::get_all_cookies(client, session_id).await?;
+    let cookies = cookies::get_cookies(client, session_id, None).await?;
 
+    // Get current origin's storage
     let origin_js = r#"(() => {
         const result = { origin: location.origin, localStorage: [], sessionStorage: [] };
         try {
@@ -271,38 +59,46 @@ pub async fn save_state(
         return result;
     })()"#;
 
-    // Merge visited origins with current frame tree origins
-    let mut all_origins = visited_origins.clone();
-    if let Ok(tree_result) = client
-        .send_command_no_params("Page.getFrameTree", Some(session_id))
-        .await
-    {
-        if let Some(tree) = tree_result.get("frameTree") {
-            collect_frame_origins(tree, &mut all_origins);
-        }
-    }
+    let origin_result: super::cdp::types::EvaluateResult = client
+        .send_command_typed(
+            "Runtime.evaluate",
+            &EvaluateParams {
+                expression: origin_js.to_string(),
+                return_by_value: Some(true),
+                await_promise: Some(false),
+            },
+            Some(session_id),
+        )
+        .await?;
 
-    // 1. Collect localStorage from the current page
-    let mut origins = Vec::new();
-    let mut current_origin = String::new();
+    let origin_data = origin_result.result.value.unwrap_or(Value::Null);
+    let origins = if origin_data.is_object() {
+        let origin = origin_data
+            .get("origin")
+            .and_then(|v| v.as_str())
+            .unwrap_or("")
+            .to_string();
+        let local_storage: Vec<StorageEntry> = origin_data
+            .get("localStorage")
+            .and_then(|v| serde_json::from_value(v.clone()).ok())
+            .unwrap_or_default();
+        let session_storage: Vec<StorageEntry> = origin_data
+            .get("sessionStorage")
+            .and_then(|v| serde_json::from_value(v.clone()).ok())
+            .unwrap_or_default();
 
-    if let Some(storage) = eval_origin_storage(client, session_id, origin_js).await {
-        current_origin = storage.origin.clone();
-        if !storage.local_storage.is_empty() || !storage.session_storage.is_empty() {
-            origins.push(storage);
+        if !origin.is_empty() && origin != "null" {
+            vec![OriginStorage {
+                origin,
+                local_storage,
+                session_storage,
+            }]
+        } else {
+            vec![]
         }
-    }
-
-    // 2. Collect localStorage from remaining origins via a disposable temp target
-    all_origins.remove(&current_origin);
-    if !all_origins.is_empty() {
-        let remaining: Vec<String> = all_origins.into_iter().collect();
-        if let Ok(temp_origins) =
-            collect_storage_via_temp_target(client, &remaining, origin_js).await
-        {
-            origins.extend(temp_origins);
-        }
-    }
+    } else {
+        vec![]
+    };
 
     let state = StorageState { cookies, origins };
     let json_str = serde_json::to_string_pretty(&state)
@@ -671,7 +467,7 @@ pub fn find_auto_state_file(session_name: &str) -> Option<String> {
                 .ok()
                 .and_then(|m| m.modified().ok())
                 .unwrap_or(std::time::UNIX_EPOCH);
-            if best_path.as_ref().is_none_or(|(_, t)| modified > *t) {
+            if best_path.as_ref().map_or(true, |(_, t)| modified > *t) {
                 best_path = Some((path.to_string_lossy().to_string(), modified));
             }
         }
@@ -679,41 +475,6 @@ pub fn find_auto_state_file(session_name: &str) -> Option<String> {
     best_path.map(|(p, _)| p)
 }
 
-/// Dispatch a state management command from its JSON payload.
-/// Returns `Some(result)` for recognised state_* actions, `None` otherwise.
-pub fn dispatch_state_command(cmd: &Value) -> Option<Result<Value, String>> {
-    let action = cmd.get("action").and_then(|v| v.as_str())?;
-    match action {
-        "state_list" => Some(state_list()),
-        "state_show" => Some(
-            cmd.get("path")
-                .and_then(|v| v.as_str())
-                .ok_or_else(|| "Missing 'path' parameter".to_string())
-                .and_then(state_show),
-        ),
-        "state_clear" => {
-            let path = cmd.get("path").and_then(|v| v.as_str());
-            Some(state_clear(path))
-        }
-        "state_clean" => {
-            let days = cmd.get("days").and_then(|v| v.as_u64()).unwrap_or(30);
-            Some(state_clean(days))
-        }
-        "state_rename" => Some(
-            cmd.get("path")
-                .and_then(|v| v.as_str())
-                .ok_or_else(|| "Missing 'path' parameter".to_string())
-                .and_then(|path| {
-                    cmd.get("name")
-                        .and_then(|v| v.as_str())
-                        .ok_or_else(|| "Missing 'name' parameter".to_string())
-                        .and_then(|name| state_rename(path, name))
-                }),
-        ),
-        _ => None,
-    }
-}
-
 pub fn get_sessions_dir() -> PathBuf {
     if let Some(home) = dirs::home_dir() {
         home.join(".agent-browser").join("sessions")
@@ -843,45 +604,4 @@ mod tests {
         assert_eq!(json["secure"], true);
         assert_eq!(json["sameSite"], "Strict");
     }
-
-    #[test]
-    fn test_dispatch_state_command_routes_state_list() {
-        let cmd = serde_json::json!({ "action": "state_list" });
-        let result = dispatch_state_command(&cmd);
-        assert!(result.is_some());
-        assert!(result.unwrap().is_ok());
-    }
-
-    #[test]
-    fn test_dispatch_state_command_returns_none_for_unknown() {
-        let cmd = serde_json::json!({ "action": "navigate" });
-        assert!(dispatch_state_command(&cmd).is_none());
-    }
-
-    #[test]
-    fn test_dispatch_state_command_returns_none_for_missing_action() {
-        let cmd = serde_json::json!({});
-        assert!(dispatch_state_command(&cmd).is_none());
-    }
-
-    #[test]
-    fn test_dispatch_state_show_missing_path() {
-        let cmd = serde_json::json!({ "action": "state_show" });
-        let result = dispatch_state_command(&cmd).unwrap();
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), "Missing 'path' parameter");
-    }
-
-    #[test]
-    fn test_dispatch_state_rename_missing_params() {
-        let cmd = serde_json::json!({ "action": "state_rename" });
-        let result = dispatch_state_command(&cmd).unwrap();
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), "Missing 'path' parameter");
-
-        let cmd = serde_json::json!({ "action": "state_rename", "path": "/tmp/test.json" });
-        let result = dispatch_state_command(&cmd).unwrap();
-        assert!(result.is_err());
-        assert_eq!(result.unwrap_err(), "Missing 'name' parameter");
-    }
 }

cli/src/native/test_fixtures/drag_probe.html

@@ -1,135 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>Drag Probe</title>
-  <style>
-    body {
-      margin: 0;
-      font: 14px/1.4 sans-serif;
-      background: #f4f4f4;
-    }
-
-    #pad {
-      position: relative;
-      width: 800px;
-      height: 500px;
-      margin: 24px;
-      border: 1px solid #999;
-      background: white;
-      overflow: hidden;
-    }
-
-    #target {
-      position: absolute;
-      left: 320px;
-      top: 40px;
-      width: 100px;
-      height: 40px;
-      background: #e34c26;
-      color: white;
-      display: flex;
-      align-items: center;
-      justify-content: center;
-      user-select: none;
-      cursor: grab;
-    }
-
-    #target.dragging {
-      cursor: grabbing;
-      background: #0d9488;
-    }
-
-    #log {
-      margin: 24px;
-      white-space: pre-wrap;
-      font-family: ui-monospace, monospace;
-    }
-  </style>
-</head>
-<body>
-  <div id="pad">
-    <div id="target">drag me</div>
-  </div>
-  <pre id="log"></pre>
-  <script>
-    const target = document.getElementById("target");
-    const logEl = document.getElementById("log");
-
-    window.__dragProbe = {
-      dragging: false,
-      events: [],
-      finalLeft: 320,
-      finalTop: 40,
-    };
-
-    let offsetX = 0;
-    let offsetY = 0;
-
-    function pushEvent(event, extra = {}) {
-      window.__dragProbe.events.push({
-        type: event.type,
-        button: event.button,
-        buttons: event.buttons,
-        x: event.clientX,
-        y: event.clientY,
-        target: event.target.id || event.target.tagName,
-        ...extra,
-      });
-      logEl.textContent = JSON.stringify(window.__dragProbe, null, 2);
-    }
-
-    function onPointerLikeStart(event) {
-      if (event.type === "mousedown") {
-        const rect = target.getBoundingClientRect();
-        offsetX = event.clientX - rect.left;
-        offsetY = event.clientY - rect.top;
-        window.__dragProbe.dragging = true;
-        target.classList.add("dragging");
-        event.preventDefault();
-      }
-      pushEvent(event, { phase: "start" });
-    }
-
-    target.addEventListener("mousedown", (event) => {
-      const rect = target.getBoundingClientRect();
-      offsetX = event.clientX - rect.left;
-      offsetY = event.clientY - rect.top;
-      window.__dragProbe.dragging = true;
-      target.classList.add("dragging");
-      event.preventDefault();
-      pushEvent(event, { phase: "start" });
-    });
-    target.addEventListener("pointerdown", onPointerLikeStart);
-
-    document.addEventListener("mousemove", (event) => {
-      if (window.__dragProbe.dragging) {
-        const left = event.clientX - offsetX;
-        const top = event.clientY - offsetY;
-        target.style.left = `${left}px`;
-        target.style.top = `${top}px`;
-        window.__dragProbe.finalLeft = left;
-        window.__dragProbe.finalTop = top;
-      }
-      pushEvent(event);
-    });
-    document.addEventListener("pointermove", (event) => {
-      pushEvent(event);
-    });
-
-    document.addEventListener("mouseup", (event) => {
-      if (window.__dragProbe.dragging) {
-        window.__dragProbe.dragging = false;
-        target.classList.remove("dragging");
-      }
-      pushEvent(event, { phase: "end" });
-    });
-    document.addEventListener("pointerup", (event) => {
-      pushEvent(event, { phase: "end" });
-    });
-    target.addEventListener("dragstart", (event) => {
-      pushEvent(event, { phase: "dragstart" });
-    });
-  </script>
-</body>
-</html>

cli/src/native/test_fixtures/html5_drag_probe.html

@@ -1,91 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>HTML5 Drag Probe</title>
-  <style>
-    body {
-      margin: 24px;
-      font: 14px/1.4 sans-serif;
-    }
-
-    #source, #dest {
-      width: 120px;
-      height: 80px;
-      display: inline-flex;
-      align-items: center;
-      justify-content: center;
-      border: 1px solid #666;
-      user-select: none;
-      margin-right: 40px;
-    }
-
-    #source {
-      background: #f97316;
-      color: white;
-    }
-
-    #dest {
-      background: #e5e7eb;
-    }
-
-    pre {
-      margin-top: 24px;
-      white-space: pre-wrap;
-      font-family: ui-monospace, monospace;
-    }
-  </style>
-</head>
-<body>
-  <div id="source" draggable="true">drag source</div>
-  <div id="dest">drop zone</div>
-  <pre id="log"></pre>
-  <script>
-    const source = document.getElementById("source");
-    const dest = document.getElementById("dest");
-    const logEl = document.getElementById("log");
-
-    window.__html5DragProbe = { events: [] };
-
-    function pushEvent(event, extra = {}) {
-      window.__html5DragProbe.events.push({
-        type: event.type,
-        target: event.target.id || event.target.tagName,
-        x: event.clientX,
-        y: event.clientY,
-        button: event.button,
-        buttons: event.buttons,
-        ...extra,
-      });
-      logEl.textContent = JSON.stringify(window.__html5DragProbe, null, 2);
-    }
-
-    for (const type of ["pointerdown", "mousedown", "dragstart", "drag", "dragend"]) {
-      source.addEventListener(type, (event) => {
-        if (type === "dragstart") {
-          event.dataTransfer.setData("text/plain", "probe");
-        }
-        pushEvent(event);
-      });
-    }
-
-    for (const type of ["pointermove", "mousemove", "dragenter", "dragover", "drop", "pointerup", "mouseup"]) {
-      document.addEventListener(type, (event) => {
-        if (type === "dragover") {
-          event.preventDefault();
-        }
-        if (type === "drop") {
-          pushEvent(event, { dropped: event.dataTransfer.getData("text/plain") });
-          return;
-        }
-        pushEvent(event);
-      });
-    }
-
-    dest.addEventListener("dragover", (event) => event.preventDefault());
-    dest.addEventListener("drop", (event) => {
-      pushEvent(event, { dropped: event.dataTransfer.getData("text/plain") });
-    });
-  </script>
-</body>
-</html>

cli/src/native/test_fixtures/pointer_capture_probe.html

@@ -1,113 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>Pointer Capture Probe</title>
-  <style>
-    body {
-      margin: 24px;
-      font: 14px/1.4 sans-serif;
-    }
-    #crop {
-      position: relative;
-      width: 240px;
-      height: 180px;
-      border: 2px solid #fff;
-      outline: 1px solid #555;
-      background: rgba(0, 0, 0, 0.2);
-    }
-    #handle {
-      position: absolute;
-      width: 20px;
-      height: 20px;
-      top: -16px;
-      left: -16px;
-      padding-top: 13px;
-      padding-left: 13px;
-      box-sizing: content-box;
-      background: rgba(255, 0, 0, 0.25);
-    }
-    #handle::after {
-      content: "";
-      display: block;
-      width: 20px;
-      height: 20px;
-      border-top: 2px solid white;
-      border-left: 2px solid white;
-    }
-    pre {
-      margin-top: 24px;
-      white-space: pre-wrap;
-      font-family: ui-monospace, monospace;
-    }
-  </style>
-</head>
-<body>
-  <div id="crop" aria-label="crop area">
-    <div id="handle" aria-label="crop handle topLeft" data-anchor="topLeft"></div>
-  </div>
-  <pre id="log"></pre>
-  <script>
-    const crop = document.getElementById("crop");
-    const handle = document.getElementById("handle");
-    const logEl = document.getElementById("log");
-
-    const state = {
-      targetAnchor: null,
-      dragging: false,
-      moved: false,
-      events: [],
-    };
-    window.__pointerCaptureProbe = state;
-
-    function sync() {
-      logEl.textContent = JSON.stringify(state, null, 2);
-    }
-
-    function push(event, extra = {}) {
-      state.events.push({
-        type: event.type,
-        target: event.target.id || event.target.tagName,
-        currentTarget: event.currentTarget.id || event.currentTarget.tagName,
-        pointerId: event.pointerId,
-        button: event.button,
-        buttons: event.buttons,
-        hasCapture: event.currentTarget.hasPointerCapture?.(event.pointerId) ?? false,
-        x: event.clientX,
-        y: event.clientY,
-        ...extra,
-      });
-      sync();
-    }
-
-    crop.addEventListener("pointerdown", (event) => {
-      state.targetAnchor = event.target.getAttribute("data-anchor");
-      crop.setPointerCapture(event.pointerId);
-      event.preventDefault();
-      push(event, { phase: "down", targetAnchor: state.targetAnchor });
-    });
-
-    crop.addEventListener("pointermove", (event) => {
-      const hasCapture = crop.hasPointerCapture(event.pointerId);
-      if (hasCapture && state.targetAnchor) {
-        state.dragging = true;
-        state.moved = true;
-      }
-      push(event, { phase: hasCapture ? "drag" : "hover", targetAnchor: state.targetAnchor });
-    });
-
-    crop.addEventListener("pointerup", (event) => {
-      const hadCapture = crop.hasPointerCapture(event.pointerId);
-      state.dragging = false;
-      push(event, { phase: "up", targetAnchor: state.targetAnchor, hadCapture });
-      state.targetAnchor = null;
-    });
-
-    handle.addEventListener("pointerdown", (event) => push(event, { listener: "handle" }));
-    handle.addEventListener("pointermove", (event) => push(event, { listener: "handle" }));
-    handle.addEventListener("pointerup", (event) => push(event, { listener: "handle" }));
-
-    sync();
-  </script>
-</body>
-</html>

cli/src/native/webdriver/appium.rs

@@ -40,45 +40,32 @@ impl AppiumManager {
         })
     }
 
-    pub fn build_ios_capabilities(
-        device_udid: Option<&str>,
-        device_name: Option<&str>,
-        platform_version: Option<&str>,
-    ) -> Value {
-        let mut caps = json!({
-            "platformName": "iOS",
-            "appium:automationName": "XCUITest",
-            "browserName": "Safari",
-            "appium:noReset": true,
-        });
-
-        if let Some(name) = device_name {
-            caps["appium:deviceName"] = json!(name);
-        } else {
-            caps["appium:deviceName"] = json!("iPhone");
-        }
-
-        if let Some(ver) = platform_version {
-            caps["appium:platformVersion"] = json!(ver);
-        }
-
-        if let Some(udid) = device_udid {
-            caps["appium:udid"] = json!(udid);
-        }
-
-        caps
-    }
-
     pub async fn create_ios_session(
         &mut self,
         device_name: Option<&str>,
         platform_version: Option<&str>,
     ) -> Result<Value, String> {
-        let caps = Self::build_ios_capabilities(
-            self.device_udid.as_deref(),
-            device_name,
-            platform_version,
-        );
+        let mut caps = json!({
+            "platformName": "iOS",
+            "automationName": "XCUITest",
+            "browserName": "Safari",
+            "noReset": true,
+        });
+
+        if let Some(name) = device_name {
+            caps["deviceName"] = json!(name);
+        } else {
+            caps["deviceName"] = json!("iPhone");
+        }
+
+        if let Some(ver) = platform_version {
+            caps["platformVersion"] = json!(ver);
+        }
+
+        if let Some(ref udid) = self.device_udid {
+            caps["udid"] = json!(udid);
+        }
+
         self.client.create_session(caps).await
     }
 
@@ -211,30 +198,4 @@ mod tests {
         assert_eq!(APPIUM_DEFAULT_PORT, 4723);
         assert_eq!(APPIUM_STARTUP_TIMEOUT_SECS, 30);
     }
-
-    #[test]
-    fn test_ios_capabilities_use_vendor_prefix() {
-        let caps = AppiumManager::build_ios_capabilities(
-            Some("TEST-UDID-123"),
-            Some("iPhone 16 Pro"),
-            Some("18.5"),
-        );
-
-        // W3C standard capabilities must NOT have vendor prefix
-        assert!(caps.get("platformName").is_some());
-        assert!(caps.get("browserName").is_some());
-
-        // Non-standard capabilities MUST have appium: vendor prefix
-        assert!(caps.get("appium:automationName").is_some());
-        assert!(caps.get("appium:noReset").is_some());
-        assert!(caps.get("appium:deviceName").is_some());
-        assert!(caps.get("appium:platformVersion").is_some());
-        assert!(caps.get("appium:udid").is_some());
-
-        // Must NOT have unprefixed non-standard capabilities
-        assert!(caps.get("automationName").is_none());
-        assert!(caps.get("noReset").is_none());
-        assert!(caps.get("deviceName").is_none());
-        assert!(caps.get("udid").is_none());
-    }
 }

cli/src/native/webdriver/client.rs

@@ -212,6 +212,32 @@ impl WebDriverClient {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_client_new() {
+        let client = WebDriverClient::new(4444);
+        assert_eq!(client.base_url, "http://127.0.0.1:4444");
+        assert!(client.session_id.is_none());
+    }
+
+    #[test]
+    fn test_session_id_none() {
+        let client = WebDriverClient::new(4444);
+        let result = client.session_id();
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("No active WebDriver session"));
+    }
+
+    #[test]
+    fn test_client_custom_port() {
+        let client = WebDriverClient::new(9515);
+        assert_eq!(client.base_url, "http://127.0.0.1:9515");
+    }
+}
+
 async fn http_request(method: &str, url: &str, body: Option<&Value>) -> Result<Value, String> {
     let parsed = url::Url::parse(url).map_err(|e| format!("Invalid URL: {}", e))?;
     let host = parsed.host_str().unwrap_or("127.0.0.1");
@@ -290,29 +316,3 @@ async fn http_request(method: &str, url: &str, body: Option<&Value>) -> Result<V
         )
     })
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_client_new() {
-        let client = WebDriverClient::new(4444);
-        assert_eq!(client.base_url, "http://127.0.0.1:4444");
-        assert!(client.session_id.is_none());
-    }
-
-    #[test]
-    fn test_session_id_none() {
-        let client = WebDriverClient::new(4444);
-        let result = client.session_id();
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("No active WebDriver session"));
-    }
-
-    #[test]
-    fn test_client_custom_port() {
-        let client = WebDriverClient::new(9515);
-        assert_eq!(client.base_url, "http://127.0.0.1:9515");
-    }
-}

cli/src/test_utils.rs

@@ -1,49 +0,0 @@
-use std::sync::{Mutex, MutexGuard};
-
-/// Global mutex shared across all test modules to prevent parallel tests from
-/// interfering with each other when mutating environment variables.
-pub static ENV_MUTEX: Mutex<()> = Mutex::new(());
-
-/// RAII guard that locks [`ENV_MUTEX`] and restores environment variables on drop.
-pub struct EnvGuard<'a> {
-    _lock: MutexGuard<'a, ()>,
-    vars: Vec<(String, Option<String>)>,
-}
-
-impl<'a> EnvGuard<'a> {
-    pub fn new(var_names: &[&str]) -> Self {
-        let lock = ENV_MUTEX.lock().unwrap();
-        let vars = var_names
-            .iter()
-            .map(|&name| (name.to_string(), std::env::var(name).ok()))
-            .collect();
-        Self { _lock: lock, vars }
-    }
-
-    pub fn set(&self, name: &str, value: &str) {
-        debug_assert!(
-            self.vars.iter().any(|(n, _)| n == name),
-            "EnvGuard::set called with unregistered var: {name}"
-        );
-        std::env::set_var(name, value);
-    }
-
-    pub fn remove(&self, name: &str) {
-        debug_assert!(
-            self.vars.iter().any(|(n, _)| n == name),
-            "EnvGuard::remove called with unregistered var: {name}"
-        );
-        std::env::remove_var(name);
-    }
-}
-
-impl Drop for EnvGuard<'_> {
-    fn drop(&mut self) {
-        for (name, value) in &self.vars {
-            match value {
-                Some(v) => std::env::set_var(name, v),
-                None => std::env::remove_var(name),
-            }
-        }
-    }
-}

cli/src/upgrade.rs

@@ -1,284 +0,0 @@
-use crate::color;
-use std::path::Path;
-use std::process::{exit, Command, Stdio};
-
-const CURRENT_VERSION: &str = env!("CARGO_PKG_VERSION");
-const NPM_REGISTRY_URL: &str = "https://registry.npmjs.org/agent-browser/latest";
-
-enum InstallMethod {
-    Npm,
-    Pnpm,
-    Yarn,
-    Bun,
-    Homebrew,
-    Cargo,
-    Unknown,
-}
-
-async fn fetch_latest_version() -> Result<String, String> {
-    let resp = reqwest::get(NPM_REGISTRY_URL)
-        .await
-        .map_err(|e| format!("Failed to fetch version info: {}", e))?;
-
-    let body: serde_json::Value = resp
-        .json()
-        .await
-        .map_err(|e| format!("Failed to parse version info: {}", e))?;
-
-    body.get("version")
-        .and_then(|v| v.as_str())
-        .map(|s| s.to_string())
-        .ok_or_else(|| "No version field in registry response".to_string())
-}
-
-/// Parse the `.install-method` marker written by postinstall.js.
-fn read_install_method_marker(exe_dir: &Path) -> Option<InstallMethod> {
-    let contents = std::fs::read_to_string(exe_dir.join(".install-method")).ok()?;
-    match contents.trim() {
-        "npm" => Some(InstallMethod::Npm),
-        "pnpm" => Some(InstallMethod::Pnpm),
-        "yarn" => Some(InstallMethod::Yarn),
-        "bun" => Some(InstallMethod::Bun),
-        _ => None,
-    }
-}
-
-fn detect_install_method() -> InstallMethod {
-    if let Ok(exe) = std::env::current_exe() {
-        // Resolve symlinks to find the real binary location
-        let real_path = exe.canonicalize().unwrap_or(exe);
-
-        // Preferred: read the marker file written at install time
-        if let Some(dir) = real_path.parent() {
-            if let Some(method) = read_install_method_marker(dir) {
-                return method;
-            }
-        }
-
-        // Fallback: infer from executable path
-        let path_str = real_path.to_string_lossy();
-
-        if path_str.contains("/.cargo/bin/") || path_str.contains("\\.cargo\\bin\\") {
-            return InstallMethod::Cargo;
-        }
-
-        if path_str.contains("/Cellar/agent-browser/")
-            || path_str.contains("/homebrew/")
-            || path_str.contains("/linuxbrew/")
-        {
-            return InstallMethod::Homebrew;
-        }
-
-        if path_str.contains("/pnpm/") || path_str.contains("/pnpm-global/") {
-            return InstallMethod::Pnpm;
-        }
-
-        if path_str.contains("/.yarn/") || path_str.contains("/yarn/global/") {
-            return InstallMethod::Yarn;
-        }
-
-        if path_str.contains("/.bun/") {
-            return InstallMethod::Bun;
-        }
-
-        if path_str.contains("node_modules/agent-browser")
-            || path_str.contains("node_modules\\agent-browser")
-        {
-            return InstallMethod::Npm;
-        }
-    }
-
-    // Last resort: probe package managers via subprocess
-
-    #[cfg(any(target_os = "macos", target_os = "linux"))]
-    {
-        if command_succeeds("brew", &["list", "agent-browser"]) {
-            return InstallMethod::Homebrew;
-        }
-    }
-
-    if command_output_contains(
-        "pnpm",
-        &["list", "-g", "agent-browser", "--depth=0"],
-        "agent-browser",
-    ) {
-        return InstallMethod::Pnpm;
-    }
-
-    if command_output_contains("yarn", &["global", "list", "--depth=0"], "agent-browser") {
-        return InstallMethod::Yarn;
-    }
-
-    if command_output_contains("bun", &["pm", "ls", "-g"], "agent-browser") {
-        return InstallMethod::Bun;
-    }
-
-    if command_succeeds("npm", &["list", "-g", "agent-browser", "--depth=0"]) {
-        return InstallMethod::Npm;
-    }
-
-    InstallMethod::Unknown
-}
-
-fn command_succeeds(cmd: &str, args: &[&str]) -> bool {
-    Command::new(cmd)
-        .args(args)
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false)
-}
-
-fn command_output_contains(cmd: &str, args: &[&str], needle: &str) -> bool {
-    Command::new(cmd)
-        .args(args)
-        .stderr(Stdio::null())
-        .output()
-        .map(|o| o.status.success() && String::from_utf8_lossy(&o.stdout).contains(needle))
-        .unwrap_or(false)
-}
-
-fn run_upgrade_command(method: &InstallMethod) -> bool {
-    let (cmd, args, display): (&str, &[&str], &str) = match method {
-        InstallMethod::Npm => (
-            "npm",
-            &["install", "-g", "agent-browser@latest"],
-            "npm install -g agent-browser@latest",
-        ),
-        InstallMethod::Pnpm => (
-            "pnpm",
-            &["add", "-g", "agent-browser@latest"],
-            "pnpm add -g agent-browser@latest",
-        ),
-        // NOTE: `yarn global` is Yarn Classic (v1) only; Yarn Berry (v2+) removed it.
-        // Users on Yarn v2+ won't reach this path — detection falls through to Unknown.
-        InstallMethod::Yarn => (
-            "yarn",
-            &["global", "add", "agent-browser@latest"],
-            "yarn global add agent-browser@latest",
-        ),
-        InstallMethod::Bun => (
-            "bun",
-            &["install", "-g", "agent-browser@latest"],
-            "bun install -g agent-browser@latest",
-        ),
-        InstallMethod::Homebrew => (
-            "brew",
-            &["upgrade", "agent-browser"],
-            "brew upgrade agent-browser",
-        ),
-        InstallMethod::Cargo => (
-            "cargo",
-            &["install", "agent-browser", "--force"],
-            "cargo install agent-browser --force",
-        ),
-        InstallMethod::Unknown => return false,
-    };
-
-    println!("Running: {}", display);
-    Command::new(cmd)
-        .args(args)
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false)
-}
-
-pub fn run_upgrade() {
-    let current = CURRENT_VERSION;
-
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .unwrap_or_else(|e| {
-            eprintln!(
-                "{} Failed to create runtime: {}",
-                color::error_indicator(),
-                e
-            );
-            exit(1);
-        });
-
-    let latest = match rt.block_on(fetch_latest_version()) {
-        Ok(v) => v,
-        Err(e) => {
-            eprintln!(
-                "{} Could not check latest version: {}",
-                color::warning_indicator(),
-                e
-            );
-            String::new()
-        }
-    };
-
-    if !latest.is_empty() && current == latest.as_str() {
-        println!(
-            "{} agent-browser is already at the latest version (v{})",
-            color::success_indicator(),
-            current
-        );
-        return;
-    }
-
-    let method = detect_install_method();
-
-    let method_name = match &method {
-        InstallMethod::Npm => "npm",
-        InstallMethod::Pnpm => "pnpm",
-        InstallMethod::Yarn => "yarn",
-        InstallMethod::Bun => "bun",
-        InstallMethod::Homebrew => "Homebrew",
-        InstallMethod::Cargo => "Cargo",
-        InstallMethod::Unknown => "",
-    };
-
-    if matches!(method, InstallMethod::Unknown) {
-        eprintln!(
-            "{} Could not detect installation method.",
-            color::error_indicator()
-        );
-        eprintln!("  To update manually, run one of:");
-        eprintln!("    npm install -g agent-browser@latest       # npm");
-        eprintln!("    pnpm add -g agent-browser@latest          # pnpm");
-        eprintln!("    yarn global add agent-browser@latest       # yarn");
-        eprintln!("    bun install -g agent-browser@latest        # bun");
-        eprintln!("    brew upgrade agent-browser                 # Homebrew");
-        eprintln!("    cargo install agent-browser --force        # Cargo");
-        exit(1);
-    }
-
-    println!("Detected installation via {}.", method_name);
-
-    if !latest.is_empty() {
-        println!(
-            "{}",
-            color::cyan(&format!(
-                "Upgrading agent-browser... v{} → v{}",
-                current, latest
-            ))
-        );
-    } else {
-        println!(
-            "{}",
-            color::cyan(&format!("Upgrading agent-browser (v{})...", current))
-        );
-    }
-
-    let success = run_upgrade_command(&method);
-
-    if success {
-        if !latest.is_empty() {
-            println!(
-                "{} Done! v{} → v{}",
-                color::success_indicator(),
-                current,
-                latest
-            );
-        } else {
-            println!("{} Done!", color::success_indicator());
-        }
-    } else {
-        eprintln!("{} Upgrade failed.", color::error_indicator());
-        exit(1);
-    }
-}

docs/PRD-cli-web-collection-ergonomics.md

@@ -0,0 +1,272 @@
+# PRD: CLI Web 数据采集体验优化（以小红书场景为例）
+
+- 文档版本: v0.1
+- 状态: Draft
+- 作者: Codex
+- 日期: 2026-03-04
+
+## 1. 背景与问题
+
+在使用 `agent-browser` CLI 执行「小红书宠物博主采集（100 条）」时，当前流程可完成任务，但存在明显的可用性与稳定性痛点：
+
+1. 网络层可观测性不足，响应体抓取不稳定，需注入脚本劫持。
+2. 分页采集依赖手工 `scroll down + wait`，重复劳动且易漏数据。
+3. 结构化导出缺少一站式命令，需要 `eval` 二次解析。
+4. 页面交互依赖文本选择，页面文案变动后脆弱。
+5. 反爬失败时缺少可解释的自动回退策略。
+6. 用户对“可抓字段”预期不清（例如搜索接口无联系方式）。
+7. 长会话缺少快照与断点续抓机制。
+
+## 2. 目标与非目标
+
+## 2.1 目标
+
+1. 将常见采集链路从“脚本拼接”降为“CLI 原生命令组合”。
+2. 让关键动作具备可观测性（日志）和可恢复性（快照/续跑）。
+3. 降低站点轻微改版、反爬限制带来的失败率。
+
+## 2.2 非目标
+
+1. 不承诺绕过平台强风控或登录体系。
+2. 不在本期实现完整通用爬虫 DSL。
+3. 不默认抓取平台未公开展示的隐私字段。
+
+## 3. 目标用户与核心场景
+
+1. 增长/运营: 按关键词采集账号基础数据并导出 CSV。
+2. 测试/研发: 复现抓取问题，定位请求失败原因。
+3. AI Agent 工作流: 在 CLI 内稳定执行“搜索 -> 翻页 -> 提取 -> 导出”。
+
+## 4. 需求范围与优先级
+
+## 4.1 P0
+
+1. `network capture` 增强模式（可过滤、可落盘 response body）。
+2. `scroll-collect` 自动滚动采集（按页数或直到无新增）。
+3. `extract` / `extract-to` 结构化导出（JSON/CSV）。
+
+## 4.2 P1
+
+1. 语义选择器与 fallback 链（role/aria/data/text）。
+2. 401/403/406 智能回退（页面触发 + 回包监听）。
+3. 可抓字段矩阵与二段式采集文档提示。
+
+## 4.3 P2
+
+1. `session snapshot` + `crawl resume` 断点续抓。
+
+## 5. CLI 方案设计
+
+## 5.1 网络捕获增强
+
+命令草案:
+
+```bash
+agent-browser network capture --match '/api/sns/web/v1/search/usersearch' --save ./out.ndjson
+agent-browser network capture --domain edith.xiaohongshu.com --method POST --save ./xhs_usersearch.ndjson
+```
+
+参数:
+
+- `--match <regex>`: 按 URL 正则过滤。
+- `--domain <host>`: 按域名过滤。
+- `--method <GET|POST|...>`: 按方法过滤。
+- `--status <code|range>`: 按状态过滤。
+- `--save <path>`: NDJSON 输出文件。
+- `--include-body <request|response|both>`: 控制 body 输出范围。
+- `--max-body-bytes <n>`: 单条 body 截断阈值。
+
+NDJSON 记录结构:
+
+```json
+{
+  "ts": "2026-03-04T10:00:00.123Z",
+  "session_id": "sess_abc",
+  "request_id": "req_123",
+  "method": "POST",
+  "url": "https://edith.xiaohongshu.com/api/sns/web/v1/search/usersearch",
+  "status": 200,
+  "duration_ms": 312,
+  "request_headers": {"content-type": "application/json"},
+  "request_body": "{...}",
+  "response_headers": {"content-type": "application/json"},
+  "response_body": "{...}",
+  "truncated": false
+}
+```
+
+## 5.2 自动滚动采集
+
+命令草案:
+
+```bash
+agent-browser scroll-collect --until no-new-items --max-steps 200 --idle-rounds 3
+agent-browser scroll-collect --pages 20 --wait-ms 1200
+```
+
+行为:
+
+1. 每轮执行滚动与等待。
+2. 基于 DOM 项数量或网络新增请求判断“是否有新增”。
+3. 达到停止条件后输出结束原因。
+
+输出示例:
+
+```text
+step=1 new_items=15 total_items=15
+step=2 new_items=15 total_items=30
+...
+stop_reason=no-new-items idle_rounds=3 total_items=135
+```
+
+## 5.3 结构化提取与导出
+
+命令草案:
+
+```bash
+agent-browser extract --from network --match usersearch --fields 'name,fans,note_count,red_id'
+agent-browser extract-to --from network --match usersearch --fields 'name,fans,note_count,red_id,url' --format csv --out ./users.csv
+```
+
+参数:
+
+- `--from <network|dom|eval>`: 数据源。
+- `--match <pattern>`: 来源过滤（URL/事件名）。
+- `--query <JMESPath|JSONPath>`: 自定义提取表达式。
+- `--fields <a,b,c>`: 字段映射快捷写法。
+- `--dedupe-by <field>`: 去重键。
+- `--limit <n>`: 限制条数。
+- `--format <json|ndjson|csv>`: 输出格式。
+- `--out <path>`: 文件输出路径。
+
+## 5.4 语义选择器与回退链
+
+命令草案:
+
+```bash
+agent-browser click --selector 'role=tab[name="用户"]' --fallback 'aria=用户,text=用户'
+agent-browser find --selector 'data-testid=user-tab' --fallback 'role=tab[name="用户"],text=用户'
+```
+
+策略:
+
+1. 主选择器失败后按 fallback 顺序重试。
+2. 日志打印每次尝试与失败原因。
+
+## 5.5 反爬失败自动回退
+
+命令草案:
+
+```bash
+agent-browser request replay --on-status 401,403,406 --fallback page-action
+```
+
+策略:
+
+1. 直接请求失败后自动回退到页面行为触发。
+2. 自动复用 UA/Referer/Cookie Jar。
+3. 捕获最终有效响应并给出“回退成功/失败”日志。
+
+## 5.6 会话快照与断点续抓
+
+命令草案:
+
+```bash
+agent-browser session snapshot save ./snapshots/xhs-20260304.json
+agent-browser crawl resume --snapshot ./snapshots/xhs-20260304.json --out ./users.csv
+```
+
+快照最小字段:
+
+- 当前 URL
+- 关键词/筛选参数
+- 已抓 user_id 集合摘要（可哈希分片）
+- 分页进度（page/scroll step）
+- 导出配置（fields/format/out）
+
+## 6. 错误码设计（草案）
+
+- `AB_NET_CAPTURE_BODY_UNAVAILABLE` (1001): 响应体不可用（被浏览器策略阻断或已释放）。
+- `AB_SCROLL_TIMEOUT_NO_PROGRESS` (1101): 滚动超时且无新增。
+- `AB_EXTRACT_QUERY_INVALID` (1201): 提取表达式语法错误。
+- `AB_EXTRACT_OUTPUT_FAILED` (1202): 导出失败（权限/路径不可写）。
+- `AB_SELECTOR_NOT_FOUND` (1301): 主选择器与 fallback 全部失败。
+- `AB_REQUEST_BLOCKED_406` (1406): 请求被风控拦截，且回退链路失败。
+- `AB_RESUME_SNAPSHOT_INVALID` (1501): 快照损坏或版本不兼容。
+
+要求:
+
+1. CLI 退出码与错误码可映射。
+2. 错误输出提供 `hint`（下一步建议命令）。
+
+## 7. 日志与可观测性
+
+默认人类可读，开启 `--log-format json` 输出结构化日志。
+
+JSON 日志字段:
+
+- `ts`
+- `level`
+- `session_id`
+- `command`
+- `event`
+- `step`
+- `url`
+- `status`
+- `error_code`
+- `message`
+- `hint`
+
+示例:
+
+```json
+{"ts":"2026-03-04T10:11:22.123Z","level":"INFO","command":"scroll-collect","event":"step","step":12,"new_items":15,"total_items":180}
+{"ts":"2026-03-04T10:13:01.001Z","level":"WARN","command":"request replay","event":"fallback","status":406,"message":"direct request blocked, fallback to page-action"}
+```
+
+## 8. 文档与帮助信息更新要求
+
+当功能落地时，需要同步更新以下位置（按仓库规范）：
+
+1. `cli/src/output.rs`（`--help`、示例、环境变量）
+2. `README.md`（命令选项、样例）
+3. `skills/agent-browser/SKILL.md`（Agent 工作流）
+4. `docs/src/app/`（新增/更新 MDX 页面，表格使用 HTML `<table>`）
+5. 对应源码内联注释
+
+## 9. 验收用例（首批）
+
+1. `network capture` 能稳定保存目标接口完整 request/response body。
+2. 设置 `--max-body-bytes` 后被截断记录带 `truncated=true`。
+3. `scroll-collect --pages 5` 精确执行 5 轮并退出。
+4. `scroll-collect --until no-new-items` 在连续空增量 N 轮后退出。
+5. `extract-to ... --format csv` 产出可打开 CSV 且列名正确。
+6. `extract --dedupe-by user_id` 去重结果稳定。
+7. selector 主规则失败时，fallback 生效并成功点击。
+8. 对 406 场景触发自动回退并成功捕获有效响应。
+9. 回退失败时返回 `AB_REQUEST_BLOCKED_406` 且提供 hint。
+10. `session snapshot save/load` 前后任务可恢复。
+11. `crawl resume` 不重复导出已抓 ID。
+12. `--log-format json` 日志字段完整，便于机器消费。
+
+## 10. 里程碑建议
+
+1. M1（1 周）: `network capture` + `scroll-collect`。
+2. M2（1 周）: `extract-to` + selector fallback。
+3. M3（1 周）: 406 回退链路 + 文档补全。
+4. M4（1 周）: snapshot/resume + 稳定性打磨。
+
+## 11. 风险与缓解
+
+1. 平台策略变化导致规则失效。  
+缓解: 增加站点适配层与策略开关，保留回退日志。
+2. 响应体过大带来内存与 IO 压力。  
+缓解: 流式写入 NDJSON + 截断阈值。
+3. 通用提取表达式学习成本高。  
+缓解: 提供字段模板与场景 presets。
+
+## 12. 开放问题
+
+1. `extract` 表达式标准优先 JSONPath 还是 JMESPath？
+2. `session snapshot` 是否需要加密（含 cookie 元信息）？
+3. 是否提供站点模板（如 `preset xiaohongshu-user-search`）以降低上手成本？

docs/blog/agent-browser-stealth-attack-defense-playbook.zh-CN.md

@@ -0,0 +1,192 @@
+# 浏览器自动化攻防方案设计：检测模型与分层控制面
+
+本文聚焦浏览器自动化的攻防方案设计，按两个部分组织：
+
+1. **原理**：风险评分系统如何形成结论
+2. **控制面**：如何用分层设计降低风险与波动
+
+本文不包含命令行操作与工程实现步骤。
+
+Turnstile 专题内容见：
+[Cloudflare Turnstile 攻防方案设计：系统原理与控制面](https://blog.misonote.com/zh/posts/cloudflare-turnstile-stability-principles/)
+
+---
+
+## 一、原理
+
+### 1.1 风险评分不是单点命中
+
+高风控站点的“是否挑战/是否降权”通常来自多维评分，而不是某一条规则的二元判断。
+
+主要输入维度：
+
+1. **一致性**：同一身份在不同表面是否互相矛盾
+2. **稀有性**：低频异常组合是否出现
+3. **时序性**：行为时间序列是否呈机械统计特征
+4. **执行完整性**：关键链路（挑战脚本、跨域资源、worker）是否被破坏
+
+```mermaid
+flowchart LR
+  A["环境与行为"] --> B["一致性评分"]
+  A --> C["稀有性评分"]
+  A --> D["时序评分"]
+  A --> E["执行完整性评分"]
+  B --> F["综合风险"]
+  C --> F
+  D --> F
+  E --> F
+  F --> G{"放行/挑战/限流"}
+```
+
+### 1.2 一致性：约束集合而非单点修饰
+
+一致性问题的本质是“同一身份在多个观测面上的约束必须同时成立”。
+
+#### 1.2.1 约束集合示意
+
+可以把身份一致性建模为“约束图”：
+
+```mermaid
+flowchart TD
+  UA["UA 字符串"] --> UACH["UA-CH / userAgentMetadata"]
+  UA --> LangH["Accept-Language"]
+  LangH --> LangJS["navigator.language(s)"]
+  LangJS --> Intl["Intl locale/timeZone"]
+  Plat["platform"] --> Rend["渲染能力/WebGL"]
+  Rend --> Win["窗口/屏幕参数"]
+  UACH --> Plat
+```
+
+图中每条边表示“两个表面必须相互一致”，否则会形成冲突分值。
+
+#### 1.2.2 典型冲突类型
+
+- UA 显示平台/版本与 UA-CH 不一致
+- `Accept-Language` 与 `navigator.languages` 不一致
+- `Intl` 时区与偏移/地区推断不一致
+- 设备声明与渲染能力组合异常
+
+工程含义：
+
+- 修一个点可能打破另一个点
+- 设计顺序应是“先定约束集合，再决定每个表面如何满足约束”
+
+### 1.3 稀有性：组合风险而非单值风险
+
+稀有性来自“低频组合”，其危险性来自共现而非单项。
+
+可以将稀有性理解为“联合分布”偏离：
+
+- 单项偏离：可被容忍
+- 多项共现偏离：风险迅速累积
+
+工程含义：
+
+- 目标是减少低频组合在同一会话内叠加
+- 目标不是拟合某个固定画像
+
+### 1.4 时序性：统计特征而非行为语义
+
+行为检测通常关注统计分布特征：
+
+- 低方差：动作间隔过于稳定
+- 强周期：间隔呈固定节奏
+- 强同步：不同类型动作间隔一致
+
+工程含义：
+
+- 行为治理的目标是“分布塑形”（variance/jitter/backoff）
+- 行为治理不是“添加更多动作”
+
+### 1.5 执行完整性：上游条件
+
+执行完整性属于“系统是否能正确运行”的前置条件。
+
+- challenge 脚本、跨域 iframe、跨域 worker 的语义被破坏时，失败率会显著上升
+- 此类失败可能与“是否被识别”为不同类别的问题
+
+工程原则：
+
+> 执行链路保护优先于信号修饰。
+
+---
+
+## 二、控制面（分层设计）
+
+### 2.1 控制面总览
+
+攻防方案可以拆为四层控制面：
+
+1. **启动控制**：治理启动早期显式风险
+2. **协议控制**：治理协议层身份一致性
+3. **运行时控制**：治理页面脚本可观测表面
+4. **行为与会话控制**：治理时序分布与上下文漂移
+
+```mermaid
+flowchart LR
+  A["启动控制"] --> B["协议控制"]
+  B --> C["运行时控制"]
+  C --> D["行为与会话控制"]
+  D --> E["一致性与稳定性"]
+```
+
+### 2.2 启动控制
+
+目标：降低会话早期显式风险。
+
+设计约束：
+
+- 只处理高置信度自动化标识
+- 避免引入与协议层/运行时层不一致的改动
+
+### 2.3 协议控制
+
+目标：将身份约束集合落实到协议层输出。
+
+设计要点：
+
+- 将 UA 与 UA-CH 视为同一约束集合的不同投影
+- 覆盖范围需要与目标（页面/worker/子目标）一致
+
+### 2.4 运行时控制
+
+目标：覆盖高频探测面，同时保证不破坏执行语义。
+
+设计要点：
+
+- 优先治理高频、可解释的探测路径
+- 对跨域挑战链路对象设置严格注入边界
+
+### 2.5 行为与会话控制
+
+目标：塑形时间分布，减少上下文漂移。
+
+设计要点：
+
+- 行为治理以统计分布为目标（variance/jitter/backoff）
+- 会话治理以一致上下文为目标（避免身份漂移）
+
+### 2.6 挑战场景控制面摘要（Turnstile）
+
+Turnstile 场景下的关键控制面可抽象为：
+
+1. 能力令牌语义：服务端验证、有限时效、单次消费
+2. 作用域收缩：`hostname/action/cdata` 收缩滥用空间
+3. 执行链路保护：跨域脚本/iframe/worker 语义保护
+4. 摩擦与安全分离：clearance 属于体验层，不替代安全决策层
+
+该摘要用于将 Turnstile 纳入统一控制面框架；细节见专题文章。
+
+---
+
+## 三、方案设计优先级
+
+控制面设计通常按以下优先级推进：
+
+1. 执行完整性（保证链路可运行）
+2. 一致性约束集合（消除跨表面矛盾）
+3. 稀有性控制（避免低频组合叠加）
+4. 时序分布塑形（降低机械统计特征）
+5. 体验优化（降低重复挑战摩擦）
+
+该顺序的含义是先保证“系统正确性”，再优化“稳定性与摩擦”。

docs/blog/cloudflare-turnstile-stability-principles.zh-CN.md

@@ -0,0 +1,250 @@
+# Cloudflare Turnstile 攻防方案设计：系统原理与控制面
+
+本文聚焦 Turnstile 的攻防方案设计：
+
+1. **系统原理**：token 的安全语义、挑战执行链路、风险评分的输入输出
+2. **控制面设计**：在不同攻击面下，哪些约束是必要的、哪些约束容易引入副作用
+
+本文不包含命令行操作与工程实现步骤。
+
+---
+
+## 一、系统原理
+
+### 1.1 Turnstile 是“能力令牌”系统
+
+Turnstile 的本质是签发一个短生命周期、单次消费的能力令牌（capability token）。
+
+- **签发端**：浏览器端完成挑战执行后获得 token
+- **消费端**：业务服务端通过 Siteverify 验证 token 并决定是否放行
+
+```mermaid
+flowchart LR
+  A["浏览器端挑战执行"] --> B["token"]
+  B --> C["业务服务端"]
+  C --> D["Siteverify"]
+  D --> E{"放行/拒绝"}
+```
+
+关键含义：
+
+- 前端任何“通过”状态都不是业务放行条件
+- 业务放行条件是“token 被正确消费”
+
+### 1.2 Token 的三条安全语义
+
+token 的安全语义可以抽象为三条约束：
+
+1. **必须服务端验证**：不允许仅以前端回调作为依据
+2. **有限时效**：token 超过时效窗口即失效
+3. **单次消费**：同一 token 重复消费应失败
+
+这三条语义分别封装了三个常见攻击目标：
+
+- 伪通过：绕过服务端验证
+- 延迟提交：绕过时效窗口
+- 重放/并发：绕过单次消费
+
+### 1.3 挑战执行链路是“跨域执行系统”
+
+Turnstile 的 token 产生依赖多组件协作，且跨域链路占主导：
+
+- `api.js` 脚本
+- challenge iframe
+- challenge worker
+- 跨域资源请求
+
+```mermaid
+flowchart TD
+  A["加载 api.js"] --> B["创建 iframe"]
+  B --> C["执行 worker"]
+  C --> D["收集信号 + 风险评估"]
+  D --> E["签发 token"]
+```
+
+该链路的工程含义：
+
+- 任何对跨域脚本/iframe/worker 的语义改写，都可能导致 token 生成失败或质量下降
+- token 失败不一定意味着“被识别”，也可能是“链路被破坏”
+
+### 1.4 风险评分：输入不是“真假”，而是“自洽程度”
+
+挑战执行阶段会收集环境与行为信号，形成风险评分。
+
+- **信号输入**：环境一致性（UA/UA-CH、语言/时区、渲染能力、能力暴露）
+- **行为输入**：时序分布（方差、周期性、同步性）
+
+风险评分的关键不是“拟合某种固定画像”，而是“同一身份在多表面是否自洽”。
+
+### 1.5 作用域绑定：hostname / action / cdata
+
+服务端校验时提供用于绑定业务语义的字段：
+
+- `hostname`：token 允许的站点作用域
+- `action`：token 允许的动作作用域
+- `cdata`：token 允许的上下文作用域
+
+这些字段的作用是“收缩 token 可被滥用的范围”，而不是“提高通过率”。
+
+```mermaid
+flowchart LR
+  A["token"] --> B["hostname 作用域"]
+  A --> C["action 作用域"]
+  A --> D["cdata 作用域"]
+  B --> E["降低站外盗用收益"]
+  C --> F["降低动作错配收益"]
+  D --> G["降低跨流程重放收益"]
+```
+
+### 1.6 Token 状态机（能力令牌视角）
+
+从能力令牌视角，token 生命周期可抽象为：
+
+```mermaid
+stateDiagram-v2
+  [*] --> Issued: challenge ok
+  Issued --> Consumed: siteverify ok
+  Issued --> Expired: time window
+  Issued --> Rejected: binding mismatch
+  Issued --> Replayed: reused
+  Replayed --> Rejected
+  Expired --> Rejected
+  Consumed --> [*]
+```
+
+设计目标是让“非法路径”快速失败，并且失败类型可被服务端语义区分。
+
+### 1.7 攻击树（高层）
+
+Turnstile 的主要攻击目标可以抽象为：
+
+```mermaid
+flowchart TD
+  A["绕过业务动作门禁"] --> B["伪造或跳过服务端验证"]
+  A --> C["重放 token"]
+  A --> D["扩大 token 作用域"]
+  A --> E["破坏挑战执行以制造降级路径"]
+  C --> C1["并发提交"]
+  C --> C2["延迟提交"]
+  D --> D1["Any Hostname"]
+  D --> D2["action/cdata 缺失"]
+```
+
+该攻击树强调设计重点：
+
+- 安全决策必须在服务端闭环
+- token 必须被作用域收缩并按语义消费
+
+---
+
+## 二、控制面设计（攻防视角）
+
+### 2.1 控制面分层
+
+Turnstile 防线可以分为四层控制面：
+
+1. **挑战执行控制**：保证脚本/iframe/worker 跨域链路完整
+2. **服务端消费控制**：保证 token 的语义被正确消费
+3. **作用域控制**：收缩 `hostname/action/cdata` 的可用范围
+4. **摩擦控制**：clearance 用于降低挑战摩擦（不作为安全决策依据）
+
+```mermaid
+flowchart LR
+  A["挑战执行控制"] --> E["token 可生成"]
+  A --> F["token 质量"]
+  B["服务端消费控制"] --> G["安全决策闭环"]
+  C["作用域控制"] --> H["滥用收益收缩"]
+  D["摩擦控制"] --> I["挑战频率下降"]
+```
+
+### 2.2 挑战执行控制：跨域语义保护优先
+
+挑战执行链路对跨域执行语义高度敏感。
+
+原则：
+
+- 跨域脚本/iframe/worker 避免语义改写
+- 所有指纹修饰必须先满足“不破坏挑战执行”这一硬约束
+
+该原则的工程含义：
+
+- “执行完整性”是上游条件
+- “信号修饰”是下游优化
+
+### 2.3 服务端消费控制：把 token 当作能力消费
+
+服务端消费控制的设计关键在于“放行条件定义”，而不是“接口调用细节”。
+
+放行条件应体现三类约束：
+
+- 真实性：校验 `success`
+- 作用域：校验 `hostname`
+- 语义绑定：校验 `action/cdata`
+
+并且必须贯彻 token 的两个安全语义：
+
+- 时效性：过期拒绝
+- 单次性：重放拒绝
+
+从攻防角度，该层解决的是“绕过与重放”。
+
+### 2.4 作用域控制：Hostname Management 与 Any Hostname
+
+Hostname 管理解决“站外盗用”的攻击面。
+
+- 启用 Hostname Management：收缩 token 可用站点范围
+- 启用 Any Hostname：扩大 token 可用站点范围
+
+设计结论：
+
+- Any Hostname 不是“更灵活”，而是“扩大攻击面”，必须用更强的服务端约束做补偿控制（来源域白名单 + 业务绑定）。
+
+### 2.5 摩擦控制：Pre-clearance 与 cf_clearance 的边界
+
+Pre-clearance 通过后可产生 clearance，用于后续 WAF 挑战联动。
+
+边界定义：
+
+- clearance 用于体验层（降低重复挑战摩擦）
+- Siteverify 用于安全决策层（业务放行依据）
+
+将两者混用会引入“体验信号替代安全信号”的设计缺陷。
+
+### 2.6 高对抗场景：代理池与设备关联
+
+在代理池与分布式滥用场景中，单一 IP 维度约束容易失效。
+
+设计方向是引入更稳定的关联维度（例如设备级 ephemeral id），用于聚类与阈值策略。
+
+该层属于平台能力与业务风控的交界：
+
+- 平台提供关联信号
+- 业务定义动作分层、阈值与处置策略
+
+---
+
+## 三、方案设计优先级
+
+Turnstile 攻防设计通常按以下优先级推进：
+
+1. 服务端消费语义闭环（真实性 + 作用域 + 绑定 + 单次性 + 时效性）
+2. 挑战执行链路完整性（跨域语义保护）
+3. 信号一致性（减少跨字段矛盾）
+4. 行为时序（降低机械分布）
+5. 体验优化（clearance 等摩擦控制）
+
+该顺序的含义是先定义“正确的安全决策”，再优化“挑战摩擦与通过率波动”。
+
+---
+
+## 官方参考（概念与配置）
+
+- Widgets: <https://developers.cloudflare.com/turnstile/concepts/widget/>
+- Widget configurations: <https://developers.cloudflare.com/turnstile/get-started/client-side-rendering/widget-configurations/>
+- Server-side validation: <https://developers.cloudflare.com/turnstile/get-started/server-side-validation/>
+- CSP: <https://developers.cloudflare.com/turnstile/reference/content-security-policy/>
+- Hostname management: <https://developers.cloudflare.com/turnstile/additional-configuration/hostname-management/>
+- Any Hostname: <https://developers.cloudflare.com/turnstile/additional-configuration/hostname-management/any-hostname/>
+- Pre-clearance: <https://developers.cloudflare.com/turnstile/additional-configuration/hostname-management/pre-clearance/>
+- Cloudflare clearance: <https://developers.cloudflare.com/cloudflare-challenges/concepts/clearance/>
+- Ephemeral IDs: <https://developers.cloudflare.com/turnstile/additional-configuration/ephemeral-id/>

docs/blog/use-agent-browser-stealth-instead-of-agent-browser.zh-CN.md

@@ -0,0 +1,97 @@
+# agent-browser 与 agent-browser-stealth：能力差异与选型
+
+本文给出 `agent-browser` 与 `agent-browser-stealth` 的技术差异、适用场景和升级验证步骤。
+
+项目地址：[leeguooooo/agent-browser](https://github.com/leeguooooo/agent-browser)
+
+---
+
+## 1. 定位差异
+
+- `agent-browser`：标准浏览器自动化能力
+- `agent-browser-stealth`：在标准自动化能力基础上，增加反检测与高风控场景稳定性能力
+
+---
+
+## 2. 核心能力对比
+
+| 维度 | agent-browser | agent-browser-stealth |
+| --- | --- | --- |
+| 自动化基础能力 | 支持 | 支持 |
+| 指纹一致性治理 | 基础 | 多层（launch/CDP/init-script） |
+| 高风控站点稳定性 | 一般 | 更高 |
+| 会话连续性（附着现有浏览器） | 支持 | 支持，默认附着策略更明确 |
+| Cloudflare/Turnstile 回归工具 | 无专用脚本 | `check:turnstile-testkey` |
+
+---
+
+## 3. Cloudflare/Turnstile 相关能力（v0.15.2-fork.2+）
+
+### 3.1 挑战链路保护
+
+- 同源 worker 注入保留
+- 跨域 challenge worker 不做注入改写
+- 降低 challenge worker 执行异常概率
+
+### 3.2 导航等待策略
+
+`open/navigate` 支持：
+
+- `--wait-until load`
+- `--wait-until domcontentloaded`
+- `--wait-until networkidle`
+
+挑战页建议优先 `domcontentloaded`，减少 `load` 阶段超时误判。
+
+### 3.3 确定性回归
+
+提供官方 test key 回归脚本：
+
+```bash
+pnpm run check:turnstile-testkey
+```
+
+通过特征：输出 `XXXX.DUMMY.TOKEN.XXXX`。
+
+---
+
+## 4. 适用场景
+
+优先使用 `agent-browser-stealth` 的场景：
+
+1. 目标站点存在挑战页/验证码/限流
+2. 自动化链路对稳定性要求高
+3. 需要长期回归验证与版本门禁
+
+使用 `agent-browser` 的场景：
+
+1. 低风控站点
+2. 以基础自动化能力验证为主
+
+---
+
+## 5. 升级验证步骤
+
+```bash
+# 1) 检查版本
+agent-browser -V
+
+# 2) 关闭旧 daemon，避免版本漂移
+agent-browser --session default close
+
+# 3) 运行确定性回归
+pnpm run check:turnstile-testkey
+
+# 4) 可选：真实站点回归
+agent-browser --wait-until domcontentloaded open https://www.anyviewer.com/cloudflare.html
+```
+
+如果启用域名白名单（`AGENT_BROWSER_ALLOWED_DOMAINS`），需包含 `challenges.cloudflare.com`。
+
+---
+
+## 6. 结论
+
+`agent-browser-stealth` 适用于高风控与稳定性敏感场景；`agent-browser` 适用于标准自动化场景。  
+选型建议按目标站点风控强度与回归要求决定。
+

docs/src/app/api/docs-chat/route.ts

@@ -12,11 +12,11 @@ export const maxDuration = 60;
 
 const DEFAULT_MODEL = "anthropic/claude-haiku-4.5";
 
-const SYSTEM_PROMPT = `You are a helpful documentation assistant for agent-browser, a browser automation CLI designed for AI agents.
+const SYSTEM_PROMPT = `You are a helpful documentation assistant for agent-browser, a headless browser automation CLI designed for AI agents.
 
-GitHub repository: https://github.com/vercel-labs/agent-browser
+GitHub repository: https://github.com/leeguooooo/agent-browser
 Documentation: https://agent-browser.dev
-npm package: agent-browser
+npm package: agent-browser-stealth
 
 You have access to the full agent-browser documentation via the bash and readFile tools. The docs are available as markdown files in the /workspace/ directory.
 

docs/src/app/api/search/route.ts

@@ -1,69 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { getSearchIndex } from "@/lib/search-index";
-
-export async function GET(req: NextRequest) {
-  const q = req.nextUrl.searchParams.get("q")?.trim().toLowerCase();
-
-  if (!q) {
-    return NextResponse.json({ results: [] });
-  }
-
-  const index = await getSearchIndex();
-  const terms = q.split(/\s+/).filter(Boolean);
-
-  const results = index
-    .map((entry) => {
-      const titleLower = entry.title.toLowerCase();
-      const contentLower = entry.content.toLowerCase();
-
-      const titleMatch = terms.every((t) => titleLower.includes(t));
-      const contentMatch = terms.every((t) => contentLower.includes(t));
-
-      if (!titleMatch && !contentMatch) return null;
-
-      let snippet = "";
-      if (contentMatch) {
-        const firstTermIdx = Math.min(
-          ...terms.map((t) => {
-            const idx = contentLower.indexOf(t);
-            return idx === -1 ? Infinity : idx;
-          }),
-        );
-        if (firstTermIdx !== Infinity) {
-          const start = Math.max(0, firstTermIdx - 40);
-          const end = Math.min(entry.content.length, firstTermIdx + 120);
-          snippet =
-            (start > 0 ? "..." : "") +
-            entry.content.slice(start, end).replace(/\n/g, " ") +
-            (end < entry.content.length ? "..." : "");
-        }
-      }
-
-      return {
-        title: entry.title,
-        href: entry.href,
-        section: entry.section,
-        snippet,
-        score: titleMatch ? 2 : 1,
-      };
-    })
-    .filter(
-      (
-        r,
-      ): r is {
-        title: string;
-        href: string;
-        section: string;
-        snippet: string;
-        score: number;
-      } => r !== null,
-    )
-    .sort((a, b) => b.score - a.score)
-    .slice(0, 20)
-    .map(({ score: _, ...rest }) => rest);
-
-  return NextResponse.json(
-    { results },
-    { headers: { "Cache-Control": "public, max-age=60" } },
-  );
-}

docs/src/app/cdp-mode/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("cdp-mode");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/cdp-mode/page.mdx

@@ -1,7 +1,18 @@
+import { pageMetadata } from '@/lib/page-metadata';
+
+export const metadata = pageMetadata('cdp-mode');
+
 # CDP Mode
 
 Connect to an existing browser via Chrome DevTools Protocol:
 
+Default behavior in this fork: when `--cdp` is omitted, agent-browser auto-attaches to an existing browser by trying `localhost:9333` first, then auto-discovery. If both fail, the command exits (no managed local-launch fallback).
+
+Project policy:
+
+- `--profile` / `AGENT_BROWSER_PROFILE` are forbidden
+- `--channel` / `AGENT_BROWSER_CHANNEL` are forbidden
+
 ```bash
 # Start Chrome with: google-chrome --remote-debugging-port=9222
 
@@ -48,8 +59,7 @@ AGENT_BROWSER_AUTO_CONNECT=1 agent-browser snapshot
 Auto-connect discovers Chrome by:
 
 1. Reading Chrome's `DevToolsActivePort` file from the default user data directory
-2. Falling back to probing common debugging ports (9222, 9229)
-3. If HTTP-based discovery (`/json/version`, `/json/list`) fails, falling back to a direct WebSocket connection
+2. Falling back to probing common debugging ports (9222, 9229, 9333)
 
 This is useful when:
 
@@ -59,7 +69,7 @@ This is useful when:
 
 ## Color scheme
 
-Use `--color-scheme` to set a persistent preference when connecting via CDP:
+Playwright overrides the browser's color scheme to `light` by default when connecting via CDP. Use `--color-scheme` to set a persistent preference:
 
 ```bash
 agent-browser --cdp 9222 --color-scheme dark open https://example.com
@@ -72,6 +82,35 @@ Or set it globally via config or environment variable:
 AGENT_BROWSER_COLOR_SCHEME=dark agent-browser --cdp 9222 open https://example.com
 ```
 
+## Stealth behavior
+
+`--stealth` is enabled by default across connection modes, but capabilities depend on how you connect:
+
+<table>
+  <thead>
+    <tr>
+      <th>Connection type</th>
+      <th>Stealth capabilities</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>Local launch</td>
+      <td>Chromium launch args + context init scripts</td>
+    </tr>
+    <tr>
+      <td>CDP / auto-connect</td>
+      <td>Context init scripts</td>
+    </tr>
+    <tr>
+      <td>Cloud providers</td>
+      <td>Context init scripts (Kernel may also apply provider-managed stealth)</td>
+    </tr>
+  </tbody>
+</table>
+
+Use `--debug` to print the active connection type and applied stealth capabilities.
+
 ## Use cases
 
 This enables control of:
@@ -86,35 +125,143 @@ This enables control of:
 
 <table>
   <thead>
-    <tr><th>Option</th><th>Description</th></tr>
+    <tr>
+      <th>Option</th>
+      <th>Description</th>
+    </tr>
   </thead>
   <tbody>
-    <tr><td><code>--session &lt;name&gt;</code></td><td>Use isolated session</td></tr>
-    <tr><td><code>--profile &lt;path&gt;</code></td><td>Persistent browser profile directory</td></tr>
-    <tr><td><code>-p &lt;provider&gt;</code></td><td>Cloud browser provider (<code>browserbase</code>, <code>browseruse</code>, <code>kernel</code>, <code>browserless</code>)</td></tr>
-    <tr><td><code>--headers &lt;json&gt;</code></td><td>HTTP headers scoped to origin</td></tr>
-    <tr><td><code>--executable-path</code></td><td>Custom browser executable</td></tr>
-    <tr><td><code>--args &lt;args&gt;</code></td><td>Browser launch args (comma-separated)</td></tr>
-    <tr><td><code>--user-agent &lt;ua&gt;</code></td><td>Custom User-Agent string</td></tr>
-    <tr><td><code>--proxy &lt;url&gt;</code></td><td>Proxy server URL</td></tr>
-    <tr><td><code>--proxy-bypass &lt;hosts&gt;</code></td><td>Hosts to bypass proxy</td></tr>
-    <tr><td><code>--json</code></td><td>JSON output for scripts</td></tr>
-    <tr><td><code>--name, -n</code></td><td>Locator name filter</td></tr>
-    <tr><td><code>--exact</code></td><td>Exact text match</td></tr>
-    <tr><td><code>--headed</code></td><td>Show browser window</td></tr>
-    <tr><td><code>{"--cdp <port|url>"}</code></td><td>CDP connection (port or WebSocket URL)</td></tr>
-    <tr><td><code>--auto-connect</code></td><td>Auto-discover and connect to running Chrome</td></tr>
-    <tr><td><code>--color-scheme &lt;scheme&gt;</code></td><td>Persistent color scheme (<code>dark</code>, <code>light</code>, <code>no-preference</code>)</td></tr>
-    <tr><td><code>--debug</code></td><td>Debug output</td></tr>
+    <tr>
+      <td>
+        <code>--session &lt;name&gt;</code>
+      </td>
+      <td>Use isolated session</td>
+    </tr>
+    <tr>
+      <td>
+        <code>-p &lt;provider&gt;</code>
+      </td>
+      <td>
+        Cloud browser provider (<code>browserbase</code>, <code>browseruse</code>,{' '}
+        <code>kernel</code>)
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>--headers &lt;json&gt;</code>
+      </td>
+      <td>HTTP headers scoped to origin</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--executable-path</code>
+      </td>
+      <td>Custom browser executable</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--args &lt;args&gt;</code>
+      </td>
+      <td>Browser launch args (comma-separated)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--user-agent &lt;ua&gt;</code>
+      </td>
+      <td>Custom User-Agent string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--proxy &lt;url&gt;</code>
+      </td>
+      <td>Proxy server URL</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--proxy-bypass &lt;hosts&gt;</code>
+      </td>
+      <td>Hosts to bypass proxy</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--json</code>
+      </td>
+      <td>JSON output for scripts</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--full, -f</code>
+      </td>
+      <td>Full page screenshot</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--name, -n</code>
+      </td>
+      <td>Locator name filter</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--exact</code>
+      </td>
+      <td>Exact text match</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--headed</code>
+      </td>
+      <td>Show browser window</td>
+    </tr>
+    <tr>
+      <td>
+        <code>{'--cdp <port|url>'}</code>
+      </td>
+      <td>CDP connection (port or WebSocket URL)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--auto-connect</code>
+      </td>
+      <td>Auto-discover and connect to running Chrome</td>
+    </tr>
+    <tr>
+      <td>
+        <code>--color-scheme &lt;scheme&gt;</code>
+      </td>
+      <td>
+        Persistent color scheme (<code>dark</code>, <code>light</code>, <code>no-preference</code>)
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>--debug</code>
+      </td>
+      <td>Debug output</td>
+    </tr>
   </tbody>
 </table>
 
 ## Cloud providers
 
-Use the `-p` flag to connect to a cloud browser provider instead of launching a local browser:
+Use cloud browser infrastructure when local browsers aren't available:
 
 ```bash
+# Browserbase
+export BROWSERBASE_API_KEY="your-api-key"
+export BROWSERBASE_PROJECT_ID="your-project-id"
 agent-browser -p browserbase open https://example.com
+
+# Browser Use
+export BROWSER_USE_API_KEY="your-api-key"
+agent-browser -p browseruse open https://example.com
+
+# Kernel
+export KERNEL_API_KEY="your-api-key"
+agent-browser -p kernel open https://example.com
+
+# Or via environment variable
+export AGENT_BROWSER_PROVIDER=browserbase
+agent-browser open https://example.com
 ```
 
-See the [Providers](/providers/browser-use) section for setup and configuration of each supported provider: [Browser Use](/providers/browser-use), [Browserbase](/providers/browserbase), [Browserless](/providers/browserless), and [Kernel](/providers/kernel).
+The `-p` flag takes precedence over `AGENT_BROWSER_PROVIDER`.

docs/src/app/changelog/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("changelog");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/changelog/page.mdx

@@ -1,477 +1,12 @@
+import { pageMetadata } from "@/lib/page-metadata"
+
+export const metadata = pageMetadata("changelog")
+
 # Changelog
 
-## v0.24.0
-
-<p className="text-[#888] text-sm">April 2, 2026</p>
-
-### New Features
-
-- **AWS Bedrock AgentCore provider** - Added AWS Bedrock AgentCore as a cloud browser provider. Connect with `--provider agentcore` or `AGENT_BROWSER_PROVIDER=agentcore`. Uses lightweight manual SigV4 signing for authentication with support for the full AWS credential provider chain (environment variables, AWS CLI, SSO, IAM roles). Configure with `AGENTCORE_REGION`, `AGENTCORE_PROFILE_ID`, and `AGENTCORE_BROWSER_ID` environment variables. Returns session ID and Live View URL in the launch response (#397)
-
-### Documentation
-
-- Added AgentCore provider page to docs site, README options table, SKILL.md, and dashboard provider icons (#1120)
-
----
-
-## v0.23.4
-
-<p className="text-[#888] text-sm">March 31, 2026</p>
-
-### Bug Fixes
-
-- Fixed **daemon hang on Linux** caused by a `waitpid(-1)` race condition in the SIGCHLD handler that stole exit statuses from Rust's `Child` handles, leaving the daemon in a broken state. Replaced the global signal handler with targeted crash detection via the existing drain interval (#1098)
-
----
-
-## v0.23.3
-
-<p className="text-[#888] text-sm">March 30, 2026</p>
-
-### Bug Fixes
-
-- Fixed **drag and drop** not working because `mouseMoved` events during the drag omitted the `buttons` bitmask, causing the browser to see `event.buttons === 0` and never fire `dragstart`/`dragover`/`drop` (#1087)
-
----
-
-## v0.23.2
-
-<p className="text-[#888] text-sm">March 30, 2026</p>
-
-### New Features
-
-- **Dashboard session creation** - Sessions can now be created directly from the dashboard UI. A new session dialog provides a unified selector grid for local engines (Chrome, Lightpanda) and cloud providers (Browserbase, Browserless, Browser Use, Kernel) with async creation, loading state, and error display (#1092)
-- **Dashboard provider icons** - The session sidebar now shows the provider or engine icon for each session, making it easy to identify which backend a session is using (#1092)
-
-### Bug Fixes
-
-- Fixed **Browser Use** provider using an intermediate API call instead of connecting directly via WSS, which caused connection failures (#1092)
-- Fixed **Browserbase** provider not sending an explicit JSON body and `Content-Type` header, causing session creation to fail (#1092)
-- Fixed **provider navigation** hanging because `wait_for_lifecycle` waited for page load events that remote providers may not emit. Navigation with `--provider` now automatically sets `waitUntil=none` (#1092)
-- Fixed **remote CDP connections** timing out by increasing the CDP connect timeout from 10s to 25s for cloud providers (#1092)
-- Fixed **zombie daemon processes** not being cleaned up when a provider connection fails during session creation from the dashboard (#1092)
-
----
-
-## v0.23.1
-
-<p className="text-[#888] text-sm">March 30, 2026</p>
-
-### New Features
-
-- **Auto-dismissal for alert and beforeunload dialogs** - JavaScript `alert()` and `beforeunload` dialogs are now automatically accepted to prevent the agent from blocking indefinitely. `confirm` and `prompt` dialogs still require explicit `dialog accept/dismiss` commands. Disable with `--no-auto-dialog` flag or `AGENT_BROWSER_NO_AUTO_DIALOG` environment variable (#1075)
-- **Puppeteer browser cache fallback** - Chrome discovery now searches `~/.cache/puppeteer/chrome/` (or `PUPPETEER_CACHE_DIR`) for Chrome binaries, so users with an existing Puppeteer installation can use agent-browser without a separate install step (#1088)
-- **Console output improvements** - `console.log` of objects now shows the actual object preview (e.g. `{userId: "abc", count: 42}`) instead of `"Object"`. JSON output includes a raw `args` array for programmatic access (#1040)
-
-### Bug Fixes
-
-- Fixed **same-document navigation** (e.g. SPA hash routing) hanging forever because `wait_for_lifecycle` waited for a `Page.loadEventFired` that never fires on same-document navigations (#1059)
-- Fixed **save_state** only capturing cookies and localStorage for the current origin, silently dropping cross-domain data (e.g. SSO/CAS auth cookies). Now uses `Network.getAllCookies` and collects localStorage from all visited origins (#1064)
-- Fixed **externally opened tabs** not appearing in `tab list` when using `--cdp` mode. Tabs opened by the user or another CDP client are now detected and tracked (#1042)
-- Fixed **dashboard server** not picking up installed files without a restart. `dashboard install` now takes effect immediately on a running server (#1066)
-- Fixed **Windows Chrome extraction** failing because zip path normalization used forward slashes while the extraction code expected backslashes (#1088)
-
----
-
-## v0.23.0
-
-<p className="text-[#888] text-sm">March 27, 2026</p>
-
-### New Features
-
-- **Observability dashboard** - Added a local web UI (`dashboard`) that shows live browser viewports, command activity feeds, console output, network requests, storage, and extensions for all sessions. Manage it with `dashboard start`, `dashboard stop`, and `dashboard install`. The dashboard runs as a standalone background process and all sessions stream to it automatically (#1034)
-
-```bash
-agent-browser dashboard install
-agent-browser dashboard start
-agent-browser open example.com    # session appears in dashboard
-agent-browser dashboard stop
-```
-
-- **Runtime stream management** - Added `stream enable`, `stream disable`, and `stream status` commands to control WebSocket streaming at runtime. Streaming is now always enabled by default; `AGENT_BROWSER_STREAM_PORT` overrides the port instead of toggling the feature (#951)
-- **Close all sessions** - Added `close --all` flag to close every active browser session at once
-
-### Bug Fixes
-
-- Fixed **Lightpanda engine** compatibility (#1050)
-- Fixed **Windows daemon TCP bind** failing when Hyper-V reserves the port by falling back to an OS-assigned port and writing it to a `.port` file (#1041)
-- Fixed **Windows dashboard relay** using Unix socket instead of TCP (#1038)
-- Fixed **radio/checkbox elements** being dropped from compact snapshot tree because the `ref=` check required a leading `[` that those elements lack (#1008)
-
----
-
-## v0.22.3
-
-<p className="text-[#888] text-sm">March 25, 2026</p>
-
-### Bug Fixes
-
-- **Re-apply download behavior on recording context** - Fixed an issue where downloads were silently dropped in recording contexts because `Browser.setDownloadBehavior` set at launch only applied to the default context. The download behavior is now re-applied when a new recording context is created (#1019)
-- **Reap zombie Chrome process and fast-detect crash for auto-restart** - Added a non-blocking process-exit check before attempting CDP connection checks. This prevents a 3-second CDP timeout when Chrome has already crashed or exited, enabling faster detection and auto-restart of the browser (#1023)
-- **Route keyboard `type` through text input** - Fixed keyboard `type` subaction to correctly route through the text input handler, and added support for an `insertText` subaction using `Input.insertText` (#1014)
-- **Handle `--clear` flag in `console` command** - Fixed the `console` command to accept and process a `clear` parameter, allowing console event history to be cleared (#1015)
-
----
-
-## v0.22.2
-
-<p className="text-[#888] text-sm">March 24, 2026</p>
-
-### New Features
-
-- **Dialog status command** - Added `dialog status` command to check whether a JavaScript dialog is currently open (#999)
-- **Dialog warning field** - Command responses now include a `warning` field when a JavaScript dialog is pending, indicating the dialog type and message (#999)
-
-### Improvements
-
-- **Standard proxy environment variables** - The proxy setting now automatically falls back to standard environment variables (`HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY`, and their lowercase variants), with `NO_PROXY`/`no_proxy` respected for bypass rules (#1000)
-- **Font packages for `--with-deps`** - Installing with `--with-deps` now includes CJK and emoji font packages on Linux (Debian, RPM, and yum-based distros) to prevent missing glyphs when rendering international content (#1002)
-
-### Bug Fixes
-
-- Fixed `state show` always failing with "Missing 'path' parameter" due to a mismatched JSON field name (#994)
-- Fixed `console` command returning only `Done` due to a JSON field name mismatch in the response (#986)
-- Fixed browser-domain CDP events being dropped during downloads due to a `sessionId` mismatch (#998)
-- Fixed proxy authentication by handling credentials via the CDP `Fetch.authRequired` event rather than passing them inline (#1000)
-
----
-
-## v0.22.1
-
-<p className="text-[#888] text-sm">March 24, 2026</p>
-
-### Bug Fixes
-
-- Fixed **modifier key chords** (e.g. `Control+a`, `Shift+Enter`, `Control+Shift+a`) not being handled correctly when using `press`. Modifier keys are now parsed and forwarded as CDP modifier bitmasks rather than treated as part of the key name (#980)
-- Fixed **query parameters being dropped** from `--cdp` HTTP URLs (e.g. `http://host:9222?mode=Hello`). Query strings are now preserved and forwarded to the remote CDP endpoint (#982)
-
----
-
-## v0.22.0
-
-<p className="text-[#888] text-sm">March 23, 2026</p>
-
-### New Features
-
-- **Cross-origin iframe support** - Added support for snapshots and interactions within cross-origin iframes via `Target.setAutoAttach` (#949)
-- **Network request detail and filtering** - Added `network request <requestId>` command to view full request/response detail, and new filtering options for `network requests` including `--type` (e.g. `xhr,fetch`), `--method` (e.g. `POST`), and `--status` (e.g. `2xx`, `400-499`) (#935)
-
-```bash
-agent-browser network requests --type xhr,fetch --method POST
-agent-browser network request <requestId>
-```
-
-### Improvements
-
-- **Snapshot usability** - Reduced AI cognitive load by filtering semantic noise from snapshot output; cursor-interactive elements are now included by default, making the `-C` flag unnecessary (#968)
-- **Upgrade command** - Improved robustness of installation method detection in the upgrade command (#960)
-- **Target tracking** - Enhanced target tracking and page information handling for more reliable browser session management (#969)
-
-### Bug Fixes
-
-- Fixed **viewport dimensions** being reported incorrectly in streaming status messages and screencast (#952)
-- Fixed **`find` command** flags such as `--exact` and `--name` leaking into fill values when used with fill actions (#955)
-- Fixed **state commands** incorrectly starting the daemon when no `session_name` is provided (#677, #964)
-- Fixed **auto-connect** triggering when the daemon is already running, preventing duplicate connections (#971)
-- Fixed **Enter key press** not working by adding a text field to `keyDown` events (#972)
-- Fixed **download command** to properly handle absolute paths and correctly click target elements (#970)
-
-### Breaking Changes
-
-- The `-C` / `--cursor` flag for `snapshot` is deprecated; cursor-interactive elements are now included by default and the flag has no additional effect (#968)
-
----
-
-## v0.21.4
-
-<p className="text-[#888] text-sm">March 20, 2026</p>
-
-### Bug Fixes
-
-- **Auth login readiness** - `agent-browser auth login` now navigates with `load`, waits for usable login form selectors, and uses staged username detection (targeted email/username selectors first, then broad text-input fallback). This reduces SPA timing failures, avoids false matches on unrelated text fields, and prevents `networkidle` hangs on pages with continuous background requests.
-
----
-
-## v0.21.3
-
-<p className="text-[#888] text-sm">March 20, 2026</p>
-
-### Bug Fixes
-
-- **WebSocket keepalive for remote browsers** - Added WebSocket Ping frames and TCP `SO_KEEPALIVE` to prevent CDP connections from being silently dropped by intermediate proxies during idle periods (#936)
-- **XPath selector support** - Fixed element resolution to correctly handle the `xpath=` selector prefix (#908)
-
-### Performance
-
-- **Fast-path for identical snapshots** - Short-circuits the Myers diff algorithm when comparing a snapshot to itself, avoiding unnecessary computation in retry and loop workloads (#922)
-
----
-
-## v0.21.2
-
-<p className="text-[#888] text-sm">March 18, 2026</p>
-
-### Bug Fixes
-
-- **Deduplicate text content in snapshots** - Fixed an issue where duplicate text content appeared in page snapshots (#909)
-- **Native mouse drag state** - Fixed incorrect raw native mouse drag state not being properly tracked across `down`, `move`, and `up` events (#872)
-- **Chrome headless launch failures** - Fixed browser launch failures caused by the `--enable-unsafe-swiftshader` flag in Chrome headless mode (#915)
-- **Origin-scoped `--headers` persistence** - Restored correct persistence of origin-scoped headers set via `--headers` across navigation commands (#894)
-- **Relative URLs in WebSocket domain filter** - Fixed handling of relative URLs in the WebSocket domain filter script (#624)
-
----
-
-## v0.21.1
-
-<p className="text-[#888] text-sm">March 18, 2026</p>
-
-### New Features
-
-- **HAR 1.2 network capture** - Added commands to capture and export network traffic in HAR 1.2 format, including accurate request/response timing, headers, body sizes, and resource types sourced from Chrome DevTools Protocol events (#864)
-- **Built-in `upgrade` command** - Added `agent-browser upgrade` to self-update the CLI; automatically detects your installation method (npm, Homebrew, or Cargo) and runs the appropriate update command (#898)
-
-```bash
-agent-browser upgrade
-```
-
----
-
-## v0.21.0
-
-<p className="text-[#888] text-sm">March 17, 2026</p>
-
-### New Commands
-
-- **`batch`** -- Execute multiple commands in a single invocation. Pipe a JSON array of string arrays to stdin and receive results sequentially. Supports `--bail` to stop on first error and `--json` for structured output.
-
-```bash
-echo '[["open","example.com"],["snapshot"]]' | agent-browser batch --json
-```
-
-- **`network har start/stop`** -- Capture and export network traffic in HAR 1.2 format.
-
-```bash
-agent-browser network har start
-# ... interact with the page ...
-agent-browser network har stop ./trace.har
-```
-
-### New Features
-
-- **iframe support** -- CLI interactions and snapshots now traverse into iframe content, enabling automation of cross-frame pages.
-- **`--idle-timeout` flag** -- Automatically shut down the daemon after a period of inactivity. Accepts human-friendly formats such as `10s`, `3m`, `1h`, or raw milliseconds. Also available as `AGENT_BROWSER_IDLE_TIMEOUT_MS`.
-- **Cursor-interactive elements in snapshots** -- Cursor-interactive elements are now embedded directly into the snapshot tree for richer context.
-- **Brave Browser auto-connect** -- Auto-discovery of Brave Browser for CDP connections on macOS, Linux, and Windows.
-- **linux-musl (Alpine) builds** -- Pre-built binaries for linux-musl targeting both x64 and arm64, enabling native support for Alpine Linux and other musl-based distributions.
-- **WebSocket fallback for CDP discovery** -- When HTTP-based CDP endpoint discovery fails, the CLI now falls back to a WebSocket connection automatically.
-
-### Improvements
-
-- **`--full`/`-f` refactored to command-level flag** -- Moved from a global flag to a per-command flag for clearer scoping.
-- **Enhanced Chrome launch** -- Added `--user-data-dir` support and configurable launch timeout for more reliable browser startup. Chrome now retries launching up to 3 times on transient startup failures.
-- **Consecutive `--auto-connect` commands** -- Multiple consecutive auto-connect commands no longer require a full browser relaunch; external connections are correctly identified and reused.
-- **Batched CDP calls** -- `snapshot -C` and `screenshot --annotate` now batch CDP calls instead of issuing sequential round-trips per element, preventing timeouts on high-latency WSS connections.
-
-### Bug Fixes
-
-- Fixed remote CDP (WSS) snapshot and screenshot hangs by removing WebSocket message/frame size limits
-- Fixed Material Design `check`/`uncheck` falling back to JS `.click()` for overlay-based controls
-- Fixed punctuation characters being dropped in the `type` command
-- Fixed WebSocket streaming by keeping the StreamServer instance alive
-- Filtered internal Chrome targets (`chrome://`, `devtools://`) from auto-connect discovery
-- Fixed `snapshot --selector` scoping to the matched element's subtree
-- Fixed network idle detection returning prematurely for cached pages
-- Fixed daemon panic on broken stderr pipe during Chrome launch
-- Fixed broadcast channel lag being treated as stream closure
-- Fixed daemon liveness detection for PID namespace isolation (e.g. `unshare`)
-- Fixed Ubuntu dependency install accidentally removing system packages
-
----
-
-## v0.20.0
-
-<p className="text-[#888] text-sm">March 13, 2026</p>
-
-### Full Native Rust
-
-agent-browser is now 100% native Rust. The Node.js/Playwright daemon has been completely removed -- no Node.js runtime or Playwright dependency is required to run the daemon. The Rust native daemon is now the only implementation.
-
-<table>
-  <thead>
-    <tr>
-      <th>Metric</th>
-      <th>Node.js</th>
-      <th>Rust</th>
-      <th></th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>Cold start</td>
-      <td>1002ms</td>
-      <td>617ms</td>
-      <td>1.6x faster</td>
-    </tr>
-    <tr>
-      <td>Daemon memory</td>
-      <td>143 MB</td>
-      <td>8 MB</td>
-      <td>18x less</td>
-    </tr>
-    <tr>
-      <td>Install size</td>
-      <td>710 MB</td>
-      <td>7 MB</td>
-      <td>99x smaller</td>
-    </tr>
-  </tbody>
-</table>
-
-```bash
-npm install -g agent-browser      # 7 MB install
-agent-browser install              # download Chrome
-agent-browser open example.com
-agent-browser snapshot
-```
-
-### Improvements
-
-- **Benchmarks** -- Added benchmark suite for comparing native vs Node.js daemon performance across cold start, warm start, memory, and install size.
-- **Chromium installer hardened** -- Fixed zip path traversal vulnerability in Chrome for Testing installer.
-
-### Bug Fixes
-
-- Fixed `--headed false` flag not being respected in CLI
-- Fixed "not found" error pattern in `to_ai_friendly_error` incorrectly catching non-element errors
-- Fixed storage local key lookup parsing and text output
-- Fixed Lightpanda engine launch with release binaries
-- Hardened Lightpanda startup timeouts
-
----
-
-## v0.19.0
-
-<p className="text-[#888] text-sm">March 13, 2026</p>
-
-### New Features
-
-- **Browserless.io provider** -- Added browserless.io as a browser provider, supported in both Node.js and native daemon paths. Connect to remote Browserless instances using the `--provider browserless` flag or `AGENT_BROWSER_PROVIDER=browserless` environment variable.
-
-```bash
-export BROWSERLESS_API_KEY="your-api-key"
-agent-browser --provider browserless open example.com
-agent-browser --provider browserless screenshot ./page.png
-```
-
-- **`clipboard` command** -- Read from and write to the browser clipboard. Supports `read`, `write`, `copy` (simulates Ctrl+C), and `paste` (simulates Ctrl+V) operations.
-
-```bash
-agent-browser clipboard read
-agent-browser clipboard write "Hello, World!"
-agent-browser clipboard copy
-agent-browser clipboard paste
-```
-
-- **Screenshot output configuration** -- New global flags for persistent screenshot settings: `--screenshot-dir`, `--screenshot-quality`, and `--screenshot-format`. Also available as environment variables `AGENT_BROWSER_SCREENSHOT_DIR`, `AGENT_BROWSER_SCREENSHOT_QUALITY`, and `AGENT_BROWSER_SCREENSHOT_FORMAT`.
-
-```bash
-agent-browser screenshot --screenshot-dir ./shots
-agent-browser screenshot --screenshot-format jpeg --screenshot-quality 80
-```
-
-### Bug Fixes
-
-- Fixed `wait --text` not working in native daemon path
-- Fixed `BrowserManager.navigate()` and package entry point
-- Fixed extensions not being loaded from `config.json`
-- Fixed scroll on page load
-- Fixed HTML retrieval by using `browser.getLocator()` for selector operations
-
----
-
-## v0.18.0
-
-<p className="text-[#888] text-sm">March 12, 2026</p>
-
-### New Features
-
-- **`inspect` command** -- Opens Chrome DevTools for the active page by launching a local proxy server that forwards the DevTools frontend to the browser's CDP WebSocket. Agent commands continue to work while DevTools is open.
-
-```bash
-agent-browser open example.com
-agent-browser inspect          # opens DevTools in your browser
-agent-browser click "Submit"   # commands still work while DevTools is open
-```
-
-- **`get cdp-url` subcommand** -- Retrieve the Chrome DevTools Protocol WebSocket URL for the active page, useful for connecting external debugging tools.
-
-```bash
-agent-browser get cdp-url
-```
-
-- **Screenshot annotate** -- The `--annotate` flag overlays numbered labels on interactive elements in screenshots.
-
-### Improvements
-
-- **KERNEL_API_KEY now optional** -- External credential injection no longer requires `KERNEL_API_KEY` to be set, making it easier to use Kernel with pre-configured environments.
-- **Browserbase simplified** -- Removed the `BROWSERBASE_PROJECT_ID` requirement, reducing setup friction for Browserbase users.
-
-### Bug Fixes
-
-- Fixed Browserbase API using incorrect endpoint to release sessions
-- Fixed CDP connect paths using hardcoded 10s timeout instead of the configurable default timeout
-- Fixed lone Unicode surrogates causing errors by sanitizing with `toWellFormed()`
-- Fixed CDP connection failure on IPv6-first systems
-- Fixed recordings not inheriting the current viewport settings
-
----
-
-## v0.17.1
-
-<p className="text-[#888] text-sm">March 9, 2026</p>
-
-### Improvements
-
-- **Viewport scale factor** -- Added support for device scale factor (retina display) in the viewport command via an optional `scale` parameter.
-- **Webview target support** -- Added webview target type support for better Electron application compatibility. The pages list now includes target type information.
-
----
-
-## v0.17.0
-
-<p className="text-[#888] text-sm">March 8, 2026</p>
-
-### New Features
-
-- **Lightpanda browser engine support** -- Added `--engine <name>` flag to select the browser engine (`chrome` by default, or `lightpanda`), implying `--native` mode. Configurable via `AGENT_BROWSER_ENGINE` environment variable.
-
-```bash
-agent-browser --engine lightpanda open example.com
-```
-
-- **Dialog dismiss command** -- Added support for `dismiss` subcommand in dialog command parsing.
-
-### Improvements
-
-- **Daemon startup error reporting** -- Daemon startup errors are now surfaced directly instead of showing an opaque timeout message.
-- **CDP port discovery** -- Replaced hand-rolled HTTP client with `reqwest` for more reliable CDP port discovery.
-- **Chrome extensions** -- Extensions now load correctly by forcing headed mode when extensions are present.
-- **Google Translate bar suppression** -- Suppressed the Google Translate bar in native headless mode to avoid interference.
-- **Auth cookie persistence** -- Auth cookies are now persisted on browser close in native mode.
-
-### Bug Fixes
-
-- Fixed native auth login failing due to incompatible encryption format.
-
-### Performance
-
-- Added benchmarks to the CLI codebase.
-
----
-
 ## v0.16.0
 
-<p className="text-[#888] text-sm">March 3, 2026</p>
+<p className="text-[#888] text-sm">March 2026</p>
 
 ### New Features
 
@@ -527,7 +62,7 @@ See the [Native Mode](/native-mode) page for full details.
 
 ## v0.15.0
 
-<p className="text-[#888] text-sm">February 25, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### New Features
 
@@ -563,7 +98,7 @@ Six new environment variables for security configuration: `AGENT_BROWSER_CONTENT
 
 ## v0.14.0
 
-<p className="text-[#888] text-sm">February 23, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### New Features
 
@@ -587,7 +122,7 @@ agent-browser --color-scheme dark open https://example.com
 
 ## v0.13.0
 
-<p className="text-[#888] text-sm">February 20, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### New Features
 
@@ -603,7 +138,7 @@ agent-browser diff url https://staging.example.com https://prod.example.com
 
 ## v0.12.0
 
-<p className="text-[#888] text-sm">February 18, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### New Features
 
@@ -617,7 +152,7 @@ agent-browser screenshot --annotate
 
 ## v0.11.1
 
-<p className="text-[#888] text-sm">February 18, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### Documentation
 
@@ -627,7 +162,7 @@ agent-browser screenshot --annotate
 
 ## v0.11.0
 
-<p className="text-[#888] text-sm">February 17, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### New Features
 
@@ -644,7 +179,7 @@ agent-browser screenshot --annotate
 
 ## v0.10.0
 
-<p className="text-[#888] text-sm">February 13, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### New Features
 
@@ -667,7 +202,7 @@ agent-browser state clear myapp
 
 ## v0.9.4
 
-<p className="text-[#888] text-sm">February 13, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### Bug Fixes
 
@@ -677,7 +212,7 @@ agent-browser state clear myapp
 
 ## v0.9.3
 
-<p className="text-[#888] text-sm">February 12, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### Improvements
 
@@ -688,7 +223,7 @@ agent-browser state clear myapp
 
 ## v0.9.2
 
-<p className="text-[#888] text-sm">February 10, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### Improvements
 
@@ -700,7 +235,7 @@ agent-browser state clear myapp
 
 ## v0.9.1
 
-<p className="text-[#888] text-sm">February 5, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### New Features
 
@@ -716,7 +251,7 @@ agent-browser snapshot -C
 
 ## v0.9.0
 
-<p className="text-[#888] text-sm">February 3, 2026</p>
+<p className="text-[#888] text-sm">February 2026</p>
 
 ### New Features
 
@@ -738,7 +273,7 @@ agent-browser swipe up
 
 ## v0.8.10
 
-<p className="text-[#888] text-sm">February 2, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Improvements
 
@@ -749,7 +284,7 @@ agent-browser swipe up
 
 ## v0.8.9
 
-<p className="text-[#888] text-sm">February 2, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Improvements
 
@@ -759,7 +294,7 @@ agent-browser swipe up
 
 ## v0.8.8
 
-<p className="text-[#888] text-sm">February 2, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Improvements
 
@@ -770,7 +305,7 @@ agent-browser swipe up
 
 ## v0.8.7
 
-<p className="text-[#888] text-sm">February 2, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Bug Fixes
 
@@ -782,7 +317,7 @@ agent-browser swipe up
 
 ## v0.8.6
 
-<p className="text-[#888] text-sm">January 31, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Bug Fixes
 
@@ -793,7 +328,7 @@ agent-browser swipe up
 
 ## v0.8.5
 
-<p className="text-[#888] text-sm">January 29, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Bug Fixes
 
@@ -804,7 +339,7 @@ agent-browser swipe up
 
 ## v0.8.4
 
-<p className="text-[#888] text-sm">January 27, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Bug Fixes
 
@@ -814,7 +349,7 @@ agent-browser swipe up
 
 ## v0.8.3
 
-<p className="text-[#888] text-sm">January 27, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Improvements
 
@@ -826,7 +361,7 @@ agent-browser swipe up
 
 ## v0.8.2
 
-<p className="text-[#888] text-sm">January 26, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Bug Fixes
 
@@ -837,7 +372,7 @@ agent-browser swipe up
 
 ## v0.8.1
 
-<p className="text-[#888] text-sm">January 26, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Improvements
 
@@ -848,7 +383,7 @@ agent-browser swipe up
 
 ## v0.8.0
 
-<p className="text-[#888] text-sm">January 26, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### New Features
 
@@ -897,7 +432,7 @@ agent-browser cookies set token "xyz" --domain .example.com --path /api --expire
 
 ## v0.7.1
 
-<p className="text-[#888] text-sm">January 23, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### Bug Fixes
 
@@ -907,7 +442,7 @@ agent-browser cookies set token "xyz" --domain .example.com --path /api --expire
 
 ## v0.7.0
 
-<p className="text-[#888] text-sm">January 23, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### New Features
 
@@ -971,7 +506,7 @@ agent-browser --proxy-bypass "localhost,*.internal" open example.com
 
 ## v0.6.0
 
-<p className="text-[#888] text-sm">January 18, 2026</p>
+<p className="text-[#888] text-sm">January 2026</p>
 
 ### New Features
 

docs/src/app/commands/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("commands");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/commands/page.mdx

@@ -1,15 +1,22 @@
+import { pageMetadata } from '@/lib/page-metadata';
+
+export const metadata = pageMetadata('commands');
+
 # Commands
 
+Executable aliases: `agent-browser`, `agent-browser-stealth`, `abs`.
+
 ## Core
 
 ```bash
 agent-browser open <url>              # Navigate (aliases: goto, navigate)
+agent-browser --risk-mode block open <url>  # Block when verification/captcha interstitial is detected
 agent-browser click <sel>             # Click element (--new-tab to open in new tab)
 agent-browser dblclick <sel>          # Double-click
 agent-browser fill <sel> <text>       # Clear and fill
-agent-browser type <sel> <text>       # Type into element
+agent-browser type <sel> <text> [--delay <ms>]  # Type into element
 agent-browser press <key>             # Press key (Enter, Tab, Control+a) (alias: key)
-agent-browser keyboard type <text>    # Type at current focus (no selector needed)
+agent-browser keyboard type <text> [--delay <ms>]  # Type at current focus (no selector needed)
 agent-browser keyboard inserttext <text>  # Insert text without key events
 agent-browser keydown <key>           # Hold key down
 agent-browser keyup <key>             # Release key
@@ -24,17 +31,19 @@ agent-browser drag <src> <dst>        # Drag and drop
 agent-browser upload <sel> <files>    # Upload files
 agent-browser screenshot [path]       # Screenshot (--full for full page)
 agent-browser screenshot --annotate   # Annotated screenshot with numbered element labels
-agent-browser screenshot --screenshot-dir ./shots    # Save to custom directory
-agent-browser screenshot --screenshot-format jpeg --screenshot-quality 80
 agent-browser pdf <path>              # Save page as PDF
 agent-browser snapshot                # Accessibility tree with refs
 agent-browser eval <js>               # Run JavaScript
 agent-browser connect <port|url>      # Connect to browser via CDP
-agent-browser stream enable [--port <port>]  # Start runtime WebSocket streaming
-agent-browser stream status           # Show runtime streaming state and bound port
-agent-browser stream disable          # Stop runtime WebSocket streaming
+agent-browser doctor                  # Diagnose CDP + sourceURL + tab-group plugin health
+agent-browser --version               # Show CLI version
 agent-browser close                   # Close browser (aliases: quit, exit)
-agent-browser close --all             # Close all active sessions
+```
+
+Fork builds print dual-version metadata with `--version`:
+
+```bash
+agent-browser 0.14.0-fork.1 (upstream 0.14.0, fork 1)
 ```
 
 ## Get info
@@ -46,7 +55,6 @@ agent-browser get value <sel>         # Get input value
 agent-browser get attr <sel> <attr>   # Get attribute
 agent-browser get title               # Get page title
 agent-browser get url                 # Get current URL
-agent-browser get cdp-url             # Get CDP WebSocket URL
 agent-browser get count <sel>         # Count matching elements
 agent-browser get box <sel>           # Get bounding box
 agent-browser get styles <sel>        # Get computed styles
@@ -98,13 +106,22 @@ agent-browser find nth 2 ".card" hover
 ```bash
 agent-browser wait <selector>         # Wait for element
 agent-browser wait <ms>               # Wait for time
-agent-browser wait --text "Welcome"   # Wait for text (substring match)
+agent-browser wait 2000-5000          # Random wait between 2-5 seconds
+agent-browser wait --text "Welcome"   # Wait for text
 agent-browser wait --url "**/dash"    # Wait for URL pattern
 agent-browser wait --load networkidle # Wait for load state
 agent-browser wait --fn "condition"   # Wait for JS condition
 agent-browser wait --download [path]  # Wait for download
-agent-browser wait --fn "!document.body.innerText.includes('Loading...')"  # Wait for text to disappear
-agent-browser wait "#spinner" --state hidden           # Wait for element to disappear
+```
+
+## Risk Mode
+
+Control how `open`/`navigate` handles verification or captcha interstitials:
+
+```bash
+agent-browser --risk-mode warn open https://example.com   # default: wait for auto-clear, then retry/warn with riskSignals
+agent-browser --risk-mode block open https://example.com  # fail fast on detection
+agent-browser --risk-mode off open https://example.com    # disable detection/retry
 ```
 
 ## Downloads
@@ -116,6 +133,32 @@ agent-browser wait --download [path]  # Wait for any download to complete
 
 Use `--download-path <dir>` (or `AGENT_BROWSER_DOWNLOAD_PATH` env) to set a default download directory. Without it, downloads go to a temporary directory that is deleted when the browser closes.
 
+## Tab grouping
+
+```bash
+agent-browser open https://example.com
+# CDP mode groups tabs when tab-group plugin is installed
+
+# Override the default group title
+agent-browser --tab-group "My Agent Group" open https://example.com
+```
+
+CDP mode uses a browser extension handshake to group tabs.
+
+- Extension available: tabs are grouped by `session`.
+- Extension missing/unavailable: silent no-op (commands still succeed).
+- Default titles:
+  - `default` session: `Agent Browser Stealth`
+  - non-default: `Agent Browser Stealth • <session>`
+- Extension side panel (`agent-browser-stealth`) also provides:
+  - Session window isolation and deterministic group colors.
+  - `Keep Only This`, `Focus`, `Clean Empty Groups` quick actions.
+  - Toggle switches for strict isolation / activation guard / auto-clean.
+  - Session allowlist editing (domain fallback to `about:blank` when violated).
+  - Download routing to `agent-browser-stealth/<session>/...`.
+- Use `--tab-group` / `AGENT_BROWSER_TAB_GROUP` for base title.
+- Use `AGENT_BROWSER_TAB_GROUP_PLUGIN_ID` (or `--tab-group-plugin-id`) to override expected extension ID.
+
 ## Mouse
 
 ```bash
@@ -125,19 +168,10 @@ agent-browser mouse up [button]       # Release button
 agent-browser mouse wheel <dy> [dx]   # Scroll wheel
 ```
 
-## Clipboard
-
-```bash
-agent-browser clipboard read                      # Read text from clipboard
-agent-browser clipboard write "Hello, World!"     # Write text to clipboard
-agent-browser clipboard copy                      # Copy current selection (Ctrl+C)
-agent-browser clipboard paste                     # Paste from clipboard (Ctrl+V)
-```
-
 ## Settings
 
 ```bash
-agent-browser set viewport <w> <h> [scale]  # Set viewport size (scale for retina, e.g. 2)
+agent-browser set viewport <w> <h>    # Set viewport size
 agent-browser set device <name>       # Emulate device ("iPhone 14")
 agent-browser set geo <lat> <lng>     # Set geolocation
 agent-browser set offline [on|off]    # Toggle offline mode
@@ -167,6 +201,14 @@ agent-browser storage local clear     # Clear all
 agent-browser storage session         # Same for sessionStorage
 ```
 
+For `cookies set`, use one of these patterns:
+
+- `--url <url>`
+- `--domain <domain> --path <path>`
+- omit all three to scope from the current page URL
+
+When `--url` is omitted, `--domain` and `--path` must be provided together.
+
 ## Network
 
 ```bash
@@ -177,12 +219,6 @@ agent-browser network unroute [url]            # Remove routes
 agent-browser network requests                 # View tracked requests
 agent-browser network requests --clear         # Clear request log
 agent-browser network requests --filter <pat>  # Filter by URL pattern
-agent-browser network requests --type xhr,fetch  # Filter by resource type
-agent-browser network requests --method POST   # Filter by HTTP method
-agent-browser network requests --status 2xx    # Filter by status (200, 2xx, 400-499)
-agent-browser network request <requestId>      # View full request/response detail
-agent-browser network har start                # Start HAR recording
-agent-browser network har stop [output.har]    # Stop and save HAR (temp path if omitted)
 ```
 
 ## Tabs & frames
@@ -193,58 +229,17 @@ agent-browser tab new [url]           # New tab
 agent-browser tab <n>                 # Switch to tab
 agent-browser tab close [n]           # Close tab
 agent-browser window new              # Open new browser window
-agent-browser frame <sel>             # Switch to iframe by CSS selector
-agent-browser frame @e3               # Switch to iframe by element ref
+agent-browser frame <sel>             # Switch to iframe
 agent-browser frame main              # Back to main frame
 ```
 
-### Iframe support
-
-Iframes are detected automatically during snapshots. `Iframe` nodes are resolved and their content is
-inlined beneath the iframe element in the snapshot output. Refs assigned to elements inside iframes carry
-frame context, so `click`, `fill`, and other interactions work without manually switching frames.
-
-```bash
-agent-browser snapshot -i
-# @e3 [Iframe] "payment-frame"
-#   @e4 [input] "Card number"
-#   @e5 [button] "Pay"
-
-# Interact directly using refs — no frame switch needed
-agent-browser fill @e4 "4111111111111111"
-agent-browser click @e5
-
-# Or switch frame context for scoped snapshots
-agent-browser frame @e3
-agent-browser snapshot -i             # Only elements inside that iframe
-agent-browser frame main              # Return to main frame
-```
-
-The `frame` command accepts element refs (`@e3`), CSS selectors (`"#my-iframe"`), or frame name/URL.
-
 ## Dialogs
 
 ```bash
 agent-browser dialog accept [text]    # Accept dialog (with optional prompt text)
 agent-browser dialog dismiss          # Dismiss dialog
-agent-browser dialog status           # Check if a dialog is currently open
 ```
 
-By default, `alert` and `beforeunload` dialogs are automatically accepted so they never block the agent. `confirm` and `prompt` dialogs still require explicit handling. Use `--no-auto-dialog` (or `AGENT_BROWSER_NO_AUTO_DIALOG=1`) to disable automatic handling.
-
-When a JavaScript dialog (`alert`, `confirm`, `prompt`) is pending, all command responses include a `warning` field with the dialog type and message.
-
-## Streaming
-
-```bash
-agent-browser stream enable           # Start runtime WebSocket streaming on an auto-selected port
-agent-browser stream enable --port 9223  # Bind a specific localhost port
-agent-browser stream status           # Show enabled state, port, browser connection, screencasting
-agent-browser stream disable          # Stop runtime streaming and remove the .stream metadata file
-```
-
-Streaming is enabled automatically for all sessions. Use these commands to check status, re-enable on a specific port, or disable streaming.
-
 ## Debug
 
 ```bash
@@ -256,57 +251,12 @@ agent-browser record start <path>     # Start video recording (WebM)
 agent-browser record stop             # Stop and save video
 agent-browser record restart <path>   # Stop current and start new recording
 agent-browser console                 # View console messages
-agent-browser console --json          # JSON output with raw CDP args
 agent-browser console --clear         # Clear console log
 agent-browser errors                  # View page errors
 agent-browser errors --clear          # Clear error log
 agent-browser highlight <sel>         # Highlight element
-agent-browser inspect                 # Open Chrome DevTools for the active page
-```
-
-## Auth vault
-
-```bash
-agent-browser auth save <name> [opts]    # Save auth profile
-agent-browser auth login <name>          # Login using saved credentials
-agent-browser auth list                  # List saved profiles (names and URLs only)
-agent-browser auth show <name>           # Show profile metadata (no passwords)
-agent-browser auth delete <name>         # Delete a saved profile
-```
-
-Save options:
-
-- `--url <url>` -- login page URL (required)
-- `--username <user>` -- username (required)
-- `--password <pass>` -- password (required unless `--password-stdin`)
-- `--password-stdin` -- read password from stdin (recommended to avoid shell history exposure)
-- `--username-selector <sel>` -- custom CSS selector for username field
-- `--password-selector <sel>` -- custom CSS selector for password field
-- `--submit-selector <sel>` -- custom CSS selector for submit button
-
-`auth login` navigates with `load` and then waits for the username/password/submit selectors to appear before interacting. This improves reliability on SPA login pages where fields render after initial page load.
-
-```bash
-echo "pass" | agent-browser auth save github --url https://github.com/login --username user --password-stdin
-agent-browser auth login github
-agent-browser auth list
-```
-
-## Confirmation
-
-When `--confirm-actions` is set, certain action categories return a `confirmation_required` response instead of executing immediately. Use `confirm` or `deny` to approve or reject the action.
-
-```bash
-agent-browser confirm <confirmation-id>  # Approve a pending action
-agent-browser deny <confirmation-id>     # Deny a pending action
-```
-
-Pending confirmations auto-deny after 60 seconds.
-
-```bash
-agent-browser --confirm-actions eval,download eval "document.title"
-# Returns confirmation_required with ID
-agent-browser confirm c_8f3a1234
+agent-browser doctor                  # Diagnose CDP + sourceURL + plugin handshake status
+pnpm run check:turnstile-testkey      # Deterministic Turnstile smoke check (official test key)
 ```
 
 ## State management
@@ -329,15 +279,6 @@ agent-browser session                 # Show current session name
 agent-browser session list            # List active sessions
 ```
 
-## Dashboard
-
-```bash
-agent-browser dashboard [start]       # Start the dashboard server (default port: 4848)
-agent-browser dashboard start --port <n>  # Start on a specific port
-agent-browser dashboard stop          # Stop the dashboard server
-agent-browser dashboard install       # Install the dashboard files
-```
-
 ## Navigation
 
 ```bash
@@ -350,8 +291,7 @@ agent-browser reload                  # Reload page
 
 ```bash
 --session <name>         # Isolated browser session
---session-name <name>    # Auto-save/restore session state (cookies, localStorage)
---profile <path>         # Persistent browser profile directory
+--session-name <name>    # Auto-save/restore session state (defaults to --session when omitted)
 --state <path>           # Load storage state from JSON file
 --headers <json>         # HTTP headers scoped to URL's origin
 --executable-path <path> # Custom browser executable
@@ -362,54 +302,21 @@ agent-browser reload                  # Reload page
 --proxy-bypass <hosts>   # Hosts to bypass proxy
 --ignore-https-errors    # Ignore HTTPS certificate errors
 --allow-file-access      # Allow file:// URLs to access local files (Chromium only)
--p, --provider <name>    # Browser provider (ios, browserbase, kernel, browseruse, browserless)
+--stealth                # Stealth mode (always on by default)
+-p, --provider <name>    # Browser provider (ios, browserbase, kernel, browseruse)
 --device <name>          # iOS device name (e.g., "iPhone 15 Pro")
 --json                   # JSON output (for scripts)
+--full, -f               # Full page screenshot
 --annotate               # Annotated screenshot with numbered element labels
---screenshot-dir <path>   # Default screenshot output directory (or AGENT_BROWSER_SCREENSHOT_DIR)
---screenshot-quality <n>  # JPEG quality 0-100 (or AGENT_BROWSER_SCREENSHOT_QUALITY)
---screenshot-format <fmt> # Format: png (default), jpeg (or AGENT_BROWSER_SCREENSHOT_FORMAT)
 --headed                 # Show browser window (not headless)
 --cdp <port|url>         # Connect via Chrome DevTools Protocol (port or WebSocket URL)
 --auto-connect           # Auto-discover and connect to running Chrome
---color-scheme <scheme>  # Color scheme: dark, light, no-preference
---download-path <path>   # Default download directory
---content-boundaries     # Wrap page output in boundary markers for LLM safety
---max-output <chars>     # Truncate page output to N characters
---allowed-domains <list> # Comma-separated allowed domain patterns
---action-policy <path>   # Path to action policy JSON file
---confirm-actions <list> # Action categories requiring confirmation
---confirm-interactive    # Interactive confirmation prompts (auto-denies if stdin is not a TTY)
---config <path>          # Use a custom config file
---debug                  # Debug output
+--tab-group <name>       # Base title for agent tab groups (CDP plugin mode)
+--tab-group-plugin-id <id> # Expected extension ID for tab-group handshake
+--wait-until <mode>      # Navigation wait strategy for open/navigate (load, domcontentloaded, networkidle)
+--debug                  # Debug output (includes stealth connection type + capabilities)
 ```
 
-## Batch execution
-
-Execute multiple commands in a single invocation by piping a JSON array of string arrays to `batch`:
-
-```bash
-echo '[
-  ["open", "https://example.com"],
-  ["snapshot", "-i"],
-  ["click", "@e1"],
-  ["screenshot", "result.png"]
-]' | agent-browser batch --json
-
-# Stop on first error
-agent-browser batch --bail < commands.json
-```
-
-<table>
-  <thead>
-    <tr><th>Option</th><th>Description</th></tr>
-  </thead>
-  <tbody>
-    <tr><td><code>--bail</code></td><td>Stop on first error (default: continue all commands)</td></tr>
-    <tr><td><code>--json</code></td><td>Output results as a JSON array</td></tr>
-  </tbody>
-</table>
-
 ## Command chaining
 
 Chain commands with `&&` in a single shell invocation. The browser persists via a background daemon, so chaining works naturally and is more efficient than separate calls:

docs/src/app/configuration/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("configuration");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/configuration/page.mdx

@@ -1,20 +1,52 @@
+import { pageMetadata } from '@/lib/page-metadata';
+
+export const metadata = pageMetadata('configuration');
+
 # Configuration
 
 Create an `agent-browser.json` file to set persistent defaults instead of repeating flags on every command.
 
+In this fork, default launch behavior auto-attaches to an existing browser by trying `localhost:9333` (CDP) first, then auto-discovery. If both fail, commands exit instead of launching a managed browser.
+
 ## Config File Locations
 
 agent-browser checks two locations, merged in priority order:
 
 <table>
   <thead>
-    <tr><th>Priority</th><th>Location</th><th>Scope</th></tr>
+    <tr>
+      <th>Priority</th>
+      <th>Location</th>
+      <th>Scope</th>
+    </tr>
   </thead>
   <tbody>
-    <tr><td>1 (lowest)</td><td><code>~/.agent-browser/config.json</code></td><td>User-level defaults</td></tr>
-    <tr><td>2</td><td><code>./agent-browser.json</code></td><td>Project-level overrides</td></tr>
-    <tr><td>3</td><td><code>AGENT_BROWSER_*</code> env vars</td><td>Override config values</td></tr>
-    <tr><td>4 (highest)</td><td>CLI flags</td><td>Override everything</td></tr>
+    <tr>
+      <td>1 (lowest)</td>
+      <td>
+        <code>~/.agent-browser/config.json</code>
+      </td>
+      <td>User-level defaults</td>
+    </tr>
+    <tr>
+      <td>2</td>
+      <td>
+        <code>./agent-browser.json</code>
+      </td>
+      <td>Project-level overrides</td>
+    </tr>
+    <tr>
+      <td>3</td>
+      <td>
+        <code>AGENT_BROWSER_*</code> env vars
+      </td>
+      <td>Override config values</td>
+    </tr>
+    <tr>
+      <td>4 (highest)</td>
+      <td>CLI flags</td>
+      <td>Override everything</td>
+    </tr>
   </tbody>
 </table>
 
@@ -33,7 +65,6 @@ AGENT_BROWSER_CONFIG=./ci-config.json agent-browser open example.com
 {
   "headed": true,
   "proxy": "http://localhost:8080",
-  "profile": "./browser-data",
   "userAgent": "my-agent/1.0",
   "ignoreHttpsErrors": true
 }
@@ -45,43 +76,253 @@ Every CLI flag can be set in the config file using its camelCase equivalent:
 
 <table>
   <thead>
-    <tr><th>Config Key</th><th>CLI Flag</th><th>Type</th></tr>
+    <tr>
+      <th>Config Key</th>
+      <th>CLI Flag</th>
+      <th>Type</th>
+    </tr>
   </thead>
   <tbody>
-    <tr><td><code>headed</code></td><td><code>--headed</code></td><td>boolean</td></tr>
-    <tr><td><code>json</code></td><td><code>--json</code></td><td>boolean</td></tr>
-    <tr><td><code>full</code></td><td><code>--full, -f</code></td><td>boolean</td></tr>
-    <tr><td><code>debug</code></td><td><code>--debug</code></td><td>boolean</td></tr>
-    <tr><td><code>session</code></td><td><code>--session</code></td><td>string</td></tr>
-    <tr><td><code>sessionName</code></td><td><code>--session-name</code></td><td>string</td></tr>
-    <tr><td><code>executablePath</code></td><td><code>--executable-path</code></td><td>string</td></tr>
-    <tr><td><code>extensions</code></td><td><code>--extension</code></td><td>string[]</td></tr>
-    <tr><td><code>profile</code></td><td><code>--profile</code></td><td>string</td></tr>
-    <tr><td><code>state</code></td><td><code>--state</code></td><td>string</td></tr>
-    <tr><td><code>proxy</code></td><td><code>--proxy</code></td><td>string</td></tr>
-    <tr><td><code>proxyBypass</code></td><td><code>--proxy-bypass</code></td><td>string</td></tr>
-    <tr><td><code>args</code></td><td><code>--args</code></td><td>string</td></tr>
-    <tr><td><code>userAgent</code></td><td><code>--user-agent</code></td><td>string</td></tr>
-    <tr><td><code>provider</code></td><td><code>-p, --provider</code></td><td>string</td></tr>
-    <tr><td><code>device</code></td><td><code>--device</code></td><td>string</td></tr>
-    <tr><td><code>ignoreHttpsErrors</code></td><td><code>--ignore-https-errors</code></td><td>boolean</td></tr>
-    <tr><td><code>allowFileAccess</code></td><td><code>--allow-file-access</code></td><td>boolean</td></tr>
-    <tr><td><code>cdp</code></td><td><code>--cdp</code></td><td>string</td></tr>
-    <tr><td><code>autoConnect</code></td><td><code>--auto-connect</code></td><td>boolean</td></tr>
-    <tr><td><code>colorScheme</code></td><td><code>--color-scheme</code></td><td>string (<code>dark</code>, <code>light</code>, <code>no-preference</code>)</td></tr>
-    <tr><td><code>downloadPath</code></td><td><code>--download-path</code></td><td>string</td></tr>
-    <tr><td><code>contentBoundaries</code></td><td><code>--content-boundaries</code></td><td>boolean</td></tr>
-    <tr><td><code>maxOutput</code></td><td><code>--max-output</code></td><td>number</td></tr>
-    <tr><td><code>allowedDomains</code></td><td><code>--allowed-domains</code></td><td>string[]</td></tr>
-    <tr><td><code>actionPolicy</code></td><td><code>--action-policy</code></td><td>string</td></tr>
-    <tr><td><code>confirmActions</code></td><td><code>--confirm-actions</code></td><td>string</td></tr>
-    <tr><td><code>confirmInteractive</code></td><td><code>--confirm-interactive</code></td><td>boolean</td></tr>
-    <tr><td><code>engine</code></td><td><code>--engine</code></td><td>string (<code>chrome</code>, <code>lightpanda</code>)</td></tr>
-    <tr><td><code>noAutoDialog</code></td><td><code>--no-auto-dialog</code></td><td>boolean</td></tr>
-    <tr><td><code>headers</code></td><td><code>--headers</code></td><td>string (JSON)</td></tr>
+    <tr>
+      <td>
+        <code>headed</code>
+      </td>
+      <td>
+        <code>--headed</code>
+      </td>
+      <td>boolean</td>
+    </tr>
+    <tr>
+      <td>
+        <code>json</code>
+      </td>
+      <td>
+        <code>--json</code>
+      </td>
+      <td>boolean</td>
+    </tr>
+    <tr>
+      <td>
+        <code>full</code>
+      </td>
+      <td>
+        <code>--full, -f</code>
+      </td>
+      <td>boolean</td>
+    </tr>
+    <tr>
+      <td>
+        <code>debug</code>
+      </td>
+      <td>
+        <code>--debug</code>
+      </td>
+      <td>boolean</td>
+    </tr>
+    <tr>
+      <td>
+        <code>session</code>
+      </td>
+      <td>
+        <code>--session</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>sessionName</code>
+      </td>
+      <td>
+        <code>--session-name</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>executablePath</code>
+      </td>
+      <td>
+        <code>--executable-path</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>extensions</code>
+      </td>
+      <td>
+        <code>--extension</code>
+      </td>
+      <td>string[]</td>
+    </tr>
+    <tr>
+      <td>
+        <code>state</code>
+      </td>
+      <td>
+        <code>--state</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>proxy</code>
+      </td>
+      <td>
+        <code>--proxy</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>proxyBypass</code>
+      </td>
+      <td>
+        <code>--proxy-bypass</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>args</code>
+      </td>
+      <td>
+        <code>--args</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>userAgent</code>
+      </td>
+      <td>
+        <code>--user-agent</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>provider</code>
+      </td>
+      <td>
+        <code>-p, --provider</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>device</code>
+      </td>
+      <td>
+        <code>--device</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>ignoreHttpsErrors</code>
+      </td>
+      <td>
+        <code>--ignore-https-errors</code>
+      </td>
+      <td>boolean</td>
+    </tr>
+    <tr>
+      <td>
+        <code>allowFileAccess</code>
+      </td>
+      <td>
+        <code>--allow-file-access</code>
+      </td>
+      <td>boolean</td>
+    </tr>
+    <tr>
+      <td>
+        <code>cdp</code>
+      </td>
+      <td>
+        <code>--cdp</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>autoConnect</code>
+      </td>
+      <td>
+        <code>--auto-connect</code>
+      </td>
+      <td>boolean</td>
+    </tr>
+    <tr>
+      <td>
+        <code>colorScheme</code>
+      </td>
+      <td>
+        <code>--color-scheme</code>
+      </td>
+      <td>
+        string (<code>dark</code>, <code>light</code>, <code>no-preference</code>)
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>downloadPath</code>
+      </td>
+      <td>
+        <code>--download-path</code>
+      </td>
+      <td>string</td>
+    </tr>
+    <tr>
+      <td>
+        <code>tabGroup</code>
+      </td>
+      <td>
+        <code>--tab-group</code>
+      </td>
+      <td>string (base title for session tab grouping via CDP plugin handshake)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>tabGroupPluginId</code>
+      </td>
+      <td>
+        <code>--tab-group-plugin-id</code>
+      </td>
+      <td>string (expected extension ID for tab-group plugin handshake)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>riskMode</code>
+      </td>
+      <td>
+        <code>--risk-mode</code>
+      </td>
+      <td>
+        string (<code>off</code>, <code>warn</code>, <code>block</code>)
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>headers</code>
+      </td>
+      <td>
+        <code>--headers</code>
+      </td>
+      <td>string (JSON)</td>
+    </tr>
   </tbody>
 </table>
 
+`riskMode` defaults to `warn` when unset.
+
+For tab grouping in CDP mode, grouping is best-effort through the extension handshake:
+extension available => grouped by session; extension missing/unavailable => silent no-op.
+
+With the `agent-browser-stealth` extension installed, the side panel also exposes
+session window isolation controls, activation guard toggles, empty-group cleanup, and per-session allowlist policy editing.
+
 ## Common Configurations
 
 ### Local Development
@@ -89,7 +330,7 @@ Every CLI flag can be set in the config file using its camelCase equivalent:
 ```json
 {
   "headed": true,
-  "profile": "./browser-data"
+  "sessionName": "local-dev"
 }
 ```
 
@@ -121,17 +362,6 @@ Every CLI flag can be set in the config file using its camelCase equivalent:
 }
 ```
 
-### AI Agent Security
-
-```json
-{
-  "contentBoundaries": true,
-  "maxOutput": 50000,
-  "allowedDomains": ["your-app.com", "*.your-app.com"],
-  "actionPolicy": "./policy.json"
-}
-```
-
 ## Overriding Boolean Options
 
 Boolean flags accept an optional `true`/`false` value to override config settings:
@@ -147,7 +377,7 @@ agent-browser --headed open example.com       # same as --headed true
 agent-browser --headed true open example.com  # explicit
 ```
 
-This applies to all boolean flags: `--headed`, `--debug`, `--json`, `--ignore-https-errors`, `--allow-file-access`, `--auto-connect`, `--content-boundaries`, `--confirm-interactive`.
+This applies to all boolean flags: `--headed`, `--debug`, `--json`, `--ignore-https-errors`, `--allow-file-access`, `--auto-connect`.
 
 ## Extensions Merging
 
@@ -161,32 +391,148 @@ These environment variables configure additional daemon and runtime behavior:
 
 <table>
   <thead>
-    <tr><th>Variable</th><th>Description</th><th>Default</th></tr>
+    <tr>
+      <th>Variable</th>
+      <th>Description</th>
+      <th>Default</th>
+    </tr>
   </thead>
   <tbody>
-    <tr><td><code>AGENT_BROWSER_AUTO_CONNECT</code></td><td>Auto-discover and connect to a running Chrome instance.</td><td>(disabled)</td></tr>
-    <tr><td><code>AGENT_BROWSER_ALLOW_FILE_ACCESS</code></td><td>Allow <code>file://</code> URLs to access local files.</td><td>(disabled)</td></tr>
-    <tr><td><code>AGENT_BROWSER_COLOR_SCHEME</code></td><td>Color scheme preference (<code>dark</code>, <code>light</code>, <code>no-preference</code>).</td><td>(none)</td></tr>
-    <tr><td><code>AGENT_BROWSER_DOWNLOAD_PATH</code></td><td>Default directory for browser downloads.</td><td>(temp directory)</td></tr>
-    <tr><td><code>AGENT_BROWSER_DEFAULT_TIMEOUT</code></td><td>Default timeout in ms. Keep below 30000 to avoid IPC timeouts.</td><td><code>25000</code></td></tr>
-    <tr><td><code>AGENT_BROWSER_SESSION_NAME</code></td><td>Auto-save/load state persistence name.</td><td>(none)</td></tr>
-    <tr><td><code>AGENT_BROWSER_STATE_EXPIRE_DAYS</code></td><td>Auto-delete saved session states older than N days.</td><td><code>30</code></td></tr>
-    <tr><td><code>AGENT_BROWSER_ENCRYPTION_KEY</code></td><td>64-char hex key for AES-256-GCM session encryption.</td><td>(none)</td></tr>
-    <tr><td><code>AGENT_BROWSER_EXTENSIONS</code></td><td>Comma-separated browser extension paths. Extensions work in both headed and headless mode.</td><td>(none)</td></tr>
-    <tr><td><code>AGENT_BROWSER_HEADED</code></td><td>Show browser window instead of running headless (<code>1</code> to enable).</td><td>(disabled)</td></tr>
-    <tr><td><code>AGENT_BROWSER_STREAM_PORT</code></td><td>Override the WebSocket streaming port. By default, an OS-assigned port is used. Set this to bind to a specific port (e.g., <code>9223</code>).</td><td>OS-assigned</td></tr>
-    <tr><td><code>AGENT_BROWSER_IDLE_TIMEOUT_MS</code></td><td>Auto-shutdown the daemon after N ms of inactivity (no commands received). Useful for ephemeral environments.</td><td>(disabled)</td></tr>
-    <tr><td><code>AGENT_BROWSER_IOS_DEVICE</code></td><td>Default iOS device name for the <code>ios</code> provider.</td><td>(none)</td></tr>
-    <tr><td><code>AGENT_BROWSER_IOS_UDID</code></td><td>Default iOS device UDID for the <code>ios</code> provider.</td><td>(none)</td></tr>
-    <tr><td><code>AGENT_BROWSER_DEBUG</code></td><td>Enable debug output (<code>1</code> to enable).</td><td>(disabled)</td></tr>
-    <tr><td><code>AGENT_BROWSER_CONTENT_BOUNDARIES</code></td><td>Wrap page output in boundary markers for LLM safety.</td><td>(disabled)</td></tr>
-    <tr><td><code>AGENT_BROWSER_MAX_OUTPUT</code></td><td>Max characters for page output (truncates beyond limit).</td><td>(unlimited)</td></tr>
-    <tr><td><code>AGENT_BROWSER_ALLOWED_DOMAINS</code></td><td>Comma-separated allowed domain patterns (e.g., <code>example.com,*.example.com</code>).</td><td>(unrestricted)</td></tr>
-    <tr><td><code>AGENT_BROWSER_ACTION_POLICY</code></td><td>Path to action policy JSON file.</td><td>(none)</td></tr>
-    <tr><td><code>AGENT_BROWSER_CONFIRM_ACTIONS</code></td><td>Comma-separated action categories requiring confirmation.</td><td>(none)</td></tr>
-    <tr><td><code>AGENT_BROWSER_CONFIRM_INTERACTIVE</code></td><td>Enable interactive confirmation prompts (auto-denies if stdin is not a TTY).</td><td>(disabled)</td></tr>
-    <tr><td><code>AGENT_BROWSER_ENGINE</code></td><td>Browser engine to use: <code>chrome</code> (default), <code>lightpanda</code>.</td><td><code>chrome</code></td></tr>
-    <tr><td><code>AGENT_BROWSER_NO_AUTO_DIALOG</code></td><td>Disable automatic dismissal of <code>alert</code>/<code>beforeunload</code> dialogs.</td><td>(disabled)</td></tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_AUTO_CONNECT</code>
+      </td>
+      <td>Auto-discover and connect to a running Chrome instance.</td>
+      <td>(disabled)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_ALLOW_FILE_ACCESS</code>
+      </td>
+      <td>
+        Allow <code>file://</code> URLs to access local files.
+      </td>
+      <td>(disabled)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_COLOR_SCHEME</code>
+      </td>
+      <td>
+        Color scheme preference (<code>dark</code>, <code>light</code>, <code>no-preference</code>).
+      </td>
+      <td>(none)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_DOWNLOAD_PATH</code>
+      </td>
+      <td>Default directory for browser downloads.</td>
+      <td>(temp directory)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_TAB_GROUP</code>
+      </td>
+      <td>Base title for tab grouping. Session suffix is appended automatically in CDP mode.</td>
+      <td>
+        <code>Agent Browser Stealth</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_TAB_GROUP_PLUGIN_ID</code>
+      </td>
+      <td>Expected extension ID for CDP tab-group plugin handshake.</td>
+      <td>
+        <code>aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_RISK_MODE</code>
+      </td>
+      <td>
+        Verification/captcha handling mode (<code>off</code>, <code>warn</code>, <code>block</code>
+        ).
+      </td>
+      <td>
+        <code>warn</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_DEFAULT_TIMEOUT</code>
+      </td>
+      <td>Default Playwright timeout in ms. Keep below 30000 to avoid IPC timeouts.</td>
+      <td>
+        <code>25000</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_SESSION_NAME</code>
+      </td>
+      <td>
+        Auto-save/load state persistence name (defaults to <code>AGENT_BROWSER_SESSION</code> when
+        unset).
+      </td>
+      <td>
+        (same as <code>AGENT_BROWSER_SESSION</code>)
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_STATE_EXPIRE_DAYS</code>
+      </td>
+      <td>Auto-delete saved session states older than N days.</td>
+      <td>
+        <code>30</code>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_ENCRYPTION_KEY</code>
+      </td>
+      <td>64-char hex key for AES-256-GCM session encryption.</td>
+      <td>(none)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_STREAM_PORT</code>
+      </td>
+      <td>
+        Enable WebSocket streaming on the specified port (e.g., <code>9223</code>).
+      </td>
+      <td>(disabled)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_IOS_DEVICE</code>
+      </td>
+      <td>
+        Default iOS device name for the <code>ios</code> provider.
+      </td>
+      <td>(none)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_IOS_UDID</code>
+      </td>
+      <td>
+        Default iOS device UDID for the <code>ios</code> provider.
+      </td>
+      <td>(none)</td>
+    </tr>
+    <tr>
+      <td>
+        <code>AGENT_BROWSER_DEBUG</code>
+      </td>
+      <td>
+        Enable debug output (<code>1</code> to enable).
+      </td>
+      <td>(disabled)</td>
+    </tr>
   </tbody>
 </table>
 

docs/src/app/dashboard/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("dashboard");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/dashboard/page.mdx

@@ -1,137 +0,0 @@
-# Observability Dashboard
-
-Monitor agent-browser sessions in real time with a local web dashboard showing a live browser viewport and command activity feed.
-
-## Install
-
-Download the dashboard once:
-
-```bash
-agent-browser dashboard install
-```
-
-This downloads the dashboard to `~/.agent-browser/dashboard/` and is served directly by the daemon when streaming is enabled.
-
-## Usage
-
-Start the dashboard server and open any session -- it appears automatically:
-
-```bash
-agent-browser dashboard start
-agent-browser open example.com
-```
-
-Then open `http://localhost:4848` in your browser to see the live dashboard.
-
-All sessions automatically stream to the dashboard. No extra flags are needed.
-
-### Custom stream port
-
-By default each session binds its WebSocket stream server to an OS-assigned port. To use a specific port, set the `AGENT_BROWSER_STREAM_PORT` environment variable:
-
-```bash
-AGENT_BROWSER_STREAM_PORT=9223 agent-browser open example.com
-```
-
-You can also use the runtime commands to control streaming on a running session:
-
-```bash
-agent-browser stream enable --port 9223
-agent-browser stream status
-agent-browser stream disable
-```
-
-## Dashboard features
-
-The dashboard is a single-page web app with three areas:
-
-<table>
-  <thead>
-    <tr>
-      <th>Area</th>
-      <th>Description</th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><strong>Live viewport</strong></td>
-      <td>Real-time JPEG frames from the browser, rendered to a canvas element</td>
-    </tr>
-    <tr>
-      <td><strong>Activity feed</strong></td>
-      <td>Chronological stream of commands, results, and console messages with expandable details</td>
-    </tr>
-    <tr>
-      <td><strong>Session creation</strong></td>
-      <td>Create new sessions from the dashboard with local engines (Chrome, Lightpanda) or cloud providers (AgentCore, Browserbase, Browserless, Browser Use, Kernel)</td>
-    </tr>
-    <tr>
-      <td><strong>Status bar</strong></td>
-      <td>Connection status, viewport dimensions, and WebSocket endpoint</td>
-    </tr>
-  </tbody>
-</table>
-
-## WebSocket protocol
-
-The dashboard connects to the same WebSocket endpoint used by [Streaming](/streaming), with additional message types for observability:
-
-### Command events
-
-Sent when a command begins executing:
-
-```json
-{
-  "type": "command",
-  "action": "click",
-  "id": "r123",
-  "params": { "selector": "@e5" },
-  "timestamp": 1711367000000
-}
-```
-
-### Result events
-
-Sent when a command finishes:
-
-```json
-{
-  "type": "result",
-  "id": "r123",
-  "action": "click",
-  "success": true,
-  "data": {},
-  "duration_ms": 45,
-  "timestamp": 1711367000045
-}
-```
-
-### Console events
-
-Sent when the browser logs to the console:
-
-```json
-{
-  "type": "console",
-  "level": "log",
-  "text": "Page loaded",
-  "args": [{"type": "string", "value": "Page loaded"}],
-  "timestamp": 1711367000100
-}
-```
-
-The `args` array contains the raw CDP `Runtime.consoleAPICalled` arguments for programmatic access. Object arguments include preview data (e.g. `{userId: "abc", count: 42}` instead of `"Object"`).
-
-These are in addition to the existing `frame`, `status`, and `error` message types documented on the [Streaming](/streaming) page.
-
-## Architecture
-
-The dashboard is a Next.js static export (`output: 'export'`) that produces plain HTML, CSS, and JS. It lives at `packages/dashboard/` in the monorepo and is built with:
-
-```bash
-pnpm build:dashboard
-```
-
-The built files are served by the daemon's stream server on the same port used for WebSocket connections. Plain HTTP requests serve the dashboard, while WebSocket upgrade requests are handled as before.
-
-When the dashboard is not installed, visiting the HTTP endpoint shows instructions to run `agent-browser dashboard install`.

docs/src/app/diffing/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("diffing");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/diffing/page.mdx

@@ -1,3 +1,7 @@
+import { pageMetadata } from "@/lib/page-metadata"
+
+export const metadata = pageMetadata("diffing")
+
 import { DiffDemo } from "@/components/diff-demo"
 
 # Diffing

docs/src/app/engines/chrome/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("engines/chrome");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/engines/chrome/page.mdx

@@ -1,104 +0,0 @@
-# Chrome
-
-Chrome (and Chromium) is the default browser engine. agent-browser discovers, launches, and manages the Chrome process automatically via the Chrome DevTools Protocol (CDP).
-
-## Binary Discovery
-
-When no `--executable-path` is provided, agent-browser searches for Chrome in this order:
-
-<table>
-  <thead>
-    <tr><th>Platform</th><th>Locations checked</th></tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>macOS</td>
-      <td>
-        <code>/Applications/Google Chrome.app</code>,
-        <code>/Applications/Google Chrome Canary.app</code>,
-        <code>/Applications/Chromium.app</code>,
-        <code>/Applications/Brave Browser.app</code>,
-        Puppeteer cache (<code>~/.cache/puppeteer/chrome/</code> or <code>PUPPETEER_CACHE_DIR</code>),
-        Chrome for Testing cache
-      </td>
-    </tr>
-    <tr>
-      <td>Linux</td>
-      <td>
-        <code>google-chrome</code>,
-        <code>google-chrome-stable</code>,
-        <code>chromium-browser</code>,
-        <code>chromium</code> in PATH,
-        Puppeteer cache (<code>~/.cache/puppeteer/chrome/</code> or <code>PUPPETEER_CACHE_DIR</code>),
-        Chrome for Testing cache
-      </td>
-    </tr>
-    <tr>
-      <td>Windows</td>
-      <td>
-        <code>%LOCALAPPDATA%\Google\Chrome\Application\chrome.exe</code>,
-        <code>C:\Program Files\Google\Chrome\Application\chrome.exe</code>,
-        <code>C:\Program Files (x86)\...\chrome.exe</code>
-      </td>
-    </tr>
-  </tbody>
-</table>
-
-If Chrome is not found, run `agent-browser install` to download Chrome from Chrome for Testing.
-
-## Usage
-
-Chrome is the default engine -- no `--engine` flag is needed:
-
-```bash
-agent-browser open example.com
-```
-
-To be explicit:
-
-```bash
-agent-browser --engine chrome open example.com
-```
-
-## Custom Binary
-
-Point to any Chromium-based browser with `--executable-path`:
-
-```bash
-agent-browser --executable-path /path/to/chromium open example.com
-```
-
-Or via environment variable:
-
-```bash
-export AGENT_BROWSER_EXECUTABLE_PATH=/path/to/chromium
-agent-browser open example.com
-```
-
-## Chrome-Specific Features
-
-These features are available only with Chrome:
-
-<table>
-  <thead>
-    <tr><th>Feature</th><th>Flag</th></tr>
-  </thead>
-  <tbody>
-    <tr><td>Browser extensions</td><td><code>--extension &lt;path&gt;</code></td></tr>
-    <tr><td>Persistent profiles</td><td><code>--profile &lt;path&gt;</code> (sets Chrome's <code>--user-data-dir</code>)</td></tr>
-    <tr><td>Storage state</td><td><code>--state &lt;path&gt;</code></td></tr>
-    <tr><td>File URL access</td><td><code>--allow-file-access</code></td></tr>
-    <tr><td>Headed mode</td><td><code>--headed</code></td></tr>
-    <tr><td>Custom launch args</td><td><code>--args &lt;args&gt;</code></td></tr>
-  </tbody>
-</table>
-
-## Containers and CI
-
-In Docker, CI runners, or other sandboxed environments, Chrome's user namespace sandbox may need to be disabled:
-
-```bash
-agent-browser --args "--no-sandbox" open example.com
-```
-
-agent-browser automatically adds `--no-sandbox` when it detects a container environment (Docker, Podman, running as root).

docs/src/app/engines/lightpanda/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("engines/lightpanda");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/engines/lightpanda/page.mdx

@@ -1,93 +0,0 @@
-# Lightpanda
-
-[Lightpanda](https://lightpanda.io/) is a headless browser engine built from scratch in Zig for machines. It starts instantly, uses 10x less memory than Chrome, and executes 10x faster.
-
-agent-browser manages Lightpanda the same way it manages Chrome -- spawning the process, connecting via CDP, and shutting it down. All downstream commands (snapshot, click, fill, screenshot, etc.) work through the same CDP protocol path.
-
-## Installation
-
-Install the Lightpanda binary before using it with agent-browser:
-
-<table>
-  <thead>
-    <tr><th>Platform</th><th>Command</th></tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td>macOS (Apple Silicon)</td>
-      <td><code>curl -L -o lightpanda https://github.com/lightpanda-io/browser/releases/download/nightly/lightpanda-aarch64-macos && chmod a+x ./lightpanda</code></td>
-    </tr>
-    <tr>
-      <td>Linux (x86_64)</td>
-      <td><code>curl -L -o lightpanda https://github.com/lightpanda-io/browser/releases/download/nightly/lightpanda-x86_64-linux && chmod a+x ./lightpanda</code></td>
-    </tr>
-  </tbody>
-</table>
-
-Move the binary somewhere in your `PATH` (e.g. `/usr/local/bin/lightpanda` or `~/.local/bin/lightpanda`).
-
-See the [Lightpanda installation docs](https://lightpanda.io/docs/open-source/installation) for more options.
-
-## Usage
-
-Use the `--engine` flag to select Lightpanda:
-
-```bash
-agent-browser --engine lightpanda open example.com
-agent-browser --engine lightpanda snapshot
-agent-browser --engine lightpanda screenshot
-```
-
-Or set it as the default via environment variable:
-
-```bash
-export AGENT_BROWSER_ENGINE=lightpanda
-agent-browser open example.com
-```
-
-Or in your `agent-browser.json` config:
-
-```json
-{
-  "engine": "lightpanda"
-}
-```
-
-## Custom Binary Path
-
-If the `lightpanda` binary is not in your `PATH`, use `--executable-path`:
-
-```bash
-agent-browser --engine lightpanda --executable-path /path/to/lightpanda open example.com
-```
-
-## Differences from Chrome
-
-Lightpanda is a purpose-built headless engine. Some Chrome-specific features are not available:
-
-<table>
-  <thead>
-    <tr><th>Feature</th><th>Status</th></tr>
-  </thead>
-  <tbody>
-    <tr><td>Extensions (<code>--extension</code>)</td><td>Not supported</td></tr>
-    <tr><td>Persistent profiles (<code>--profile</code>)</td><td>Not supported</td></tr>
-    <tr><td>Storage state (<code>--state</code>)</td><td>Not supported</td></tr>
-    <tr><td>File access (<code>--allow-file-access</code>)</td><td>Not supported</td></tr>
-    <tr><td>Headed mode (<code>--headed</code>)</td><td>Not applicable (headless only)</td></tr>
-    <tr><td>Screenshots</td><td>Depends on Lightpanda CDP support</td></tr>
-  </tbody>
-</table>
-
-agent-browser returns a clear error if you combine `--engine lightpanda` with unsupported flags.
-
-## When to Use Lightpanda
-
-Lightpanda is a good fit for:
-
-- Fast web scraping and data extraction
-- AI agent workflows where speed and low memory matter
-- CI/CD environments with constrained resources
-- High-volume parallel automation
-
-Use Chrome when you need full browser fidelity, extensions, or persistent profiles.

docs/src/app/globals.css

@@ -16,7 +16,6 @@
   --color-muted-foreground: var(--muted-foreground);
   --color-primary: var(--primary);
   --color-primary-foreground: var(--primary-foreground);
-  --color-sidebar: var(--sidebar);
 }
 
 :root {
@@ -27,7 +26,6 @@
   --muted-foreground: #737373;
   --primary: #171717;
   --primary-foreground: #fff;
-  --sidebar: #f5f5f5;
 }
 
 .dark {
@@ -38,11 +36,10 @@
   --muted-foreground: #a3a3a3;
   --primary: #f5f5f5;
   --primary-foreground: #0a0a0a;
-  --sidebar: #171717;
 }
 
 html {
-  scroll-padding-top: 4rem;
+  scroll-behavior: smooth;
 }
 
 ::selection {
@@ -132,23 +129,6 @@ pre:not(.shiki) {
   font-size: 0.875em;
 }
 
-/* Diff line highlighting */
-.diff-add {
-  color: #00952d;
-}
-
-.diff-remove {
-  color: #f32e40;
-}
-
-.dark .diff-add {
-  color: #00ca50;
-}
-
-.dark .diff-remove {
-  color: #f32e40;
-}
-
 /* Shiki dual theme support */
 .shiki,
 .shiki span {

docs/src/app/installation/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("installation");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/installation/page.mdx

@@ -1,3 +1,7 @@
+import { pageMetadata } from "@/lib/page-metadata"
+
+export const metadata = pageMetadata("installation")
+
 # Installation
 
 ## Global installation (recommended)
@@ -5,50 +9,49 @@
 Installs the native Rust binary for maximum performance:
 
 ```bash
-npm install -g agent-browser
-agent-browser install  # Download Chrome from Chrome for Testing (first time)
+npm install -g agent-browser-stealth
+agent-browser install  # Download Chromium
 ```
 
 This is the fastest option -- commands run through the native Rust CLI directly with sub-millisecond parsing overhead.
 
 ## Quick start (no install)
 
+Run directly with `npx` if you want to try it without installing globally:
+
 ```bash
-npx agent-browser install   # Download Chrome (first time only)
-npx agent-browser open example.com
+npx agent-browser-stealth install   # Download Chromium (first time only)
+npx agent-browser-stealth open example.com
 ```
 
+> **Note:** `npx` routes through Node.js before reaching the Rust CLI, so it is noticeably slower than a global install. For regular use, install globally.
+
 ## Project installation (local dependency)
 
 For projects that want to pin the version in `package.json`:
 
 ```bash
-npm install agent-browser
-npx agent-browser install  # Download Chrome (first time)
+npm install agent-browser-stealth
+npx agent-browser-stealth install
 ```
 
-Then use via `npx` or `package.json` scripts.
+Then use via `npx` or `package.json` scripts:
+
+```bash
+npx agent-browser-stealth open example.com
+```
 
 ## Homebrew (macOS)
 
 ```bash
 brew install agent-browser
-agent-browser install  # Download Chrome (first time)
+agent-browser install  # Download Chromium
 ```
 
-## Cargo (Rust)
-
-```bash
-cargo install agent-browser
-agent-browser install  # Download Chrome (first time)
-```
-
-Compiles from source (~2-3 min). Requires the Rust toolchain ([rustup.rs](https://rustup.rs)).
-
 ## From source
 
 ```bash
-git clone https://github.com/vercel-labs/agent-browser
+git clone https://github.com/leeguooooo/agent-browser
 cd agent-browser
 pnpm install
 pnpm build
@@ -57,24 +60,24 @@ pnpm build:native
 pnpm link --global
 ```
 
+## Fork versioning
+
+Fork releases use a dual-version format:
+
+- `<upstream>-fork.<fork>`
+- Example: `0.14.0-fork.1`
+
+`agent-browser --version` prints the full version and also shows upstream and fork parts for fork builds.
+
 ## Linux dependencies
 
 On Linux, install system dependencies:
 
 ```bash
 agent-browser install --with-deps
+# or manually: npx playwright install-deps chromium
 ```
 
-## Updating
-
-Upgrade to the latest version:
-
-```bash
-agent-browser upgrade
-```
-
-Detects your installation method (npm, Homebrew, or Cargo) and runs the appropriate update command automatically. Displays the version change on success, or informs you if you are already on the latest version.
-
 ## Custom browser
 
 Use a custom browser executable instead of bundled Chromium:
@@ -93,7 +96,19 @@ AGENT_BROWSER_EXECUTABLE_PATH=/path/to/chromium agent-browser open example.com
 
 ### Serverless example
 
-Use `@sparticuz/chromium` or similar to obtain a Chromium executable path, then pass it via `--executable-path` or `AGENT_BROWSER_EXECUTABLE_PATH`.
+```typescript
+import chromium from '@sparticuz/chromium';
+import { BrowserManager } from 'agent-browser-stealth';
+
+export async function handler() {
+  const browser = new BrowserManager();
+  await browser.launch({
+    executablePath: await chromium.executablePath(),
+    headless: true,
+  });
+  // ... use browser
+}
+```
 
 ## AI agent setup
 
@@ -104,7 +119,7 @@ agent-browser works with any AI agent out of the box. For richer context:
 Install the skill for your AI coding assistant:
 
 ```bash
-npx skills add vercel-labs/agent-browser
+npx skills add leeguooooo/agent-browser
 ```
 
 This works with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Goose, OpenCode, and Windsurf. The skill is fetched from the repository and stays up to date automatically.

docs/src/app/ios/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("ios");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/ios/page.mdx

@@ -1,3 +1,7 @@
+import { pageMetadata } from "@/lib/page-metadata"
+
+export const metadata = pageMetadata("ios")
+
 # iOS Simulator
 
 Control real Mobile Safari in the iOS Simulator for authentic mobile
@@ -176,7 +180,7 @@ agent-browser -p ios --device "John's iPhone" open https://example.com
     <tr><th>Feature</th><th>Desktop</th><th>iOS</th></tr>
   </thead>
   <tbody>
-    <tr><td>Browser</td><td>Chrome, Lightpanda</td><td>Safari only</td></tr>
+    <tr><td>Browser</td><td>Chromium/Firefox/WebKit</td><td>Safari only</td></tr>
     <tr><td>Tabs</td><td>Supported</td><td>Single tab only</td></tr>
     <tr><td>PDF export</td><td>Supported</td><td>Not supported</td></tr>
     <tr><td>Screencast</td><td>Supported</td><td>Not supported</td></tr>

docs/src/app/layout.tsx

@@ -25,23 +25,23 @@ const geistMono = Geist_Mono({
 export const metadata: Metadata = {
   metadataBase: new URL("https://agent-browser.dev"),
   title: {
-    default: "agent-browser | Browser Automation for AI",
+    default: "agent-browser | Headless Browser Automation for AI",
     template: "%s | agent-browser",
   },
-  description: "Browser automation CLI for AI agents",
+  description: "Headless browser automation CLI for AI agents",
   openGraph: {
     type: "website",
     locale: "en_US",
     url: "https://agent-browser.dev",
     siteName: "agent-browser",
-    title: "agent-browser | Browser Automation for AI",
-    description: "Browser automation CLI for AI agents",
+    title: "agent-browser | Headless Browser Automation for AI",
+    description: "Headless browser automation CLI for AI agents",
     images: [{ url: "/og", width: 1200, height: 630, alt: "agent-browser" }],
   },
   twitter: {
     card: "summary_large_image",
-    title: "agent-browser | Browser Automation for AI",
-    description: "Browser automation CLI for AI agents",
+    title: "agent-browser | Headless Browser Automation for AI",
+    description: "Headless browser automation CLI for AI agents",
     images: ["/og"],
   },
 };

docs/src/app/native-mode/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("native-mode");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/native-mode/page.mdx

@@ -1,5 +1,85 @@
-# Native Mode
+import { pageMetadata } from "@/lib/page-metadata"
 
-agent-browser is now 100% native Rust by default. The Node.js/Playwright daemon has been removed.
+export const metadata = pageMetadata("native-mode")
 
-This page is no longer relevant. See the main [documentation](/) for current architecture and usage.
+# Native Mode (Experimental)
+
+agent-browser includes an experimental native Rust daemon that communicates with Chrome directly via the Chrome DevTools Protocol (CDP), eliminating the Node.js and Playwright dependencies entirely.
+
+## Enabling Native Mode
+
+Native mode is opt-in. Enable it with the `--native` flag or the `AGENT_BROWSER_NATIVE` environment variable.
+
+### CLI Flag
+
+```bash
+agent-browser --native open example.com
+agent-browser --native snapshot
+agent-browser --native close
+```
+
+### Environment Variable
+
+Set `AGENT_BROWSER_NATIVE=1` to avoid passing the flag on every command:
+
+```bash
+export AGENT_BROWSER_NATIVE=1
+agent-browser open example.com
+agent-browser snapshot
+agent-browser close
+```
+
+### Config File
+
+Add `"native": true` to your `agent-browser.json`:
+
+```json
+{"native": true}
+```
+
+## Architecture Comparison
+
+<table>
+  <thead>
+    <tr><th></th><th>Default (Node.js)</th><th>Native (<code>--native</code>)</th></tr>
+  </thead>
+  <tbody>
+    <tr><td><strong>Runtime</strong></td><td>Node.js + Playwright</td><td>Pure Rust binary</td></tr>
+    <tr><td><strong>Protocol</strong></td><td>Playwright protocol</td><td>Direct CDP / WebDriver</td></tr>
+    <tr><td><strong>Install size</strong></td><td>Larger (Node.js + npm deps)</td><td>Smaller (single binary)</td></tr>
+    <tr><td><strong>Browser support</strong></td><td>Chromium, Firefox, WebKit</td><td>Chromium, Safari (via WebDriver)</td></tr>
+    <tr><td><strong>Stability</strong></td><td>Stable</td><td>Experimental</td></tr>
+  </tbody>
+</table>
+
+## What Works
+
+All core commands are supported in native mode:
+
+- Navigation: `open`, `back`, `forward`, `reload`
+- Interaction: `click`, `fill`, `type`, `press`, `hover`, `select`, `check`, `uncheck`, `scroll`, `focus`, `clear`, `upload`, `drag`
+- Observation: `snapshot`, `screenshot`, `eval`, `get text/html/value/attr/count/box/styles`, `is visible/enabled/checked`
+- State: `cookies get/set/clear`, `storage local/session`, `state save/load/list`
+- Tabs: `tab new/list/close`, tab switching
+- Emulation: `set viewport`, `set device`, `set geo`, user agent, timezone, locale
+- Streaming: WebSocket screencast and remote input
+- Diffing: `diff snapshot`, `diff url`
+- Recording: `record start/stop`
+- Profiling: `profiler start/stop`, `trace start/stop`
+
+## Known Limitations
+
+- **Firefox and WebKit** are not yet supported (Chromium and Safari only)
+- **Playwright trace format** is not available (native tracing uses Chrome's built-in tracing)
+- **HAR export** is not available
+- **Network route interception** uses CDP Fetch domain instead of Playwright's route API
+
+## Switching Between Modes
+
+The native daemon and Node.js daemon share the same session socket. You cannot run both simultaneously for the same session. Close the current daemon before switching:
+
+```bash
+agent-browser close
+export AGENT_BROWSER_NATIVE=1
+agent-browser open example.com
+```

docs/src/app/next/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("next");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/next/page.mdx

@@ -1,207 +0,0 @@
-# Next.js + Vercel
-
-Run agent-browser from a Next.js app on Vercel using Vercel Sandbox.
-A Linux microVM spins up on demand, runs agent-browser + Chrome, and
-shuts down. No binary size limits, no Chromium bundling complexity.
-
-## Setup
-
-```bash
-pnpm add @vercel/sandbox
-```
-
-## Server action
-
-The Vercel Sandbox runs Amazon Linux. Chromium requires system libraries
-that are not installed by default, so fresh sandboxes need a `dnf install`
-step before agent-browser can launch Chrome. Use a sandbox snapshot
-(below) to skip this entirely in production.
-
-```ts
-"use server";
-import { Sandbox } from "@vercel/sandbox";
-
-const snapshotId = process.env.AGENT_BROWSER_SNAPSHOT_ID;
-
-const CHROMIUM_SYSTEM_DEPS = [
-  "nss", "nspr", "libxkbcommon", "atk", "at-spi2-atk", "at-spi2-core",
-  "libXcomposite", "libXdamage", "libXrandr", "libXfixes", "libXcursor",
-  "libXi", "libXtst", "libXScrnSaver", "libXext", "mesa-libgbm", "libdrm",
-  "mesa-libGL", "mesa-libEGL", "cups-libs", "alsa-lib", "pango", "cairo",
-  "gtk3", "dbus-libs",
-];
-
-function getSandboxCredentials() {
-  if (
-    process.env.VERCEL_TOKEN &&
-    process.env.VERCEL_TEAM_ID &&
-    process.env.VERCEL_PROJECT_ID
-  ) {
-    return {
-      token: process.env.VERCEL_TOKEN,
-      teamId: process.env.VERCEL_TEAM_ID,
-      projectId: process.env.VERCEL_PROJECT_ID,
-    };
-  }
-  return {};
-}
-
-async function withBrowser<T>(
-  fn: (sandbox: InstanceType<typeof Sandbox>) => Promise<T>,
-): Promise<T> {
-  const credentials = getSandboxCredentials();
-
-  const sandbox = snapshotId
-    ? await Sandbox.create({
-        ...credentials,
-        source: { type: "snapshot", snapshotId },
-        timeout: 120_000,
-      })
-    : await Sandbox.create({ ...credentials, runtime: "node24", timeout: 120_000 });
-
-  if (!snapshotId) {
-    await sandbox.runCommand("sh", [
-      "-c",
-      `sudo dnf clean all 2>&1 && sudo dnf install -y --skip-broken ${CHROMIUM_SYSTEM_DEPS.join(" ")} 2>&1 && sudo ldconfig 2>&1`,
-    ]);
-    await sandbox.runCommand("npm", ["install", "-g", "agent-browser"]);
-    await sandbox.runCommand("npx", ["agent-browser", "install"]);
-  }
-
-  try {
-    return await fn(sandbox);
-  } finally {
-    await sandbox.stop();
-  }
-}
-
-export async function screenshotUrl(url: string) {
-  return withBrowser(async (sandbox) => {
-    await sandbox.runCommand("agent-browser", ["open", url]);
-
-    const ssResult = await sandbox.runCommand("agent-browser", [
-      "screenshot", "--json",
-    ]);
-    const ssPath = JSON.parse(await ssResult.stdout())?.data?.path;
-    const b64Result = await sandbox.runCommand("base64", ["-w", "0", ssPath]);
-    const screenshot = (await b64Result.stdout()).trim();
-
-    await sandbox.runCommand("agent-browser", ["close"]);
-    return { ok: true, screenshot };
-  });
-}
-
-export async function snapshotUrl(url: string) {
-  return withBrowser(async (sandbox) => {
-    await sandbox.runCommand("agent-browser", ["open", url]);
-
-    const result = await sandbox.runCommand("agent-browser", [
-      "snapshot", "-i", "-c",
-    ]);
-    const snapshot = await result.stdout();
-
-    await sandbox.runCommand("agent-browser", ["close"]);
-    return { ok: true, snapshot };
-  });
-}
-```
-
-## Sandbox snapshots
-
-Without optimization, each Sandbox run installs system dependencies +
-agent-browser + Chromium from scratch (~30 seconds). A **sandbox snapshot**
-is a saved VM image with everything pre-installed -- like a Docker image
-for Vercel Sandbox. When `AGENT_BROWSER_SNAPSHOT_ID` is set, the sandbox
-boots from that image instead of installing, bringing startup down to
-sub-second.
-
-This is different from an agent-browser *accessibility snapshot* (which
-dumps a page's accessibility tree). A sandbox snapshot is a Vercel
-infrastructure concept.
-
-Create a sandbox snapshot by running the helper script once:
-
-```bash
-npx tsx scripts/create-snapshot.ts
-```
-
-The script spins up a fresh sandbox, installs system dependencies +
-agent-browser + Chromium, saves the VM state, and prints the snapshot ID:
-
-```
-AGENT_BROWSER_SNAPSHOT_ID=snap_xxxxxxxxxxxx
-```
-
-Add this to your Vercel project environment variables (or `.env.local`
-for local development). Recommended for any production deployment.
-
-## Authentication
-
-On Vercel deployments, the Sandbox SDK authenticates automatically via
-OIDC. For local development, provide explicit credentials:
-
-<table>
-  <thead>
-    <tr><th>Variable</th><th>Description</th></tr>
-  </thead>
-  <tbody>
-    <tr><td><code>VERCEL_TOKEN</code></td><td>Vercel personal access token</td></tr>
-    <tr><td><code>VERCEL_TEAM_ID</code></td><td>Vercel team ID</td></tr>
-    <tr><td><code>VERCEL_PROJECT_ID</code></td><td>Vercel project ID</td></tr>
-  </tbody>
-</table>
-
-When all three are set, they are passed to `Sandbox.create()`. When
-absent, the SDK falls back to `VERCEL_OIDC_TOKEN` (automatic on Vercel).
-
-## Scheduled workflows (cron)
-
-For recurring tasks like daily monitoring, use Vercel Cron Jobs:
-
-```ts
-// app/api/cron/monitor/route.ts
-export async function GET() {
-  const result = await withBrowser(async (sandbox) => {
-    await sandbox.runCommand("agent-browser", [
-      "open", "https://example.com/pricing",
-    ]);
-    const snap = await sandbox.runCommand("agent-browser", [
-      "snapshot", "-i", "-c",
-    ]);
-    await sandbox.runCommand("agent-browser", ["close"]);
-    return await snap.stdout();
-  });
-
-  // Process results, send alerts, store data...
-  return Response.json({ ok: true, snapshot: result });
-}
-```
-
-```json
-// vercel.json
-{
-  "crons": [
-    { "path": "/api/cron/monitor", "schedule": "0 9 * * *" }
-  ]
-}
-```
-
-## Environment variables
-
-<table>
-  <thead>
-    <tr><th>Variable</th><th>Description</th></tr>
-  </thead>
-  <tbody>
-    <tr><td><code>AGENT_BROWSER_SNAPSHOT_ID</code></td><td>Sandbox snapshot ID for sub-second startup (see above)</td></tr>
-    <tr><td><code>VERCEL_TOKEN</code></td><td>Vercel personal access token (for local dev; OIDC is automatic on Vercel)</td></tr>
-    <tr><td><code>VERCEL_TEAM_ID</code></td><td>Vercel team ID (for local dev)</td></tr>
-    <tr><td><code>VERCEL_PROJECT_ID</code></td><td>Vercel project ID (for local dev)</td></tr>
-  </tbody>
-</table>
-
-## Demo app
-
-A working demo with streaming progress UI, rate limiting, and a
-deploy-to-Vercel button is at
-[`examples/environments/`](https://github.com/vercel-labs/agent-browser/tree/main/examples/environments).

docs/src/app/page.mdx

@@ -1,16 +1,21 @@
+import { pageMetadata } from "@/lib/page-metadata"
+
+export const metadata = pageMetadata("")
+
 # agent-browser
 
-Browser automation CLI designed for AI agents. Compact text output minimizes context usage. 100% native Rust.
+Browser automation CLI designed for AI agents. Compact text output minimizes context usage. Fast Rust CLI with Node.js fallback.
 
 ```bash
-npm install -g agent-browser      # all platforms
+npm install -g agent-browser-stealth      # all platforms (fastest, native Rust CLI)
 brew install agent-browser        # macOS
-agent-browser install             # Download Chrome (first time)
 
 # or try without installing
-npx agent-browser open example.com
+npx agent-browser-stealth open example.com
 ```
 
+Executable aliases after install: `agent-browser`, `agent-browser-stealth`, and `abs`.
+
 ## Features
 
 - **Agent-first** - Compact text output uses fewer tokens than JSON, designed for AI context efficiency
@@ -19,6 +24,8 @@ npx agent-browser open example.com
 - **Complete** - 50+ commands for navigation, forms, screenshots, network, storage
 - **Sessions** - Multiple isolated browser instances with separate auth
 - **Cross-platform** - macOS, Linux, Windows with native binaries
+- **Auto region detection** - Locale, timezone, and Accept-Language automatically match the target site's TLD
+- **Captcha auto-retry** - Detects captcha/verification pages and retries with randomized backoff
 
 ## Works with
 
@@ -56,7 +63,8 @@ has a unique ref like `@e1`, `@e2`. This provides:
 Client-daemon architecture for optimal performance:
 
 1. **Rust CLI** - Parses commands, communicates with daemon
-2. **Native Daemon** - Pure Rust daemon using direct CDP, manages Chrome via Chrome DevTools Protocol
+2. **Node.js Daemon** (default) - Manages Playwright browser instance
+3. **Native Daemon** (experimental, `--native`) - Pure Rust daemon using direct CDP, no Node.js required
 
 Daemon starts automatically and persists between commands.
 

docs/src/app/profiler/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("profiler");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/profiler/page.mdx

@@ -1,3 +1,7 @@
+import { pageMetadata } from "@/lib/page-metadata"
+
+export const metadata = pageMetadata("profiler")
+
 # Profiler
 
 Capture Chrome DevTools performance profiles during browser automation.

docs/src/app/providers/agentcore/layout.tsx

@@ -1,7 +0,0 @@
-import { pageMetadata } from "@/lib/page-metadata";
-
-export const metadata = pageMetadata("providers/agentcore");
-
-export default function Layout({ children }: { children: React.ReactNode }) {
-  return children;
-}

docs/src/app/providers/agentcore/page.mdx

@@ -1,89 +0,0 @@
-# AgentCore
-
-[AWS Bedrock AgentCore](https://aws.amazon.com/bedrock/agentcore/) provides cloud browser sessions with SigV4 authentication. Use it when running agent-browser in AWS environments or when you need managed cloud browsers backed by AWS infrastructure.
-
-## Setup
-
-Credentials are automatically resolved from:
-
-1. Environment variables (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`)
-2. AWS CLI (`aws configure export-credentials`) which supports SSO, profiles, IAM roles, etc.
-
-```bash
-agent-browser -p agentcore open https://example.com
-```
-
-Or use environment variables for CI/scripts:
-
-```bash
-export AGENT_BROWSER_PROVIDER=agentcore
-agent-browser open https://example.com
-```
-
-The `-p` flag takes precedence over `AGENT_BROWSER_PROVIDER`.
-
-## Configuration
-
-<table>
-  <thead>
-    <tr><th>Variable</th><th>Description</th><th>Default</th></tr>
-  </thead>
-  <tbody>
-    <tr><td><code>AGENTCORE_REGION</code></td><td>AWS region for the AgentCore endpoint</td><td><code>us-east-1</code></td></tr>
-    <tr><td><code>AGENTCORE_BROWSER_ID</code></td><td>Browser identifier</td><td><code>aws.browser.v1</code></td></tr>
-    <tr><td><code>AGENTCORE_PROFILE_ID</code></td><td>Browser profile for persistent state (cookies, localStorage)</td><td>(none)</td></tr>
-    <tr><td><code>AGENTCORE_SESSION_TIMEOUT</code></td><td>Session timeout in seconds</td><td><code>3600</code></td></tr>
-    <tr><td><code>AWS_PROFILE</code></td><td>AWS CLI profile for credential resolution</td><td><code>default</code></td></tr>
-    <tr><td><code>AWS_ACCESS_KEY_ID</code></td><td>AWS access key (checked before AWS CLI fallback)</td><td>(none)</td></tr>
-    <tr><td><code>AWS_SECRET_ACCESS_KEY</code></td><td>AWS secret key</td><td>(none)</td></tr>
-    <tr><td><code>AWS_SESSION_TOKEN</code></td><td>Temporary session token (for STS/SSO credentials)</td><td>(none)</td></tr>
-  </tbody>
-</table>
-
-## Browser Profiles
-
-Use `AGENTCORE_PROFILE_ID` to persist browser state (cookies, localStorage) across sessions:
-
-```bash
-AGENTCORE_PROFILE_ID=my-profile agent-browser -p agentcore open https://example.com
-```
-
-When a profile is set, AgentCore stores and restores browser state automatically between sessions.
-
-## Live View
-
-When a session starts, AgentCore prints a Live View URL to stderr:
-
-```
-Session: abc123-def456
-Live View: https://us-east-1.console.aws.amazon.com/bedrock-agentcore/browser/aws.browser.v1/session/abc123-def456#
-```
-
-Open this URL in your browser to watch the agent session in real time from the AWS Console.
-
-## Credential Resolution
-
-AgentCore uses lightweight manual SigV4 signing (no AWS SDK dependency). Credentials are resolved in order:
-
-1. **Environment variables** (`AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY`, optionally `AWS_SESSION_TOKEN`)
-2. **AWS CLI** (`aws configure export-credentials --format env`), which supports SSO, IAM roles, credential files, and profiles
-
-If using SSO, run `aws sso login` before launching agent-browser. Set `AWS_PROFILE` to select a specific named profile.
-
-## Example
-
-```bash
-# Basic usage (credentials auto-resolved via AWS CLI)
-agent-browser -p agentcore open https://example.com
-
-# With a browser profile for persistent login state
-AGENTCORE_PROFILE_ID=my-profile agent-browser -p agentcore open https://x.com/home
-
-# With explicit region
-AGENTCORE_REGION=eu-west-1 agent-browser -p agentcore open https://example.com
-
-# With SSO profile
-AWS_PROFILE=my-sso-profile agent-browser -p agentcore open https://example.com
-```
-
-When enabled, agent-browser connects to an AgentCore cloud browser session instead of launching a local browser. All commands work identically.