Agent skill

Gsd Browser

by gsd-build in gsd-build/gsd-browser

Native Rust browser automation CLI for AI agents. An agent skill from gsd-build/gsd-browser.

Apache-2.0Auto-check passedProductivity & Automation

Install Gsd Browser

skills CLI
$ npx skills add gsd-build/gsd-browser --skill gsd-browser -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install gsd-build/gsd-browser gsd-browser --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
gsd-browser
GitHub stars
268
Token cost
~7.5k tokens
SKILL.md length
1,201 words
Files
116
Skills in repo
2
Repo updated
First seen
Licence
Apache-2.0

At a glance

Native Rust browser automation CLI for AI agents. An agent skill from gsd-build/gsd-browser.

  • Works in 6 steps: The daemon auto-starts on browser… → Always re-snapshot after page changes.… → Use --json when parsing output. Use text… → …
  • The user needs to interact with websites — navigating pages
  • SKILL.md covers Critical Rules, Core Workflow, Command Chaining and Command Reference, plus 2 more sections
  • Runs Rust and JavaScript scripts from its folder; reaches github.com and site-a.com; needs GSD_BROWSER_VAULT_KEY

What it does

Gsd Browser is an agent skill from gsd-build/gsd-browser. Native Rust browser automation CLI for AI agents. Use when the user needs to interact with websites — navigating pages, filling forms, clicking buttons, taking screenshots, sharing a live browser view, narrating browser actions, extracting structured data, running assertions, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "show me the browser", "share the screen", "pause the browser", "step through this"…

Its SKILL.md is about 7.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 122 other files (for example `.github/workflows/release.yml`, `AGENTS.md` and `README.md`).

It sits in Productivity & Automation, covering Browser automation, Visual regression testing and Web scraping. It works with Rust. The repository describes itself as: A fast, native browser automation CLI built from the ground up for AI agents, powered by Chrome DevTools Protocol. 63 commands covering navigation, interaction, screenshots… The licence is Apache-2.0.

When your agent uses it

  • The user needs to interact with websites — navigating pages
  • Clicking buttons
  • Taking screenshots
  • Sharing a live browser view

Example prompts

  • “open a website”
  • “fill out a form”
  • “click a button”
  • “/gsd-browser”

Requirements

  • Node.js
  • Pre-approved tools (allowed-tools): Bash(gsd-browser:*), Bash(gsd-browser *)

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. The daemon auto-starts on browser commands. daemon health only reports state; it does not start a session. Use daemon start only when you…
  2. Always re-snapshot after page changes. Refs are versioned (@v1:e1). After navigation, form submission, or dynamic content loading, old…
  3. Use --json when parsing output. Use text mode when reading output yourself. Use --json when you need to extract values programmatically…
  4. Positional args have no flag prefix. Commands like click, type, hover take positional args — do NOT add --selector. See exact syntax in…
  5. Use batch for atomic multi-step flows. Batch reduces round trips and keeps pass/fail checks in one call. Use separate commands when you…
  6. Use view when the user wants to watch or direct the browser. The live viewer is an authenticated local workbench with Control, Annotate…

What it can do on your machine

Read from SKILL.md and the folder at commit e5ec085. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Bash(gsd-browser:*)
    • Bash(gsd-browser *)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships script files (Rust and JavaScript, from the files we listed), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com
    • site-a.com
    • site-b.com
    • untrusted-page.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • GSD_BROWSER_VAULT_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Gsd Browser loads about 7.5k tokens when it runs. Until then it costs about 183 tokens; SKILL.md has 1,201 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~183
When it runs · the whole SKILL.md, loaded when a task matches
~7.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from gsd-build/gsd-browser at commit e5ec085, republished under its Apache-2.0 licence (© gsd-build). 1,201 words, ~7,502 tokens.

