DEV Community: zmy

I built a CLI tool so my AI coding agent can browse the web

zmy — Wed, 10 Jun 2026 09:37:49 +0000

I Built a CLI Tool So My AI Coding Agent Can Browse the Web

Here's a problem I kept running into:

I'd ask Claude Code to build a feature. It writes the code perfectly. Then I'd say, "Now go test it — open the app, fill in the form, submit it, and tell me if it works."

And Claude would say: "I can't interact with browsers."

Every. Single. Time.

My AI assistant could write a full React component from scratch, but couldn't click a button on a webpage. It could generate a Playwright test script, but couldn't run it. The intelligence was there — the hands weren't.

So I built the hands.

The Idea Was Simple

What if browser automation was just... shell commands?

browser-cli navigate https://my-app.com
browser-cli fill "#email" "test@example.com"
browser-cli click "button[type=submit]"
browser-cli text

No scripts. No Node.js setup. No Python virtualenv. Just commands that any AI agent can run as a shell command, with JSON output it can actually parse.

I called it browser-cli.

What It Does

Browser-CLI wraps Playwright (the browser automation engine) into a Go CLI tool. The architecture is straightforward:

A background server manages browser instances over Unix sockets
CLI commands connect, execute, and return JSON
The server auto-starts when you run your first command — no manual setup

Every command returns structured JSON:

{
  "command": "navigate",
  "status": "success",
  "data": {
    "url": "https://example.com/",
    "title": "Example Domain"
  }
}

This means AI agents can call browser-cli, read the response, and decide what to do next. It's a feedback loop: navigate → read → decide → act.

The Features I Actually Needed

I didn't start with a feature list. I started with my own frustrations and built what I needed:

Login persistence. I got tired of logging into GitHub every time I wanted to scrape something. So I added a login command that opens a visible browser, lets you log in manually, and saves the entire state (cookies + localStorage) to a file. Next time, you just pass --state ./github-state.json and you're already logged in.

browser-cli login https://github.com
# ... log in manually, press Ctrl+C when done ...

# Reuse forever
browser-cli --state ./github-state.json navigate https://github.com/settings

Stealth mode. Half the sites I tried to automate blocked Playwright immediately. So I built in anti-detection: override navigator.webdriver, fake plugins and mimeTypes, add window.chrome, disable automation flags. Now it works on Google sign-in, Cloudflare-protected sites, and most bot detectors.

Session isolation. Sometimes I'd have two AI agents working on different tasks simultaneously, and they'd interfere with each other's browser state. The --session flag gives each agent its own isolated browser instance:

browser-cli --session agent-1 navigate https://site-a.com
browser-cli --session agent-2 navigate https://site-b.com

Web Components. Modern SPAs use custom elements that ignore standard DOM clicks. I added smart-click that detects internal handlers (_onClick, handleSubmit, etc.) and calls them directly.

How I Use It Day to Day

Here's my actual workflow with Claude Code:

I ask Claude to build a feature
Claude writes the code
I say: "Test it with browser-cli"
Claude runs browser-cli navigate http://localhost:3000, fills in forms, clicks buttons, reads the output
If something's broken, Claude sees the error and fixes it — without me touching the browser

It's a tight loop. No context switching. No "let me check that manually and get back to you."

Another thing I do: scraping. I needed to pull data from a dashboard that has no API. Instead of writing a one-off Python script, I just tell Claude: "Go to this dashboard, extract the numbers from the table, and put them in a CSV." Claude uses browser-cli to navigate, extract, and format the data. Done.

The Tech Stack

Go — I wanted a single static binary with no runtime dependencies. Go is perfect for this. CGO_ENABLED=0 and it runs anywhere.
Playwright — The best browser automation engine. Handles Chromium, Firefox, and WebKit.
JSON-RPC over Unix sockets — Simple, fast, no HTTP overhead. The server manages browser instances and the CLI is just a thin client.

The whole thing compiles to one binary. No Node.js. No Python. No runtime dependencies.

It's Open Source

I put it on GitHub because I figured other people have the same problem:

