據 AlphaMoat 統計,截至 2026-10,stealthy-auto-browse 累計下載 6,103 次、獲 3 個星標,按累計下載量在本次參與排名的 10,914 個 AI 技能中排名第 4,714 位,在「運維安全」分類(502 個)中排名第 163 位。
列表預設按累計下載量排序,也可按星標排序;詳情頁排名按累計下載量計算。
| 平台 | 累計下載 | 星標 | 評論 |
|---|---|---|---|
| ClawHub ↗ | 6103 | 2 | - |
| SkillHub ↗ | 5867 | 3 | — |
各平台的計數口徑不同,統計時間不一致。
Docker 中抗檢測的無頭瀏覽器自動化,用於授權 QA、相容性測試與防禦性安全研究,採用 Camoufox 與作業系統級輸入。
2026-09 起統計方法調整:同名技能按作者分別統計,並覆蓋全部技能。圖中虛線為調整前的月份,與之後的資料不直接比較,也不計算跨越調整的增長。
| 月份 | 累計下載 | 環比 | 星標 |
|---|---|---|---|
| 2026-10 | 6103 | — | 3 |
| 2026-09 | 5391 | — | 3 |
| 2026-08 | 4909 | +14.4% | 3 |
| 2026-07 | 4291 | +19.0% | 3 |
| 2026-06 | 3605 | +4.4% | 2 |
| 2026-05 | 3454 | — | 2 |
以下是作者釋出的原始檔案,按純文字顯示,本站未做修改或稽核;其中的連結不可點選,命令請核實後再執行。抓取於 2026-10-23。
---
name: stealthy-auto-browse
description: Headless-detection-resistant browser automation in Docker for authorized QA, compatibility testing, and defensive security research. Camoufox + OS-level input + persistent fingerprints. Use only with sites you own or have written authorization to test.
homepage: https://github.com/psyb0t/docker-stealthy-auto-browse
user-invocable: true
metadata:
{ "openclaw": { "emoji": "🕵️", "primaryEnv": "STEALTHY_AUTO_BROWSE_URL", "requires": { "bins": ["docker", "curl"] } } }
---
# stealthy-auto-browse
Browser automation in Docker built for QA against anti-bot stacks, compatibility testing of detection libraries (CreepJS, BrowserScan, Pixelscan, Cloudflare), and defensive security research where standard headless browsers produce false-positive blocks. Uses Camoufox (custom Firefox, no CDP signals) + PyAutoGUI for OS-level input.
For installation, configuration, and container setup, see [references/setup.md](references/setup.md).
## Security & safety
- **Authorized targets only.** This tool is built for QA/testing against sites and systems you own or have written authorization to test. It is not for scraping or automating third-party sites without permission. See "Authorized use only" below before pointing it at anything.
- **Data capture is powerful, so scope it.** `get_text`, `get_html`, `get_interactive_elements`, `eval`, and the screenshot/`save_screenshot` actions can extract full page content, DOM structure, and rendered pixels in one call. Only capture what the authorized test actually needs; don't sweep pages outside scope just because the API makes it easy.
- **Dialogs auto-accept by default, which can approve destructive actions.** The browser accepts `confirm()`, `beforeunload`, and permission prompts automatically unless you called `handle_dialog` with `accept: false` first. An agent must disable or scope auto-accept (call `handle_dialog` with `accept: false` before any step that might raise a dialog) whenever it is acting on a stateful site (one with real data, real accounts, or irreversible actions behind a confirm prompt), and must never drive this tool against a site where an accidental confirm would be harmful. See "Dialogs" below.
- **No auth when `AUTH_TOKEN` is unset.** With it empty the HTTP API and MCP server are **unauthenticated**. Anyone who can reach the port gets full browser control (navigation, input, cookies, screenshots, script execution). **Never** expose such an instance beyond localhost; set `AUTH_TOKEN` and bind to `127.0.0.1` or put it behind an authenticating proxy. See [references/setup.md](references/setup.md).
- **Loaders execute automatically on matching URLs.** Only mount loader YAML you wrote or audited. See "Page loaders" below.
## Authorized use only
This tool is intentionally hard to fingerprint as automation. That makes it dangerous if misused. Only use it for:
- Sites you own or operate
- Sites you have **written authorization** to test (security engagements, bug bounty in-scope targets)
- Your own anti-bot / fraud detection stack for QA and regression testing
- Detection-library research in a controlled environment
- Compatibility testing where a detection stack misclassifies legitimate automation as malicious
**Do not** use this to evade access controls, scrape sites against their ToS, automate logged-in activity on accounts you don't own, abuse rate limits, or bypass CAPTCHAs you weren't authorized to bypass. Many jurisdictions criminalize unauthorized access regardless of technical means. The maintainer is not responsible for misuse.
If you're unsure whether your use case is authorized, it isn't. Stop and get written permission first.
## When to use
- Validating that your own anti-bot rules behave correctly under realistic automation
- Compatibility / regression testing where another headless browser is wrongly flagged
- Authorized pentests / bug bounty on in-scope targets that require human-like interaction
- Maintaining a stable test session against your own site or a sanctioned staging environment
## When not to use
- Any site you don't own or aren't explicitly authorized to test
- Scraping content protected by ToS, paywalls, or rate limits
- Driving real (non-test) user accounts on third-party services
- Static HTML: use `curl` or `WebFetch`
- Sites with no detection layer: use a normal browser skill
## Setup
The API should already be running. Set the base URL:
```bash
export STEALTHY_AUTO_BROWSE_URL=http://127.0.0.1:8080
```
**Verify:** `curl $STEALTHY_AUTO_BROWSE_URL/health` returns `ok`.
Recommended defaults: bind to `127.0.0.1`, set `AUTH_TOKEN` to a strong random value, and do not expose port 5900 to anything beyond localhost. See [references/setup.md](references/setup.md).
## HTTP API
All commands: `POST $STEALTHY_AUTO_BROWSE_URL/` with JSON body `{"action": "name", ...params}`.
**`AUTH_TOKEN` is required for any non-localhost deployment.** When set, include it on every request (except `/health`):
```
Authorization: Bearer <key>
```
Query-string authentication is not supported because URLs leak into logs.
In single-instance mode, the server serializes requests automatically. Only one runs at a time and the rest queue up.
Every response:
```json
{
"success": true,
"timestamp": 1234567890.123,
"data": { ... },
"error": "only when success is false"
}
```
## Two input modes
### System input: OS-level events
Uses PyAutoGUI for real OS-level mouse/keyboard events. The browser doesn't see synthetic DOM events. Use only for legitimate detection-stack testing where the stack incorrectly blocks DOM-event automation.
- `system_click`: move along a human path to the target, then press with a human hold (viewport x,y of the target centre, plus its w,h)
- `mouse_move`: move without clicking (hover menus, tooltips)
- `mouse_click`: click where the pointer is, or move to x,y first
- `system_type`: type with real key holds, human rhythm, Shift before capitals; optional self-correcting typos
- `send_key`: press a key or combo (`enter`, `tab`, `ctrl+a`)
- `scroll`: mouse wheel scroll, one notch at a time (negative = down)
Get viewport coordinates and sizes (`x`, `y`, `w`, `h`) from `get_interactive_elements` and pass all four to `system_click`.
Timing is modeled on human motor data and is consistent per container. Override it per request when needed: `speed`, `curvature`, `tremor`, `click_hold`, `click_delay` on pointer actions; `interval`, `key_hold`, `rollover`, `typos`, `typo_rate` on `system_type`; `key_hold` or `instant: true` (no human timing) on `send_key`; `notch_gap` on wheel actions; `max_gestures`, `return_to_top`, `scroll_back`, `drift` on `scroll_to_bottom_humanized`. Pointer actions return `landed_at`. Full table: [Humanized Input](https://github.com/psyb0t/docker-stealthy-auto-browse/blob/main/docs/api.md#humanized-input).
### Playwright input: DOM events
Uses Playwright's DOM events. Faster, uses CSS selectors/XPath, distinguishable as automation.
- `click`: click by selector
- `fill`: set input value instantly
- `type`: type into element character-by-character
### Which to use
- **Clicking:** always try `click` with a CSS selector first. It is fast and reliable.
Only fall back to `system_click` if your authorized test target requires OS-level input.
It re-measures the window position itself, so no `calibrate` call is needed.
- **Typing:** `fill` for inputs (fast). `system_type` only when the test target requires OS-level input.
- **No detection layer in scope?** Playwright input (`click`, `fill`) is fine.
- **Testing OS-input behavior of your own detection stack?** Use system input.
## Typical workflow
1. `goto` → load the page
2. `get_text` → read what's on the page
3. `get_interactive_elements` → find buttons/inputs with selectors and x,y coords
4. `click` (CSS selector) → interact; fall back to `system_click` only when test scope requires
5. `wait_for_element` / `wait_for_text` → wait for results
6. `get_text` → verify
## Actions reference
### Navigation
```json
{"action": "goto", "url": "https://example.com"}
{"action": "goto", "url": "https://example.com", "wait_until": "networkidle"}
{"action": "goto", "url": "https://example.com", "referer": "https://google.com/search?q=stuff"}
{"action": "refresh"}
{"action": "refresh", "wait_until": "networkidle"}
```
`wait_until`: `"domcontentloaded"` (default), `"load"`, `"networkidle"`.
`referer`: set HTTP Referer header (for sites that check referrer).
Response: `{"url": "...", "title": "..."}`
### System input (OS-level)
```json
{"action": "system_click", "x": 500, "y": 300, "w": 120, "h": 40}
{"action": "system_click", "x": 500, "y": 300, "w": 120, "h": 40, "speed": 1.5, "click_hold": 0.15}
{"action": "mouse_move", "x": 500, "y": 300}
{"action": "mouse_click", "x": 500, "y": 300}
{"action": "mouse_click"}
{"action": "system_type", "text": "hello world"}
{"action": "system_type", "text": "a comment", "typos": true}
{"action": "system_type", "text": "hello world", "interval": 0.12, "key_hold": 0.09}
{"action": "send_key", "key": "enter"}
{"action": "send_key", "key": "ctrl+a"}
{"action": "send_key", "key": "enter", "instant": true}
{"action": "scroll", "amount": -3}
{"action": "scroll", "amount": -3, "x": 500, "y": 300, "notch_gap": 0.1}
```
`system_type` only makes typos on plain text fields and always corrects them; on password, email, maxlength and similar fields the response has `"typos": false` and a `typos_disabled_reason`.
### Playwright input (DOM events)
```json
{"action": "click", "selector": "#submit-btn"}
{"action": "click", "selector": "xpath=//button[@id='submit']"}
{"action": "fill", "selector": "input[name='email']", "value": "[email protected]"}
{"action": "type", "selector": "#search", "text": "query", "delay": 0.05}
```
### Page inspection
> Combined with screenshots (below) and script/run_script mode, these actions let one call extract full page text, DOM structure, and rendered pixels. That is powerful data capture. Use only against authorized targets and only pull what the test actually needs; this is not a general-purpose scraping tool for sites you don't have permission to collect from.
```json
{"action": "get_interactive_elements"}
{"action": "get_interactive_elements", "visible_only": true}
{"action": "get_text"}
{"action": "get_html"}
{"action": "get_page_info"}
{"action": "detect_challenge"}
{"action": "get_element", "selector": "main article"}
{"action": "get_elements", "selector": "main article a", "limit": 25}
{"action": "get_computed_style", "selector": "main article", "properties": ["display", "font-size"]}
{"action": "eval", "expression": "document.title"}
{"action": "eval", "expression": "document.querySelectorAll('a').length"}
{"action": "eval", "expression": "document.title", "world": "isolated"}
```
`eval` runs in the page's own JavaScript world by default, so it can read globals a site defines (`window.__NEXT_DATA__`). With `"world": "isolated"` it sees only the DOM, and page scripts cannot observe or hook it. Prefer `isolated` for DOM reads on sites that watch for automation.
`get_interactive_elements` returns all buttons, links, inputs with `x`, `y`, `w`, `h`, `text`, `selector`, `visible`. Pass `x`, `y`, `w`, `h` to `system_click` so the click lands at a human offset inside the element.
`get_text` returns visible page text (truncated to 10,000 chars). Call this first after navigating.
For structured extraction, use `get_element` for one matching node or `get_elements` for a bounded list. `get_page_info` returns document/viewport state, and `get_computed_style` exposes selected CSS values without a custom JavaScript expression.
### Challenge detection
`detect_challenge` is read-only, best-effort detection for authorised QA flows that need to request human review. It returns `absent`, `present`, or `unknown`, plus bounded known-vendor or generic low-confidence evidence. It never clicks, solves, submits, or enters a challenge frame, and excludes query strings, fragments, site keys, response values, page text, and HTML from the result. Set `scroll_into_view: true` to bring the first visible detected frame or widget into the viewport for VNC handoff; it still never clicks or focuses it. It recognises documented Turnstile, reCAPTCHA, hCaptcha, Friendly Captcha, ALTCHA, Arkose, AWS WAF, and GeeTest signals when exposed in the top-level page.
Use an `output_id` plus a script `if` output condition to decide whether your orchestration should notify a person. In cluster mode, place `detect_challenge` inside `run_script`.
### Virtual camera and microphone
For authorized camera/microphone compatibility tests, mount test media at `/media` and configure `VIRTUAL_CAMERA_FILE` and/or `VIRTUAL_MICROPHONE_FILE` before the browser starts. A page's `navigator.mediaDevices.getUserMedia()` call then receives tracks captured from those files. A request for an unconfigured kind fails with `NotFoundError` rather than falling back to hardware. This virtualizes streams only; it does not add native devices to `enumerateDevices()`. Source files must remain within `VIRTUAL_MEDIA_DIR` (default `/media`) and the browser must restart after static-source changes.
Set `VIRTUAL_MEDIA_DYNAMIC=true` to switch file-backed sources at runtime. `set_virtual_media_source` takes `kind` (`"camera"` or `"microphone"`) plus an existing relative `source` name; `upload_virtual_media` takes `kind`, a safe `filename` whose declared media type matches that kind, strict base64 `content_base64`, and optional `activate`. The filename supplies only the extension: the service generates and returns a collision-safe stored basename and never overwrites a named source. It checks decoded uploads with `ffprobe` for the requested video or audio stream before storage or activation. Uploads are limited to `VIRTUAL_MEDIA_UPLOAD_MAX_BYTES` (50 MiB by default) and need a writable `VIRTUAL_MEDIA_DIR`. Already acquired page streams retain their track identities after a source switch. The service accepts only files inside the configured media directory, never arbitrary paths, remote URLs, WebSocket streams, or other live ingress. These actions require the same Bearer authorization as every other action when `AUTH_TOKEN` is set. See [references/setup.md](references/setup.md).
### Screenshots
```bash
# Browser viewport
curl -s "$STEALTHY_AUTO_BROWSE_URL/screenshot/browser?whLargest=512" -o screenshot.png
# Full desktop
curl -s "$STEALTHY_AUTO_BROWSE_URL/screenshot/desktop?whLargest=512" -o desktop.png
```
Resize params: `whLargest=512` (recommended), `width=800`, `height=300`, `width=400&height=400`.
Via action (for script mode, returns base64 with `output_id`):
```json
{"action": "save_screenshot"}
{"action": "save_screenshot", "type": "desktop"}
{"action": "save_screenshot", "output_id": "my_screenshot", "whLargest": 512}
{"action": "save_screenshot", "path": "/output/page.png"}
```
### Screen recording
Captures actual rendered pixels (ffmpeg `x11grab` against the Xvfb display) including the OS-level mouse cursor, so PyAutoGUI moves are visible. One active recording per container; a second `start_recording` while one is active returns an error. **Requires `/recordings` mounted as a host volume.** See [references/setup.md](references/setup.md). If not mounted (or not writable), `start_recording` fails fast.
```json
{"action": "start_recording"}
{"action": "start_recording", "mode": "viewport", "fps": 30}
{"action": "start_recording", "mode": "desktop", "show_cursor": false}
{"action": "recording_status"}
{"action": "stop_recording", "slug": "my-flow"}
```
`mode`: `"window"` (default, full Camoufox window incl. chrome), `"viewport"` (crops chrome using the page position measured at start), `"desktop"` (entire Xvfb screen). `fps`: 1-60, default 15. `show_cursor`: bool, default `true`. Set `false` to record without the OS-level cursor sprite.
`start_recording` returns `recording_id`, `tmp_path`, `show_cursor`, `capture_size`. `stop_recording` finalizes and renames the tmp file to `/recordings/<slug>.mp4`. `slug` must match `[a-zA-Z0-9][a-zA-Z0-9_-]{0,62}` (no path traversal); `stop_recording` saves a colliding slug as `<slug>-2.mp4`, etc. Returns `path`, `duration_s`, `size_bytes`. `recording_status` returns `{"active": true, "recording_id", "mode", "started_at", "elapsed_s", "tmp_path"}` when recording, `{"active": false}` otherwise.
Encoder: H.264 (`libx264`), `-preset ultrafast`, `-crf 28`, `yuv420p`, tuned for low CPU over file size on browser footage.
**Cluster mode:** recording actions are only usable from inside `run_script`. Outside it, the script-only restriction rejects them. `start_recording` and `stop_recording` must live in the **same** `run_script` call so both hit the same browser instance:
```json
{"action": "run_script", "steps": [
{"action": "start_recording", "mode": "viewport", "fps": 20},
{"action": "goto", "url": "https://example.com", "wait_until": "networkidle"},
{"action": "stop_recording", "slug": "example-page"}
]}
```
### Wait conditions
Use these instead of `sleep`.
```json
{"action": "wait_for_element", "selector": "#results", "state": "visible", "timeout": 10}
{"action": "wait_for_text", "text": "Search results", "timeout": 10}
{"action": "wait_for_url", "url": "**/dashboard", "timeout": 10}
{"action": "wait_for_network_idle", "timeout": 30}
```
`state`: `"visible"` (default), `"hidden"`, `"attached"`, `"detached"`.
### Tabs
```json
{"action": "list_tabs"}
{"action": "new_tab", "url": "https://example.com"}
{"action": "switch_tab", "index": 0}
{"action": "close_tab", "index": 1}
```
### Dialogs
> **Dialogs are auto-accepted by default.** If a scripted step raises an unexpected `confirm()` / `beforeunload` / permission prompt, the browser **will** accept it automatically, which can confirm a destructive or irreversible action. When a run might hit a dialog you don't want accepted, call `handle_dialog` with `accept: false` **before** the triggering action, and review your scripts for steps that could raise one.
>
> **Agent guardrail:** when driving a stateful site (real accounts, real data, or any confirm/permission prompt that could trigger an irreversible action), disable or scope auto-accept first. Call `handle_dialog` with `accept: false` before the step that might raise the dialog, and only re-enable acceptance for a specific, expected prompt you intend to approve. Never run this tool against a site where an accidental confirm would be harmful.
Call `handle_dialog` **before** the action that triggers the dialog.
```json
{"action": "handle_dialog", "accept": true}
{"action": "handle_dialog", "accept": false}
{"action": "handle_dialog", "accept": true, "text": "prompt response"}
{"action": "get_last_dialog"}
```
### Cookies
```json
{"action": "get_cookies"}
{"action": "get_cookies", "urls": ["https://example.com"]}
{"action": "set_cookie", "name": "session", "value": "abc", "url": "https://example.com"}
{"action": "delete_cookies"}
```
### Storage
```json
{"action": "get_storage", "type": "local"}
{"action": "set_storage", "type": "local", "key": "theme", "value": "dark"}
{"action": "clear_storage", "type": "local"}
```
`type`: `"local"` (default) or `"session"`.
### Downloads & uploads
```json
{"action": "get_last_download"}
{"action": "upload_file", "selector": "#file-input", "file_path": "/tmp/doc.pdf"}
```
### Clipboard
These actions use the real X11 text clipboard shared by Camoufox and noVNC. Text is limited to 1 MiB of UTF-8 data and is not written to request logs.
```json
{"action": "set_clipboard", "text": "paste me"}
{"action": "get_clipboard"}
```
Both are dedicated MCP tools. In cluster mode, put them inside one `run_script` call.
### Network logging
```json
{"action": "enable_network_log"}
{"action": "get_network_log"}
{"action": "clear_network_log"}
{"action": "getclear_network_log"}
{"action": "disable_network_log"}
```
### Console logging
Capture `console.log`, `console.error`, `console.warn`, etc. Each entry has `type`, `text`, `location`, `timestamp`.
```json
{"action": "enable_console_log"}
{"action": "get_console_log"}
{"action": "clear_console_log"}
{"action": "getclear_console_log"}
{"action": "disable_console_log"}
```
### Scrolling
```json
{"action": "scroll_to_bottom", "delay": 0.4}
{"action": "scroll_to_bottom_humanized", "min_clicks": 2, "max_clicks": 6, "delay": 0.5}
{"action": "scroll_to_bottom_humanized", "delay": 1.5, "scroll_back": 0.1, "return_to_top": false}
```
`scroll_to_bottom` uses JS (fast). `scroll_to_bottom_humanized` scrolls like a reader with the OS-level wheel: gestures, reading pauses around `delay`, pointer drift, occasional scroll-backs, and Home (wheel flicks when a text field has focus) to return to the top.
### Display
```json
{"action": "calibrate"}
{"action": "get_resolution"}
{"action": "set_color_scheme", "scheme": "dark"}
{"action": "enter_fullscreen"}
{"action": "exit_fullscreen"}
```
`calibrate` returns the current `window_offset`. OS-level pointer actions and `viewport` recordings measure it themselves, so you never have to call it.
### Multi-step scripts
Run multiple actions as one atomic request. Steps with `output_id` collect results.
```json
{"action": "run_script", "steps": [
{"action": "goto", "url": "https://example.com", "wait_until": "domcontentloaded"},
{"action": "sleep", "duration": 2},
{"action": "get_text", "output_id": "text"},
{"action": "eval", "expression": "document.title", "output_id": "title"}
]}
```
Also accepts `"yaml": "..."` with the same YAML format used in script mode.
`on_error`: `"stop"` (default) or `"continue"`.
### Utility
```json
{"action": "ping"}
{"action": "sleep", "duration": 2}
{"action": "close"}
```
### State endpoints (GET)
```bash
curl $STEALTHY_AUTO_BROWSE_URL/health # "ok" when ready
curl $STEALTHY_AUTO_BROWSE_URL/state # {"status", "url", "title", "window_offset"}
```
## MCP server
The browser exposes all actions as MCP tools via Streamable HTTP at `/mcp/` on the same port as the HTTP API.
```
http://127.0.0.1:8080/mcp/
```
Connect any MCP-compatible client to that URL. All actions from the HTTP API are available as tools. Dedicated tools include `goto`, `screenshot`, `system_click`, `system_type`, `eval_js`, `get_text`, `set_clipboard`, `get_clipboard`, `detect_challenge`, `click`, `fill`, `run_script` (multi-step), and `browser_action` (generic fallback for everything else, such as cookies, tabs, storage, dialogs, downloads, logging, and recording).
If `AUTH_TOKEN` is set, configure the MCP client to send `Authorization: Bearer <key>` when connecting to `http://127.0.0.1:8080/mcp/`.
Works in both standalone and cluster mode. In cluster mode, only `run_script` is available (same restriction as HTTP API).
## Cluster mode
Run multiple browser instances behind HAProxy with a request queue, sticky sessions, and Redis cookie sync. For setup see [references/setup.md](references/setup.md).
Entry point is `http://127.0.0.1:8080`, with the same API. HAProxy queues requests when all instances are busy instead of returning errors.
**Script-only enforcement (v1.0.0+):** When `NUM_REPLICAS > 1`, both the HTTP API and MCP server only allow `run_script`, `ping`, and `sleep`. They reject all other individual actions. Use `run_script` to bundle multiple actions into a single atomic request. One request = one routing decision = one browser instance handles the entire sequence. All actions remain available as steps inside `run_script`.
**Sticky sessions:** HAProxy sets an `INSTANCEID` cookie. Send it back on subsequent requests to keep routing to the same browser instance. All browser state (tabs, DOM, JS, local storage) lives on that specific container. Only cookies sync via Redis.
**Redis cookie sync:** Cookies set on any instance propagate to all others instantly via PubSub. Authenticate once against your own test target and the whole fleet shares the session.
## Script mode
Pipe a YAML script via stdin, get JSON results on stdout, container exits. No HTTP server.
```bash
cat my-script.yaml | docker run --rm -i \
-e TARGET_URL=https://example.com \
psyb0t/stealthy-auto-browse:latest \
--script > results.json
```
### Script format
```yaml
name: Scrape Example
on_error: stop # "stop" (default) or "continue"
steps:
- action: goto
url: ${env.TARGET_URL}
wait_until: networkidle
- action: sleep
duration: 2
- action: save_screenshot
output_id: screenshot
- action: get_text
output_id: page_text
- action: eval
expression: "document.title"
output_id: title
```
### Output
```json
{
"name": "Scrape Example",
"success": true,
"steps_executed": 5,
"steps_total": 5,
"duration": 3.42,
"step_results": [ ... ],
"outputs": {
"screenshot": "data:image/png;base64,iVBOR...",
"page_text": { "text": "...", "length": 1234 },
"title": { "result": "Example Domain" }
}
}
```
- **`output_id`** on any step collects its result into `outputs`. Screenshots become base64 data URIs.
- **`${env.VAR_NAME}`** substitutes environment variables.
- **`on_error: continue`** keeps going past failures. `stop` (default) halts.
- **Control flow:** `if` conditions can inspect elements, text, URL globs, JavaScript booleans, and prior outputs. `repeat` and `while` require explicit bounds (1-100 iterations); a `while` that remains true at its bound fails visibly. See the [control-flow reference](https://github.com/psyb0t/docker-stealthy-auto-browse/blob/main/docs/script-mode.md#control-flow) for the complete schema and limits.
- **All HTTP API actions** work as script steps.
- **Logs go to stderr**, stdout is clean JSON.
- **Exit code** 0 on success, 1 on failure.
### Example: screenshot + extract (against your own site)
```bash
cat <<'EOF' | docker run --rm -i -e URL=https://staging.your-site.example \
psyb0t/stealthy-auto-browse:latest \
--script > results.json
name: Quick Scrape
steps:
- action: goto
url: ${env.URL}
wait_until: networkidle
- action: save_screenshot
output_id: screenshot
whLargest: 1024
- action: get_text
output_id: text
- action: eval
expression: "document.title"
output_id: title
EOF
```
## Page loaders (URL-triggered automation)
Mount YAML files to `/loaders`. When `goto` hits a matching URL, the loader's steps execute instead of normal navigation. Works in both API and script mode.
> **Loaders run automatically the moment the browser visits a matching URL**, with no fresh confirmation at that point, and their steps can modify page state (`eval`, clicks, form fills). Only mount loaders you wrote or audited, and **review every loader YAML before mounting it.** Don't mount loader files from an untrusted source.
```bash
docker run -d -p 127.0.0.1:8080:8080 -v ./my-loaders:/loaders \
psyb0t/stealthy-auto-browse:latest
```
In script mode:
```bash
cat script.yaml | docker run --rm -i \
-v ./my-loaders:/loaders \
psyb0t/stealthy-auto-browse:latest \
--script
```
### Loader format
```yaml
name: News Site Cleanup
match:
domain: news-site.com # exact hostname (www. stripped)
path_prefix: /articles # path starts with
regex: "article/\\d+" # full URL regex
steps:
- action: goto
url: "${url}" # ${url} = original URL
wait_until: networkidle
- action: eval
expression: "document.querySelector('.cookie-banner')?.remove()"
- action: wait_for_element
selector: "article"
timeout: 10
```
Match fields are optional but at least one is required. All specified fields must match.
## Account & session hygiene
Persistent profiles let cookies, sessions, and fingerprints survive restarts. Use them responsibly:
- **Test accounts only.** Provision isolated accounts dedicated to QA on your own systems. Never persist sessions for real (production / personal / customer) accounts you don't own.
- **Treat the profile volume as a secret.** It contains live session cookies. Back it up encrypted or not at all, and shred it (`rm -rf ./profile`) when the test run is done.
- **Don't share profile volumes across environments.** A profile built against staging shouldn't be reused against prod or vice versa.
- **Rotate credentials after authorized testing concludes** if humans also use the same accounts.
## Tips
1. **Read text, not pixels.** Always try `get_text` or `get_html` first; screenshots are last resort
2. **Screenshots: use `whLargest=512`.** Full resolution wastes tokens; fine detail is rarely needed
3. **Prefer `click` with CSS selector.** It is reliable and fast; use `system_click` only when scope requires OS-level input
4. **Always `get_interactive_elements` before clicking.** It gets both selectors and coordinates
5. **Match TZ to IP location.** A timezone mismatch is a fingerprint inconsistency that breaks realistic test scenarios
6. **Wait conditions over sleep:** `wait_for_element`, `wait_for_text`, `wait_for_url`
7. **`handle_dialog` before the trigger.** Otherwise the browser auto-accepts dialogs
鍾馗.Skill——會更新漏洞庫的安全審查專家。直來直去、快刀斬亂麻,三層審查(靜態審計/行為模擬/供應鏈溯源)覆蓋12類風險,輸出結構化安全裁定(✅乾淨/⚠️可疑/🚫惡意)。Use when 使用者說"審查這個Skill"、"安全檢查"、"鍾馗看下"、"審一下"、"查一下這個skill"、安裝Skill前的安全評估、或需要審計SKILL.md的惡意載荷。
在使用技能包之前做安全掃描,並按結論決定放行或攔截的技能。
為 OpenClaw 配置 OpenRouter 免費模型與回退鏈的工具。
Parse, search, and analyze application logs across formats. Use when debugging from log files, setting up structured logging, analyzing error patterns, correlating events across services, parsing stack traces, or monitoring log output in real time.
用於安裝技能、包或外掛的安全檢查。請在執行任何 npm install、openclaw plugins install、clawhub install 或類似安裝命令之前使用。
網路安全與SRC漏洞掘金實戰技能。融合「系統學習路徑」與「SRC實戰掘金」雙模式: ①學習模式=法律→基礎→工具→靶場→攻防→就業全流程; ②實戰模式=直接指導在騰訊TSRC、阿里ASRC、百度BSRC等平台挖掘高價值漏洞變現。 當用戶提出以下問題時觸發: "我想學網路安全怎麼入門""SRC漏洞怎麼挖能賺錢""滲透測試需要學什麼" "Web安全漏洞原理是什麼""怎麼準備CTF比賽""護網面試會問什麼" "雲安全怎麼學""挖漏洞賺錢的方法""埠掃描指令碼怎麼寫" "SQL隱碼攻擊怎麼檢測""子域名怎麼列舉""XSS漏洞怎麼找" "靶場怎麼搭建""Kali Linux怎麼用""Metasploit怎麼入門" "等保測評是什麼""程式碼審計怎麼做""內網滲透怎麼學" "資訊洩露漏洞怎麼挖""越權漏洞怎麼測試""邏輯漏洞挖掘技巧" "簡歷怎麼寫才能進安全公司""安全行業面試題有哪些" "Burp Suite怎麼用""DVWA怎麼安裝""Pikachu靶場搭建" "Vulhub漏洞復現""網路安全法有什麼規定""CTF奪旗賽怎麼參加" "AWD比賽是什麼""應急響應怎麼做""攻擊溯源怎麼搞" "資料安全怎麼保障""公有云安全怎麼防護""私有云攻防怎麼做" "雲原生安全是什麼"。
這個技能特別簡單——你只需要呼叫它,給一個網站域名,它就會自動幫你跑一遍滲透測試,找出這個網站存在哪些安全漏洞。 不需要你配環境、不用你手動發包,一切自動化。測完直接出結果,告訴你哪裡有問題、怎麼修。 它的願景是:讓每個人都能成為白帽駭客——只要輸入一個域名,就能知道自己的網站安不安全。一切只為授權測試,只為發現漏洞、修復風險,讓網際網路更安全。
Security-first skill vetting for AI agents. Use before installing any skill from ClawdHub, GitHub, or other sources. Checks for red flags, permission scope, and suspicious patterns.
資料月份:2026-10 · 下載/星標數聚合自公開技能註冊庫(ClawHub、SkillHub),按月更新。口徑說明見資料方法。