Download SKILL.mdSave it as .claude/skills/gsd-browser/SKILL.md (or your agent's skills folder). This skill also uses 115 other files; get the full folder from GitHub.
name
gsd-browser
description
Native Rust browser automation CLI for AI agents. Use when the user needs to interact with websites — navigating pages, filling forms, clicking buttons, taking screenshots, sharing a live browser view, narrating browser actions, extracting structured data, running assertions, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "show me the browser", "share the screen", "pause the browser", "step through this", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", "visual regression test", "check for prompt injection", or any task requiring programmatic web interaction.
allowed-tools
Bash(gsd-browser:*), Bash(gsd-browser *)

Browser Automation with gsd-browser

Critical Rules

  1. The daemon auto-starts on browser commands. daemon health only reports state; it does not start a session. Use daemon start only when you want to pre-warm or verify daemon lifecycle explicitly.
  2. Always re-snapshot after page changes. Refs are versioned (@v1:e1). After navigation, form submission, or dynamic content loading, old refs are stale. Run gsd-browser snapshot to get fresh refs.
  3. Use --json when parsing output. Use text mode when reading output yourself. Use --json when you need to extract values programmatically (e.g., checking assertion results, parsing snapshot refs).
  4. Positional args have no flag prefix. Commands like click, type, hover take positional args — do NOT add --selector. See exact syntax in command reference below.
  5. Use batch for atomic multi-step flows. Batch reduces round trips and keeps pass/fail checks in one call. Use separate commands when you need intermediate output (e.g., snapshot to discover refs).
  6. Use view when the user wants to watch or direct the browser. The live viewer is an authenticated local workbench with Control, Annotate, Record, and Sensitive modes. Keep CLI commands on the same named session.

Core Workflow

Every browser automation follows this pattern:

  1. Navigate: gsd-browser navigate <url>
  2. Snapshot: gsd-browser snapshot (get versioned refs like @v1:e1, @v1:e2)
  3. Interact: Use refs to click, fill, hover
  4. Re-snapshot: After navigation or DOM changes, get fresh refs
bash
gsd-browser navigate https://example.com/form
gsd-browser snapshot
# Output: @v1:e1 [input type="email"], @v1:e2 [input type="password"], @v1:e3 [button] "Submit"

gsd-browser fill-ref @v1:e1 "user@example.com"
gsd-browser fill-ref @v1:e2 "password123"
gsd-browser click-ref @v1:e3
gsd-browser wait-for --condition network_idle
gsd-browser snapshot  # REQUIRED — old refs are now stale

Command Chaining

Commands can be chained with && in a single shell invocation. Browser state also persists across separate invocations through the background daemon when you stay on the same session.

bash
# Chain navigate + wait + snapshot
gsd-browser navigate https://example.com && gsd-browser wait-for --condition network_idle && gsd-browser snapshot

# Chain multiple interactions
gsd-browser fill-ref @v1:e1 "user@example.com" && gsd-browser fill-ref @v1:e2 "password123" && gsd-browser click-ref @v1:e3

When to chain: Use && when you don't need intermediate output. Run commands separately when you need to parse output first (e.g., snapshot to discover refs, then interact).


Command Reference

Argument syntax: <arg> = required positional, [arg] = optional positional, --flag = named option. Do NOT add -- prefix to positional args.

Navigation
bash
gsd-browser navigate <url>                        # Navigate to a URL
gsd-browser back                                   # Go back in browser history
gsd-browser forward                                # Go forward in browser history
gsd-browser reload                                 # Reload the current page
Interaction

All selectors are positional — do NOT use --selector.

bash
# Click
gsd-browser click <selector>                       # Click by CSS selector
gsd-browser click --x 100 --y 200                  # Click by coordinates (no selector)

# Type — positional: <selector> <text>
gsd-browser type <selector> <text>                 # Atomic fill (replaces content)
gsd-browser type <selector> <text> --slowly        # Character-by-character
gsd-browser type <selector> <text> --clear-first   # Clear field before typing
gsd-browser type <selector> <text> --submit        # Press Enter after typing

# Other interaction — all positional selectors
gsd-browser press <key>                            # Press key: Enter, Escape, Tab, Meta+A
gsd-browser hover <selector>                       # Hover over element
gsd-browser scroll --direction down                # Scroll down 300px (default)
gsd-browser scroll --direction up --amount 500     # Scroll up 500px
gsd-browser select-option <selector> <option>      # Select dropdown by label or value
gsd-browser set-checked <selector> --checked       # Check checkbox/radio (omit --checked to uncheck)
gsd-browser drag <source-selector> <target-selector>  # Drag-and-drop
gsd-browser upload-file <selector> <file>...       # Set files on <input type="file">
gsd-browser set-viewport --preset mobile           # Preset: mobile, tablet, desktop, wide
gsd-browser set-viewport --width 1920 --height 1080  # Custom dimensions
Snapshot & Refs

Refs are versioned (@v1:e1, @v2:e3). The version increments each snapshot. Old refs become stale after page changes — always re-snapshot.

bash
# Take snapshot
gsd-browser snapshot                               # Snapshot interactive elements, assign refs
gsd-browser snapshot --selector "form"             # Scope to a CSS selector
gsd-browser snapshot --mode <mode>                 # Semantic mode (see below)
gsd-browser snapshot --limit 80                    # Increase element limit (default: 40)

# Use refs — all positional
gsd-browser get-ref <ref>                          # Get metadata for a ref
gsd-browser click-ref <ref>                        # Click element by ref
gsd-browser hover-ref <ref>                        # Hover element by ref
gsd-browser fill-ref <ref> <text>                  # Type into element by ref

Snapshot modes (--mode):

ModeWhat it captures
interactiveButtons, inputs, links, selects (default)
formForm fields with labels and current values
dialogElements inside open dialogs/modals
navigationLinks and nav elements
errorsError messages, validation warnings
headingsHeading elements (h1-h6) for page structure
visible_onlyAll visible elements regardless of interactivity
Inspection
bash
gsd-browser accessibility-tree                     # Full accessibility tree (roles, names, states)
gsd-browser find --text "Sign In"                  # Find elements by text (case-insensitive)
gsd-browser find --role button                     # Find by ARIA role
gsd-browser find --selector ".my-class"            # Find by CSS selector
gsd-browser find --role link --limit 50            # Increase limit (default: 20)
gsd-browser page-source                            # Get raw HTML of page
gsd-browser page-source --selector "main"          # Scoped HTML source
gsd-browser eval '<js-expression>'                 # Evaluate JavaScript in page context
Assertions

Run explicit pass/fail checks against the current page state. Prefer this over inferring success from output.

bash
gsd-browser assert --checks '[
  {"kind": "url_contains", "text": "/dashboard"},
  {"kind": "text_visible", "text": "Welcome"},
  {"kind": "selector_visible", "selector": "#user-menu"},
  {"kind": "value_equals", "selector": "input[name=email]", "value": "user@test.com"},
  {"kind": "no_console_errors"},
  {"kind": "no_failed_requests"}
]'