👉 https://github.com/zmysysz/browser-cli

Apache 2.0 license. Free to use, modify, and distribute.

git clone https://github.com/zmysysz/browser-cli
cd browser-cli
make build
make setup-browsers
browser-cli navigate https://example.com

Integration files are included for Claude Code, OpenAI Codex, Cursor, and generic AI agents. Just copy the right file to the right directory and you're set.

What's Next

I'm working on:

CDP endpoint support — Connect to an externally-launched Chrome for sites with strict bot detection
Better element discovery — Making it easier for AI agents to find the right selectors
More integrations — Windsurf, Aider, and other AI coding tools

If you try it, I'd love to hear what you think. Open an issue, drop a star, or just tell me what workflow you'd automate first.

What would you do if your AI coding assistant could browse the web?

How to Give Your AI Agent Browser Superpowers with Browser-CLI

zmy — Tue, 09 Jun 2026 10:20:08 +0000

How to Give Your AI Agent Browser Superpowers with Browser-CLI

Your AI coding assistant just wrote perfect code. Now you need it to test the login flow on your staging site.

You ask Claude Code: "Go to staging.example.com, log in with test@example.com, and verify the dashboard loads."

Claude's response: "I can't interact with web browsers. I can write Playwright scripts for you, but I can't run them."

This is the missing piece. Your AI agent has all the intelligence to navigate websites, fill forms, and extract data — but no hands to actually do it.

Browser-CLI fixes this. It's a command-line tool that gives AI agents direct browser control through simple shell commands. No scripts. No complex setup. Just:

browser-cli navigate https://staging.example.com
browser-cli fill "#email" "test@example.com"
browser-cli fill "#password" "secret"
browser-cli click "button[type=submit]"
browser-cli wait ".dashboard"
browser-cli screenshot result.png

Every command returns structured JSON that AI agents can parse and act on. The result? Your AI agent can now browse the web, test your apps, and automate repetitive tasks — all by itself.

Why You Need This

If you use any AI coding assistant (Claude Code, Cursor, Codex, Windsurf, etc.), you've probably hit these walls:

Task	AI Agent Can Do It?	Why Not?
Log into a website and scrape data	❌	No browser access
Fill out and submit forms	❌	No browser access
Take screenshots of pages	❌	No browser access
Test web apps end-to-end	❌	No browser access
Automate repetitive web tasks	❌	No browser access

Existing solutions don't fit AI agents:

Puppeteer/Playwright: Require writing JavaScript/Python scripts. AI agents can generate these scripts, but running them requires a Node.js/Python environment, proper setup, and error handling. It's fragile and slow.
browser-use: A Python library that uses LLMs to control browsers. But it's designed for Python developers, not as a tool for AI coding assistants to call directly.
Actionbook: Similar concept, but requires specific integrations and doesn't have the AI-first design.

Browser-CLI is different. It's designed from the ground up for AI agents to call as a shell command:

✅ Zero-code: Just CLI commands, no scripts to write or maintain
✅ JSON output: Structured responses that AI agents can parse reliably
✅ Auto-managed server: No manual server start/stop, it just works
✅ Session isolation: Multiple agents can run in parallel without conflicts
✅ Login persistence: Log in once manually, reuse forever in automation
✅ Stealth mode: Bypasses bot detection on sites like Google, Cloudflare

Quick Start: 5 Minutes to Browser Superpowers

Step 1: Install

git clone https://github.com/zmysysz/browser-cli
cd browser-cli
make build
make setup-browsers  # Downloads Playwright browsers (first time only)
make install         # Adds to PATH

Requirements: Go 1.21+ (for building). The binary is fully static — no CGO, no runtime dependencies.

Step 2: Try It

# Navigate to a page (server auto-starts)
browser-cli navigate https://example.com

# Extract page content
browser-cli text

Output:

{
  "command": "text",
  "status": "success",
  "data": {
    "content": "Example Domain\nThis domain is for use in illustrative examples...",
    "url": "https://example.com/",
    "title": "Example Domain"
  }
}