Assertion kinds (17): url_contains, text_visible, text_hidden, selector_visible, selector_hidden, value_equals, checked, no_console_errors, no_failed_requests, request_url_seen, response_status, console_message_matches, network_count, console_count, element_count, no_console_errors_since, no_failed_requests_since.

Batch Execution

Execute multiple steps in one call to reduce round trips. Stops on first failure by default.

bash
gsd-browser batch --steps '[
  {"action": "navigate", "url": "https://example.com"},
  {"action": "wait_for", "condition": "network_idle"},
  {"action": "click", "selector": "#login-btn"},
  {"action": "type", "selector": "input[name=email]", "text": "user@test.com"},
  {"action": "type", "selector": "input[name=password]", "text": "secret", "submit": true},
  {"action": "assert", "checks": [{"kind": "url_contains", "text": "/dashboard"}]}
]'

# With --summary-only to reduce output
gsd-browser batch --steps '[...]' --summary-only

Batch actions: navigate, click, type, key_press, wait_for, assert, click_ref, fill_ref.

Wait Conditions
bash
gsd-browser wait-for --condition selector_visible --value "#content"
gsd-browser wait-for --condition selector_hidden --value ".spinner"
gsd-browser wait-for --condition url_contains --value "/dashboard"
gsd-browser wait-for --condition network_idle
gsd-browser wait-for --condition delay --value 2000
gsd-browser wait-for --condition text_visible --value "Success"
gsd-browser wait-for --condition text_hidden --value "Loading"
gsd-browser wait-for --condition request_completed --value "/api/data"
gsd-browser wait-for --condition console_message --value "ready"
gsd-browser wait-for --condition element_count --value ".item" --threshold ">=5"
gsd-browser wait-for --condition region_stable --value "#content"

# Custom timeout (default: 10000ms)
gsd-browser wait-for --condition selector_visible --value "#slow" --timeout 30000
Forms (Smart Fill)

Analyze forms and fill them by field label, name, placeholder, or aria-label — no selectors needed.

bash
# Analyze form structure
gsd-browser analyze-form
gsd-browser analyze-form --selector "#signup-form"

# Fill by field identifiers (resolved: label -> name -> placeholder -> aria-label)
gsd-browser fill-form --values '{"Email": "a@b.com", "Password": "secret", "Country": "US"}'
gsd-browser fill-form --values '{"Email": "a@b.com"}' --submit  # Fill and click submit
gsd-browser fill-form --values '{"Email": "a@b.com"}' --selector "#login-form"
Intent-Based Interaction

Find and act on elements by semantic intent — no selectors or refs needed. Intents are predefined categories, not free-form text.

bash
# Find top candidates for an intent (returns scored matches with selectors)
gsd-browser find-best --intent submit_form
gsd-browser find-best --intent accept_cookies
gsd-browser find-best --intent primary_cta --scope "#modal"

# Act: find best match and click/focus it in one call
gsd-browser act --intent submit_form
gsd-browser act --intent accept_cookies
gsd-browser act --intent fill_email

Intents (15):

IntentActionDescription
submit_formclickSubmit buttons, form actions
close_dialogclickModal/dialog close buttons
primary_ctaclickPrimary call-to-action elements
search_fieldfocusSearch inputs and searchboxes
next_stepclickNext/continue/proceed buttons
dismissclickDismiss overlays, banners, toasts
auth_actionclickLogin/signup/register buttons
back_navigationclickBack/previous navigation links
fill_emailfocusEmail input fields
fill_passwordfocusPassword input fields
fill_usernamefocusUsername/login input fields
accept_cookiesclickCookie consent accept buttons
main_contentclickMain content area (<main>, <article>, semantic markup required)
pagination_nextclickNext page in pagination
pagination_prevclickPrevious page in pagination
Pages & Frames

Page and frame IDs are positional — do NOT use --id.

bash
gsd-browser list-pages                             # List all open tabs
gsd-browser switch-page <id>                       # Switch to tab by ID (positional)
gsd-browser close-page <id>                        # Close a tab by ID (positional)

gsd-browser list-frames                            # List all frames (main + iframes)
gsd-browser select-frame --name "iframe-name"      # Select frame by name
gsd-browser select-frame --url-pattern "embed"     # Select frame by URL substring
gsd-browser select-frame --index 0                 # Select by index
gsd-browser select-frame --name main               # Return to main frame
Diagnostics
bash
gsd-browser console                                # Get console log entries (clears buffer)
gsd-browser console --no-clear                     # Read without clearing
gsd-browser network                                # Get network log entries
gsd-browser dialog                                 # Get dialog events (alert, confirm, prompt)
gsd-browser timeline                               # Query the action timeline
gsd-browser session-summary                        # Diagnostic summary of current session
gsd-browser debug-bundle                           # Full debug bundle: screenshot + logs + timeline + a11y tree
Live Viewer & Workbench

The live viewer is a localhost screen-sharing and control surface for the active browser session. It prints or opens a tokenized URL bound to the session, viewer id, local origin, expiry, and capabilities. The viewer displays live frames, narrated action history, ref overlays, target rings, click ripples, failure markers, and page-following across navigation or tab changes.

bash
gsd-browser view                                   # Open the live viewer
gsd-browser view --print-only                      # Print tokenized URL only
gsd-browser view --interactive                     # Interactive local workbench
gsd-browser view --history                         # Open history-focused viewer
gsd-browser view --history --print-only            # Print history URL only

gsd-browser goal "Find the checkout button"        # Set viewer goal banner
gsd-browser goal --clear                           # Clear goal banner

gsd-browser control-state                          # Show shared owner/mode/version
gsd-browser takeover                               # Give page input to the viewer
gsd-browser release-control                        # Return page input to the agent
gsd-browser pause                                  # Pause before next narrated action
gsd-browser resume                                 # Resume actions
gsd-browser step                                   # Allow one action, then pause
gsd-browser abort                                  # Abort next gated action
gsd-browser sensitive-on                           # Local human control with redaction
gsd-browser sensitive-off                          # Leave sensitive mode

Use one named session for the whole shared-screen flow:

bash
gsd-browser --session demo navigate https://example.com
gsd-browser --session demo view --print-only
gsd-browser --session demo click "h1"

Viewer controls:

ControlEffect
ControlForwards pointer, wheel, keyboard, text, and paste input to Chrome
AnnotateCreates point annotations without forwarding page input
RecordStarts or stops a local recording bundle
SensitiveKeeps local viewer control active and applies redaction policy
PauseBlocks agent page input
ResumeAllows actions to continue
StepAllows one action, then returns to paused mode
AbortAborts the next gated action
Refs overlayShows or hides target boxes/labels

Keyboard shortcuts: Space pauses/resumes, Right Arrow steps, Escape aborts, R toggles refs.

Risky visible targets such as destructive labels, payment actions, OAuth grants, credential entry, file transfer, production/admin surfaces, and cross-origin navigation produce an approval banner. Approval dispatches the exact pending command stored by the daemon.

Annotations:

bash
gsd-browser annotations
gsd-browser annotation-get <id>
gsd-browser annotation-clear <id>
gsd-browser annotation-clear --all
gsd-browser annotation-resolve <id>
gsd-browser annotation-export --output annotations.json
gsd-browser annotation-request "Select the button to restyle"

Recording bundles:

bash
gsd-browser record-start --name checkout-bug
gsd-browser record-stop
gsd-browser record-pause
gsd-browser record-resume
gsd-browser recordings
gsd-browser recording-get <id>
gsd-browser recording-export <id> --output <path>
gsd-browser recording-discard <id>
gsd-browser recording-validate <id-or-path> --json

Viewer annotations and recording bundles are local daemon artifacts. Recording manifests use BrowserArtifactBundleV1, ordered JSONL events, redaction metadata, and local artifact directories under the browser state path.

Use --no-narration-delay for fast agent-only runs that keep narration events/history without lead-time sleeps:

bash
gsd-browser --session demo --no-narration-delay click "h1"
Show full SKILL.md (373 more words)Show less
Visual
bash
gsd-browser screenshot                             # Screenshot to stdout (JPEG base64)
gsd-browser screenshot --output page.png           # Write to file
gsd-browser screenshot --format png                # Force PNG format
gsd-browser screenshot --full-page                 # Full scrollable page
gsd-browser screenshot --selector "#hero"          # Crop to element (always PNG)
gsd-browser screenshot --quality 50                # JPEG quality 1-100 (default: 80)

gsd-browser zoom-region --x 100 --y 200 --width 400 --height 300  # Capture region
gsd-browser zoom-region --x 0 --y 0 --width 200 --height 200 --scale 3  # Upscale

gsd-browser save-pdf                               # Save page as PDF (A4 default)
gsd-browser save-pdf --output report.pdf           # Custom output path
gsd-browser save-pdf --format Letter               # Page format: A4, Letter, Legal, Tabloid
Visual Regression
bash
# First run: saves baseline screenshot
gsd-browser visual-diff --name "homepage"

# Subsequent runs: compare against baseline, report mismatch
gsd-browser visual-diff --name "homepage"
gsd-browser visual-diff --name "homepage" --threshold 0.05   # Stricter tolerance (0-1)
gsd-browser visual-diff --selector "#hero" --name "hero"     # Scope to element
gsd-browser visual-diff --name "homepage" --update-baseline  # Reset baseline
Structured Data Extraction
bash
# Single item
gsd-browser extract --schema '{
  "type": "object",
  "properties": {
    "title": {"_selector": "h1", "_attribute": "textContent"},
    "price": {"_selector": ".price", "_attribute": "textContent"},
    "image": {"_selector": "img.product", "_attribute": "src"}
  }
}'

# Array of items
gsd-browser extract --selector ".product-card" --multiple --schema '{
  "type": "object",
  "properties": {
    "name": {"_selector": "h3", "_attribute": "textContent"},
    "price": {"_selector": ".price", "_attribute": "textContent"}
  }
}'
Network Mocking
bash
gsd-browser mock-route --url "**/api/users*" --body '[{"name":"Alice"}]' --status 200
gsd-browser mock-route --url "**/api/data" --body '{"ok":true}' --delay 3000  # Slow response
gsd-browser block-urls "**/analytics*" "**/ads*"   # Block URL patterns (positional)
gsd-browser clear-routes                           # Remove all mocks and blocks
Device Emulation
bash
gsd-browser emulate-device <device-name>           # Full device emulation (positional)
gsd-browser emulate-device "iPhone 15"
gsd-browser emulate-device "Pixel 7"
gsd-browser emulate-device "iPad Pro 11"
gsd-browser emulate-device list                    # Show all available presets

Warning: Device emulation recreates the browser context — current page state and cookies are lost.

State & Auth
bash
# Save/restore browser state (cookies, localStorage, sessionStorage)
gsd-browser save-state --name "logged-in"
gsd-browser restore-state --name "logged-in"

# Auth vault (encrypted credentials)
gsd-browser vault-save --profile github --url https://github.com/login \
  --username user --password "secret"
gsd-browser vault-login --profile github
gsd-browser vault-list                             # List profiles (no secrets shown)

Vault encryption requires GSD_BROWSER_VAULT_KEY env var set before the daemon starts. If the daemon is already running, stop it first, set the var, then run your vault command.

Tracing & Recording
bash
gsd-browser trace-start                            # Start CDP performance trace
gsd-browser trace-start --name "checkout-flow"     # Named trace
gsd-browser trace-stop                             # Stop and write trace to disk
gsd-browser trace-stop --name "checkout.json"      # Custom output filename

gsd-browser har-export                             # Export network as HAR 1.2 JSON
gsd-browser har-export --filename "session.har"    # Custom output path

gsd-browser generate-test                          # Generate Playwright test from timeline
gsd-browser generate-test --name "login-flow" --output tests/login.spec.ts
Security
bash
gsd-browser check-injection                        # Scan for prompt injection in page content
gsd-browser check-injection --include-hidden       # Include hidden/invisible text (default: true)
Action Cache