Step 3: Integrate with Your AI Tool

Claude Code:

mkdir -p .claude/commands/
cp integrations/claude/browser.md .claude/commands/

OpenAI Codex:

mkdir -p ~/.codex/skills/
cp integrations/codex/browser-cli.md ~/.codex/skills/

Cursor / Windsurf / Others: The AGENTS.md file at the project root is automatically read by most AI coding tools.

Now just ask your AI: "Use browser-cli to check the top 5 posts on Hacker News"

Real-World Examples

Example 1: Automated Web Scraping

# Navigate to Hacker News
browser-cli navigate https://news.ycombinator.com

# Extract the top 5 post titles using JavaScript
browser-cli eval "JSON.stringify(
  Array.from(document.querySelectorAll('.titleline > a'))
    .slice(0, 5)
    .map(a => ({title: a.textContent, link: a.href}))
)"

Output:

{
  "command": "eval",
  "status": "success",
  "data": {
    "result": "[{\"title\":\"Show HN: I built a CLI tool for AI agents\",\"link\":\"https://github.com/...\"}, ...]"
  }
}

Example 2: Login and Scrape Protected Content

# First time: log in manually (opens a visible browser)
browser-cli login https://github.com
# ... complete login in the browser window ...
# Press Ctrl+C when done — state is saved to ./github-state.json

# Now automate using the saved login state
browser-cli --state ./github-state.json navigate https://github.com/settings
browser-cli text

The login state persists forever. You can reuse it across sessions, projects, and even different AI agents.

Example 3: Form Submission

browser-cli navigate https://httpbin.org/forms/post

# Fill multiple fields
browser-cli fill "input[name='custname']" "John Doe"
browser-cli fill "input[name='custtel']" "555-1234"
browser-cli fill "input[name='custemail']" "john@example.com"
browser-cli fill "textarea[name='comments']" "This is a test submission"

# Select radio button
browser-cli click "input[value='medium']"

# Submit
browser-cli click "button[type=submit]"

# Get the result
browser-cli text

Example 4: Multi-Step Workflow in One Command

browser-cli run "navigate https://example.com; click a; text; screenshot result.png"

The run command executes multiple actions in a single round-trip, reducing latency for complex workflows.

Example 5: Handle JavaScript Dialogs

browser-cli navigate https://example.com/delete
browser-cli click ".delete-button"

# Check if a dialog appeared
browser-cli dialog-status
# → {"dialog": {"type": "confirm", "message": "Are you sure?"}}

# Accept or dismiss
browser-cli dialog-accept
# or: browser-cli dialog-dismiss

Feature Deep Dive

🥷 Stealth Mode: Bypass Bot Detection

Browser-CLI includes built-in stealth mode that overrides automation fingerprints:

navigator.webdriver — Set to undefined instead of true
navigator.plugins — Faked with realistic entries
navigator.mimeTypes — Includes PDF viewer
window.chrome — Added to match real Chrome
Permissions API — Auto-grants notifications
Chromium flags — Disables AutomationControlled blink feature

This lets you automate sites that normally block bots, like Google sign-in, Cloudflare-protected pages, and banking sites.

# Use system Chrome for even better stealth
browser-cli --chrome navigate https://accounts.google.com

🍪 Login Persistence: Set and Forget

The login command opens a visible browser for you to log in manually. Once done, the entire browser state (cookies + localStorage) is saved to a JSON file:

# Log in once
browser-cli login https://twitter.com
# → saves to ./twitter-login.json

# Reuse forever
browser-cli --state ./twitter-login.json navigate https://twitter.com/home
browser-cli text  # You're already logged in!

🔗 Session Isolation: Parallel Agents

Multiple AI agents can run simultaneously without interfering with each other:

# Agent 1 works on site A
browser-cli --session agent-1 navigate https://site-a.com

# Agent 2 works on site B (completely isolated)
browser-cli --session agent-2 navigate https://site-b.com

# List all active sessions
browser-cli session-list

Each session gets its own browser instance, cookies, and storage.

🎯 Web Components Support