Reduce repeated element lookups by caching intent-to-selector mappings.

bash
gsd-browser action-cache --action stats            # Show cache metrics
gsd-browser action-cache --action get --intent submit_form  # Look up cached selector
gsd-browser action-cache --action put --intent submit_form --selector "#submit-btn" --score 0.95
gsd-browser action-cache --action clear            # Flush cache
Daemon Management

The daemon auto-starts on browser commands. These are for explicit lifecycle control.

bash
gsd-browser daemon stop                            # Stop daemon (idempotent — safe on dead processes)
gsd-browser daemon health                          # Health check (read-only, does not auto-start)
gsd-browser daemon start                           # Explicit start (pre-warm browser before commands)
gsd-browser update                                 # Install the current release

Global Options

Available on all commands:

FlagDescription
--jsonOutput as JSON (use when parsing output programmatically)
--browser-path <path>Path to Chrome/Chromium binary
--cdp-url <url>Attach to an already-running Chrome (e.g. http://localhost:9222)
--session <name>Named session for parallel browser instances
--no-narration-delaySkip narration lead-time sleeps while keeping history/events

Error Recovery

Stale refs
Error: resolve_ref: JS evaluation failed: ref @v1:e3 not found

Refs become stale after page changes. Fix: re-snapshot and use the new version.

bash
gsd-browser snapshot        # Get fresh refs (@v2:eN)
gsd-browser click-ref @v2:e1
Click/type timeouts
Error: click timed out after 10s for: #submit-btn

The element may not be visible, may be behind an overlay, or may not exist. Try:

bash
gsd-browser find --selector "#submit-btn"          # Verify element exists
gsd-browser scroll --direction down                # Scroll it into view
gsd-browser wait-for --condition selector_visible --value "#submit-btn"  # Wait for it
gsd-browser click "#submit-btn"                    # Retry
Empty console/network logs

Console and network buffers start fresh each navigation. If you need logs from a specific action, check them before navigating away:

bash
gsd-browser navigate https://example.com
gsd-browser eval "fetch('/api/data')"
gsd-browser network                                # Check network BEFORE navigating away

Many sites show consent banners that block clicks. Dismiss them first:

bash
gsd-browser act --intent accept_cookies            # Auto-find and click accept button
gsd-browser act --intent dismiss                   # Or dismiss generic overlays
Session is stopped, unhealthy, or opens a fresh blank page

If daemon health reports stopped or unhealthy, or a named session no longer has the page you expected, that session does not currently map to a live daemon/browser pair.

bash
gsd-browser --session site1 daemon health
gsd-browser --session site1 daemon stop
gsd-browser --session site1 navigate https://example.com

Use the same --session value on every follow-up command. batch is still useful for atomic flows, but separate invocations are supported when the session is healthy.

Daemon won't start
Error: daemon did not start within 10s

Usually the session is unhealthy, startup exited early, or browser launch state is stale. Fix:

bash
gsd-browser daemon health                          # Inspect current state
gsd-browser daemon stop                            # Clear the current session state
gsd-browser daemon start                           # Retry explicit startup

Common Patterns

Form Submission
bash
gsd-browser navigate https://example.com/signup
gsd-browser analyze-form                           # Discover field labels and types
gsd-browser fill-form --values '{"Full Name": "Jane Doe", "Email": "jane@example.com", "State": "California"}' --submit
gsd-browser wait-for --condition network_idle
gsd-browser assert --checks '[{"kind": "text_visible", "text": "Welcome"}]'
Login Flow (Refs)
bash
gsd-browser navigate https://app.example.com/login
gsd-browser act --intent accept_cookies            # Dismiss cookie banner if present
gsd-browser snapshot
# Read snapshot output to find email, password, and submit refs
gsd-browser fill-ref @v1:e1 "$USERNAME"
gsd-browser fill-ref @v1:e2 "$PASSWORD"
gsd-browser click-ref @v1:e3
gsd-browser wait-for --condition url_contains --value "/dashboard"
gsd-browser save-state --name "myapp-auth"         # Save for reuse
Login Flow (Vault)
bash
# Save credentials once (encrypted at rest)
gsd-browser vault-save --profile myapp \
  --url https://app.example.com/login \
  --username user@example.com \
  --password "$PASSWORD"

# Login in any future session
gsd-browser vault-login --profile myapp
gsd-browser wait-for --condition url_contains --value "/dashboard"
Reuse Saved Auth
bash
gsd-browser restore-state --name "myapp-auth"
gsd-browser navigate https://app.example.com/dashboard  # Already logged in
Data Scraping
bash
gsd-browser navigate https://example.com/products
gsd-browser extract --selector ".product" --multiple --schema '{
  "type": "object",
  "properties": {
    "name": {"_selector": ".title", "_attribute": "textContent"},
    "price": {"_selector": ".price", "_attribute": "textContent"},
    "link": {"_selector": "a", "_attribute": "href"}
  }
}'
Visual Regression Testing
bash
# Establish baseline (first run)
gsd-browser navigate https://example.com
gsd-browser visual-diff --name "home-page"

# Later: compare current state
gsd-browser navigate https://example.com
gsd-browser visual-diff --name "home-page"
# Output: similarity %, diff pixel count, diff image path
Network Mocking for Testing
bash
gsd-browser mock-route --url "**/api/users" --body '{"error":"server error"}' --status 500
gsd-browser navigate https://app.example.com
gsd-browser assert --checks '[{"kind": "text_visible", "text": "Something went wrong"}]'
gsd-browser clear-routes                           # Clean up mocks
Parallel Sessions
bash
gsd-browser --session site1 navigate https://site-a.com
gsd-browser --session site2 navigate https://site-b.com

gsd-browser --session site1 snapshot
gsd-browser --session site2 snapshot

# Clean up both
gsd-browser --session site1 daemon stop
gsd-browser --session site2 daemon stop
Performance Audit
bash
gsd-browser navigate https://example.com
gsd-browser trace-start --name "perf-audit"
# ... interact with the page ...
gsd-browser trace-stop --name "perf-audit.json"
gsd-browser har-export --filename "network.har"
Prompt Injection Scanning
bash
gsd-browser navigate https://untrusted-page.com
gsd-browser check-injection
# Returns severity-rated findings for visible and hidden injection patterns

Configuration

Config Files (TOML)

gsd-browser loads config with 5-layer merge precedence:

  1. Compiled defaults
  2. User config: ~/.gsd-browser/config.toml
  3. Project config: ./gsd-browser.toml
  4. Environment variables: GSD_BROWSER_*
  5. CLI flags (highest priority)

Example gsd-browser.toml:

toml
[browser]
path = "/usr/bin/chromium"

[daemon]
port = 9222
host = "127.0.0.1"

[screenshot]
quality = 90
format = "png"
full_page = false

[settle]
timeout_ms = 500
poll_ms = 40
quiet_window_ms = 100

[logs]
max_buffer_size = 1000

[artifacts]
dir = "./browser-artifacts"

[timeline]
max_entries = 500
Environment Variables

Supported config overrides use GSD_BROWSER_<SECTION>_<FIELD> naming:

bash
GSD_BROWSER_BROWSER_PATH=/usr/bin/chromium
GSD_BROWSER_DAEMON_PORT=9223
GSD_BROWSER_SCREENSHOT_QUALITY=90
GSD_BROWSER_SETTLE_TIMEOUT_MS=1000
GSD_BROWSER_VAULT_KEY=your-encryption-key

Session Cleanup

Always stop the daemon when done to avoid leaked Chrome processes:

bash
gsd-browser daemon stop

For parallel sessions:

bash
gsd-browser --session agent1 daemon stop
gsd-browser --session agent2 daemon stop

© gsd-build, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 115 other files in the repository root of gsd-build/gsd-browser.

  • SKILL.md
  • .github/workflows/release.yml
  • .gitignore
  • AGENTS.md
  • Cargo.lock
  • Cargo.toml
  • LICENSE-APACHE
  • LICENSE-MIT
  • README.md
  • cli/Cargo.toml
  • cli/assets/viewer-coordinate.test.mjs
  • cli/assets/viewer.html
  • cli/src/daemon/capture.rs
  • cli/src/daemon/handlers/advanced.rs
  • … and 102 more

Open the folder on GitHubat commit e5ec085

Compare with similar skills

Gsd Browser next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Gsd Browser compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Gsd Browser this skillgsd-build/gsd-browser268—~7.5kAutomated safety check: PassApache-2.0
Bright Data MCPbrightdata/skills2641 repos~3.7kAutomated safety check: PassMIT
Scrapingbee CLIScrapingBee/scrapingbee-cli108—~3.2kAutomated safety check: NotesMIT
Cloudflare Browser Renderingeinverne/dotfiles121—~4.9kAutomated safety check: PassGPL-3.0
Dev Browser AutomationMemTensor/MemOS12k3 repos~1.7kAutomated safety check: PassApache-2.0
Browser Control with Omowrightcode-yeongyu/oh-my-openagent70k1 repos~2.2kAutomated safety check: PassCustom licence