Modern web apps use custom elements that don't respond to standard clicks. Browser-CLI's smart-click detects and triggers internal handlers:

# Normal click might not work on custom elements
browser-cli click "my-custom-button"  # ❌ May fail

# Smart-click finds and calls internal methods
browser-cli smart-click "my-custom-button"  # ✅ Works!

Detection patterns: _on*, _handle*, handle*, _click, _submit, _action

📸 Screenshots, PDFs, and More

# Screenshot
browser-cli screenshot page.png

# Full page PDF (Chromium only)
browser-cli pdf report.pdf

# Screenshot specific element
browser-cli elements ".chart"
browser-cli eval "document.querySelector('.chart').scrollIntoView()"
browser-cli screenshot chart.png

Comparison with Alternatives

Feature	Browser-CLI	Puppeteer	Playwright	browser-use	Actionbook
AI-friendly output	JSON by default	JS API	JS/Python API	Natural language	JSON
Zero-code usage	✅ CLI commands	❌ Scripts	❌ Scripts	✅ LLM-driven	✅ Actions
Session isolation	✅ Built-in	❌ Manual	❌ Manual	❌	✅
Login persistence	✅ Built-in	❌ Manual	❌ Manual	❌	✅
Stealth mode	✅ Built-in	❌ Plugin	❌ Plugin	✅	❌
Web Components	✅ smart-click	❌	❌	✅	❌
Language	Go (single binary)	Node.js	Node/Python	Python	Go
Runtime deps	None	Node.js	Node/Python	Python + deps	None
Setup complexity	Low	Medium	Medium	High	Low

When to use Browser-CLI:

You want AI agents to control browsers directly
You need a simple, script-free automation solution
You want login state persistence
You need to bypass bot detection
You want parallel agent execution

When to use Puppeteer/Playwright:

You're writing traditional test scripts
You need fine-grained control over browser behavior
You're building a testing framework

When to use browser-use:

You want natural language browser control
You're building an LLM-powered application

All Commands Reference

Navigation

Command	Description
`navigate <url>`	Navigate to URL
`back`	Go back in history
`forward`	Go forward in history
`reload`	Reload current page

Interaction

Command	Description
`click <selector>`	Click element
`smart-click <selector>`	Click Web Components
`fill <selector> <value>`	Fill input field
`type <selector> <text>`	Type character by character
`select <selector> <value>`	Select dropdown option
`hover <selector>`	Hover over element
`keyboard <key>`	Press key (e.g., `Ctrl+A`, `Enter`)
`upload <selector> <file>`	Upload file
`eval <script>`	Execute JavaScript

Extraction

Command	Description
`text`	Extract page text
`screenshot [path]`	Take screenshot
`elements <selector>`	Find elements
`pdf [file]`	Save as PDF

Utility

Command	Description
`wait <selector>`	Wait for element
`scroll <up\	down>`
`pick <x> <y>`	Inspect element at coordinates

Tabs & Sessions

Command	Description
`tab-new`	Create new tab
`tab-list`	List all tabs
`tab-switch <id>`	Switch to tab
`session-list`	List active sessions
`stop`	Stop server

Call to Action

Star the repo: https://github.com/zmysysz/browser-cli ⭐

Try it now:

git clone https://github.com/zmysysz/browser-cli
cd browser-cli && make build && make setup-browsers
browser-cli navigate https://example.com
browser-cli text

Integrate with your AI tool:

Claude Code: Copy integrations/claude/browser.md to .claude/commands/
Codex: Copy integrations/codex/browser-cli.md to ~/.codex/skills/
Others: Check the integrations/ folder

Have questions or feature requests? Open an issue on GitHub or drop a comment below!

Browser-CLI is open source under Apache 2.0. Built with Go + Playwright. No CGO required — works on Linux, macOS, and Windows.

Browser-CLI: Let Your AI Agent Control the Browser from the Command Line

zmy — Tue, 02 Jun 2026 10:07:18 +0000