Similar skills

  • Bright Data MCP

    brightdata/skills

    Bright Data MCP handles ALL web data operations. An agent skill from brightdata/skills.

    264 GitHub starsUsed in 1 repo~3.7k tokens
    Productivity & AutomationAuto-check passed
  • Scrapingbee CLI

    ScrapingBee/scrapingbee-cli

    Fetch and read any web page, search the web, crawl a site, or pull structured data out of pages.

    108 GitHub stars~3.2k tokensUpdated yesterday
    Productivity & AutomationAuto-check: notes
  • Guide for implementing Cloudflare Browser Rendering - a headless browser automation API for screenshots, PDFs, web scraping, and testing.

    121 GitHub stars~4.9k tokensUpdated 29 days ago
    Productivity & AutomationAuto-check passed
  • Dev Browser Automation

    MemTensor/MemOS

    Automates a real browser through short TypeScript scripts that keep page state between runs, for navigating, filling forms, taking screenshots and extracting data.

    12k GitHub starsUsed in 3 repos~1.7k tokens
    Productivity & AutomationAuto-check passed
  • Browser Control with Omowright

    code-yeongyu/oh-my-openagent

    Drives a real browser through the omowright library, either the user's own signed-in browser or a separate browser the code launches, for forms, QA, screenshots and scraping.

    70k GitHub starsUsed in 1 repo~2.2k tokens
    Productivity & AutomationAuto-check passed
  • Core Guide for agent-browser

    vercel-labs/agent-browser

    Official

    Core usage guide for the agent-browser CLI: the snapshot-and-ref workflow for navigating, clicking, filling forms, extracting data and running parallel sessions.

    44k GitHub starsUsed in 4 repos~9.5k tokens
    Productivity & AutomationAuto-check passed

More from gsd-build/gsd-browser

  • Gsd Browser

    gsd-build/gsd-browser

    Native Rust browser automation CLI for AI agents. An agent skill from gsd-build/gsd-browser.

    268 GitHub stars~1.3k tokensUpdated 5 mo ago
    Auto-check passed

Works with

Questions about Gsd Browser

What does Gsd Browser do?

Native Rust browser automation CLI for AI agents. An agent skill from gsd-build/gsd-browser. Gsd Browser is an agent skill from gsd-build/gsd-browser. Native Rust browser automation CLI for AI agents.

When should I use Gsd Browser?

Gsd Browser fits situations like: the user needs to interact with websites — navigating pages; clicking buttons; taking screenshots; sharing a live browser view.

How do I install Gsd Browser in Claude Code?

Run `npx skills add gsd-build/gsd-browser --skill gsd-browser -a claude-code`. Or copy the skill folder (the gsd-build/gsd-browser repository) into .claude/skills/gsd-browser in your project. Claude Code loads it when a task matches its description.

How do I install Gsd Browser in Codex?

Run `npx skills add gsd-build/gsd-browser --skill gsd-browser -a codex`. Or copy the skill folder (the gsd-build/gsd-browser repository) into .agents/skills/gsd-browser in your project. Codex loads it when a task matches its description.

Can I use Gsd Browser in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add gsd-build/gsd-browser --skill gsd-browser -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/gsd-browser, .gemini/skills/gsd-browser, .github/skills/gsd-browser and .opencode/skills/gsd-browser in your project.

What does Gsd Browser need to run?

Going by SKILL.md and its folder, Gsd Browser needs Rust and JavaScript for the scripts in its folder and credentials named GSD_BROWSER_VAULT_KEY. Our summary lists: Node.js. Its frontmatter pre-approves these tools: Bash(gsd-browser:*), Bash(gsd-browser *).

Does Gsd Browser access the network?

SKILL.md names 4 domains. In commands or code: github.com, site-a.com, site-b.com and untrusted-page.com; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.

Is Gsd Browser safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Gsd Browser use?

Gsd Browser is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Gsd Browser use?

About 7.5k tokens (SKILL.md is roughly 30k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Gsd Browser?

Skills that share tags, products or a category with Gsd Browser: Bright Data MCP (brightdata/skills, 264 stars), Scrapingbee CLI (ScrapingBee/scrapingbee-cli, 108 stars), Cloudflare Browser Rendering (einverne/dotfiles, 121 stars) and Dev Browser Automation (MemTensor/MemOS, 12k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Gsd Browser?

gsd-build (a GitHub organization) maintains it in gsd-build/gsd-browser, which has 268 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on May 3, 2026.

Source: gsd-build/gsd-browser on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.