Ever wanted your AI coding assistant to actually use a browser? Not just read web pages, but click buttons, fill forms, take screenshots, and extract data — all from the terminal?

That's exactly why I built Browser-CLI.

What is it?

Browser-CLI is a Go-based command-line tool that wraps Playwright to give AI agents full browser control through simple shell commands. No API keys, no browser extensions, no complex setup — just run a command and you're off.

👉 GitHub: https://github.com/zmysysz/browser-cli

⭐ Stars and feedback are appreciated!

# Install
git clone https://github.com/zmysysz/browser-cli
cd browser-cli && make build && make install
make setup-browsers  # first time only

# Use
browser-cli navigate https://example.com
browser-cli fill "#search" "hello world"
browser-cli click "button[type=submit]"
browser-cli text

Why not just use Playwright directly?

Playwright is great, but it's a library — you need to write code to use it. Browser-CLI turns it into a universal CLI interface that any AI agent can call without writing a single line of automation code.

This means:

Claude Code can browse the web
OpenAI Codex can fill forms and extract data
Cursor can take screenshots and interact with pages
Any AI agent can automate browser tasks through shell commands

Key Features

🤖 AI-First Design — Structured JSON output, auto-managed server, clear command semantics
🔒 Session Isolation — Each agent gets its own browser instance via --session
🍪 Cookie Persistence — Auto save/load, login states preserved across sessions
🌐 Proxy Support — --proxy http://host:port for restricted networks
🎯 Web Components — smart-click and pick for custom elements and Shadow DOM
⌨️ Full Keyboard — Shortcuts, combos, Tab/Enter/Escape, Ctrl+A/C/V
📄 PDF & Screenshot — Export pages as PDF or PNG
📁 File Upload — Upload files to any <input type="file">

30 Commands at a Glance

Category	Commands
Navigate	`navigate`, `back`, `forward`, `reload`
Click	`click`, `click-js`, `smart-click`, `right-click`, `dblclick`
Input	`fill`, `type`, `select`, `keyboard`, `upload`
Extract	`text`, `screenshot`, `elements`, `eval`, `pdf`
Utility	`wait`, `scroll`, `pick`
Tabs	`tab-new`, `tab-list`, `tab-switch`, `tab-close`
Dialogs	`dialog-status`, `dialog-accept`, `dialog-dismiss`
Session	`status`, `stop`, `session-list`, `cookie`

Integration with AI Tools

Browser-CLI ships with ready-to-use integration files:

File	Tool	How to Use
`integrations/claude/browser.md`	Claude Code	Copy to `.claude/commands/`
`integrations/codex/browser-cli.md`	OpenAI Codex	Copy to `~/.codex/skills/`
`AGENTS.md`	Cursor, Windsurf	Already in project root
`skills/browser-cli/SKILL.md`	GAL	Copy to `~/.gal/skills/`

Real-World Example

Here's how an AI agent can search GitHub and extract results:

# Navigate to GitHub
browser-cli navigate https://github.com/search?q=browser+automation

# Extract search results
browser-cli eval "JSON.stringify(
  Array.from(document.querySelectorAll('.repo-list-item a.v-align-middle'))
  .map(a => ({name: a.textContent.trim(), url: a.href}))
)"

# Take a screenshot
browser-cli screenshot github-results.png

Architecture

Browser-CLI uses a client-server architecture over Unix sockets:

AI Agent → shell command → browser-cli (client) → Unix socket → server → Playwright → Browser

The server auto-starts on first command and stays running. Multiple agents can connect simultaneously with isolated sessions.

No CGO Required

Pure Go binary, compiles with CGO_ENABLED=0:

# Static Linux build
make build-static

# Cross-compile for Windows
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o browser-cli.exe .

# Cross-compile for macOS
CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -o browser-cli-mac .

Get Started

git clone https://github.com/zmysysz/browser-cli
cd browser-cli && make build && make install
make setup-browsers
browser-cli navigate https://example.com

Star ⭐ the repo if you find it useful! Feedback and contributions welcome.

This article was drafted with the help of an AI agent — but the tool itself was built by hand. 😉