# Weavetab [Health: Active]

**Category:** 📂 Browser Automation  
**Repository:** https://github.com/Weavetab/mcp  
**GitHub Stars:** 3  
**npm Downloads (last month):** 1337  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/weavetab

## Description
Open automation engine for AI agents. Control live browsers and desktop apps locally.

## Tools
Capabilities this server exposes over MCP:

- **browser_map** — Snapshot interactive DOM with volatile ref IDs that invalidate after DOM mutations. For complex SPAs (e.g. GitHub dashboards), use `scope` or `query` to reduce tokens. For forms/pagination/sequential loops, ALWAYS use `delta: true` to save 97% tokens. For canvas/WebGL/Figma pages where the DOM has < 5 interactive elements, use `visual: "auto"` to get a numbered screenshot — then use browser_click({ mark: N }) to interact.
- **browser_navigate** — Navigate to a URL or launch/focus a configured Electron app.
- **browser_click** — Click a DOM element. Use browser_canvas for charts/canvas. If stuck_warning=true, stop and use browser_map. Pass mark: N to click a numbered element from browser_map({ visual: true/"auto" }) without any DOM re-scan.
- **browser_type** — Type text into an input field or currently focused element. If id/selector/label is omitted, automatically types directly into document.activeElement without needing a redundant click or browser_map. If target is already focused, skips click to prevent unfocus bugs.
- **browser_type_secret** — Inject a secret from an environment variable.
- **browser_key** — Press a keyboard key.
- **browser_scroll** — Scroll the page.
- **browser_dialog** — Accept or dismiss JS dialogs (alert, confirm, prompt). Browser sessions only.
- **browser_burst** — HIGH-SPEED MULTI-ACTION PIPELINE: Executes 2 or more sequential browser actions in a single round-trip without waiting for LLM turns between steps. PREFER THIS over individual single-action calls (e.g. typing + pressing Enter, filling multiple form fields, clicking tabs/buttons then waiting, searching, navigating + reading) to drastically slash latency and token burn. Supports native primitives (browser_click, browser_fill, browser_type, browser_type_secret, browser_navigate, browser_key, browser_scroll, browser_wait, browser_map, etc.) plus ergonomic macro steps (type_and_send, click_and_wait, navigate_and_read, scroll_and_read, fill_form). If compile_from_history: true is passed, automatically compiles recent successful session trail actions into a burst macro.
- **browser_tabs** — Manage browser and Electron app tabs/windows (open, switch, close, list). Specify 'app' when targeting desktop apps (e.g. app: 'discord') to avoid opening web browser.
- **browser_wait** — Pause until a condition is met.
- **browser_captcha** — Autonomous CAPTCHA detection and solving.
- **browser_thoughts** — Agent-to-user communication. Renders in the middle down of the page. Use 'question' mode to ask a free-text question. Use 'feedback' mode to provide status updates, analysis, or decisions. Supports element anchoring (e.g. 'w:15') and presentation styles ('observation', 'decision', 'warning', 'question').
- **browser_pointer** — Advanced pointer control (hover, click, double_click, drag_and_drop, hover_chain). Use hover_chain for Photoshop/Photopea, Figma, and multi-level flyout submenus.
- **browser_select** — Select an option from a native dropdown or custom UI dropdown.
- **browser_fill** — Smart multi-field form-filling and input inspector. Call with scan:true (or empty) to get a lightweight list of all editable inputs on the page without dumping the full DOM. Fill multiple fields in a single turn.
- **browser_highlight** — Highlight elements on page. Supports single or multiple candidates (refs) with styles ('consideration' for candidate evaluation, 'target' for lock-on, 'danger' for destructive actions, 'success', or 'shimmer'), floating badges, and configurable duration.
- **browser_upload** — Upload files to a file input.
- **browser_find** — Instant text & keyword search across page text, labels, and placeholders. Returns matched element coordinates, selectors, and ref IDs.
- **browser_storage** — Manage localStorage and sessionStorage.
- **browser_network_intercept** — Intercept/stub network responses (e.g. mock APIs) OR retrieve captured network telemetry: per-request TLS/SSL certificate details (when the connection exposes them), millisecond timing phases, and failure reasons.
- **browser_console** — 1-5ms latency. Read or clear buffered console API messages, JS exceptions, and network errors.
- **browser_pdf** — Print the current page to a PDF file.
- **browser_eval** — Run arbitrary JS via CDP. Good for extracting app state. Cannot traverse shadow DOM/cross-origin iframes.
- **browser_cookies** — Manage browser cookies.
- **browser_canvas** — For ALL canvas content (charts, games, graphs). Use 'get_image' to read pixels, 'draw' to simulate gestures. Do NOT use browser_click here.
- **browser_scrape** — Sub-5ms latency, zero waste extraction. Best for batch list extraction, table parsing, targeted data mining. Prefer this over browser_map for pure data extraction. Note: XPath selectors lack shadow-DOM support; use CSS selectors for shadow DOMs.
- **browser_snapshot** — Capture or restore an MHTML snapshot. Best for offline archival, replay testing, and compliance audits.
- **browser_screenshot** — 95-135ms capture. Best for visual layout validation, canvas/image inspection. For multimodal models only. Text-only models should use browser_map or browser_canvas instead.
- **browser_viewport** — Set viewport dimensions and device emulation (device presets, geolocation, locale, timezone, color scheme, touch, orientation).
- **browser_clipboard** — Read or write to the system clipboard.
- **browser_inspect** — 15-35ms latency, zero waste. Deep DOM inspection. Useful for debugging failed clicks, verifying z-index & visibility, or computed styles.
- **browser_extract_design** — Extract design tokens (colors, typography, spacing, shadows, CSS variables), semantic HTML layouts, and clean CSS into structured files and an LLM design blueprint. Ideal for cloning websites, UI components, and design systems with 100% pixel fidelity.
- **browser_automation** — Inject self-running background script for monitoring/polling. Cleared on tab close. Don't use persistent scripts for expensive ops.
- **browser_recording** — Record video screencast for compliance/audit. Compiles captured frames into video/animation (.webp, .gif, .webm, .mp4).
- **browser_detect** — CRITICAL INITIALIZATION TOOL. Detect available browsers and configured desktop apps (Discord, Slack, etc.). Call this FIRST before interacting with the environment to know if apps are online/offline and what tabs they have open.
- **browser_performance** — Retrieve page performance metrics: Core Web Vitals (FCP, LCP, CLS, INP, TTFB), JS heap memory, navigation timing, slowest resources, and raw CDP counters.
- **browser_pattern_learn** — Read, register, update, and record execution outcomes for named workflow patterns and site quirks in ~/.weavetab-system/memory/sites/. Use action='get' at session start to inspect a site profile and decide between fast-path replay (reliability ≥ 0.8) or exploratory navigation. Use action='learn' after completing a multi-step flow to persist it. Use action='record_execution' to update reliability scores after replay attempts.
- **browser_office** — Read and extract structured content from office documents (Excel, Word, PDF, CSV). Note: PDF/Word extraction requires local binary dependencies (e.g., poppler) and output is truncated by max_chars/max_rows limits. Two modes:
- **url** — fetch a document URL using the browser's live session cookies (works for authenticated downloads, SharePoint, Google Drive exports, etc). Automatically detects format from URL or MIME type.
- **file** — parse a file that was already downloaded to the local downloads directory (bare filename only, e.g. 'report.xlsx').

Supported formats: .xlsx/.xls (returns per-sheet JSON tables), .docx (returns extracted text), .pdf (returns page text + metadata), .csv (returns row objects).

Use 'list' action first if you don't know what files are in the downloads directory.

DO NOT use browser_scrape or browser_map for binary documents — they cannot read inside Excel, Word, or PDF files.
- **browser_emulate** — Emulate browser conditions over CDP: network throttling (Slow 3G, Fast 3G, 4G, Offline), CPU throttling rate, Geolocation coordinates, Timezone, and User Agent string overrides.
- **browser_checkpoint** — Snapshot and restore browser state (cookies, localStorage, sessionStorage, and scroll/URL) into named checkpoints to time-travel and rollback failed automation branches.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "weavetab": {
    "command": "npx",
    "args": ["-y","@weavetab/mcp"]
  }
}
```

## Documentation

## What Weavetab does

Weavetab exposes browser and desktop automation to MCP clients. It connects directly to live Chromium tabs and registered Electron applications through Chrome DevTools Protocol (CDP) sockets, allowing an agent to navigate pages, inspect interfaces, enter data, manage tabs, and perform UI actions locally.

Its browser representation is a semantic map rather than a full HTML dump. Interactive elements receive session-scoped references, dialogs are surfaced prominently, and repeated link groups can be compressed. Subsequent reads can return only changed nodes through delta mode, which is useful for large single-page applications and repetitive workflows.

The server also includes visual and low-level capabilities. Agents can inspect screenshots, interact with canvas content, control pointer movement, upload files, read console output, inspect network activity, manage cookies and storage, and capture or restore MHTML snapshots. Electron routing lets the same tool family target configured applications such as Discord, VS Code, or Figma.

## How it works

MCP clients communicate with Weavetab over JSON-RPC 2.0. The default launch mode uses stdio; an optional WebSocket mode is available with `--ws`. Local CDP connections and the optional MCP WebSocket listener bind to `127.0.0.1`. WebSocket access uses a shared secret stored under `~/.weavetab-system/ws-secret`, together with Origin and Host header checks.

The main interaction cycle is to navigate or select a tab, obtain a map or targeted extraction, and act on the returned references. `browser_map` supports scoping and queries for complex pages. Delta reads reduce repeated output, while visual mapping can produce numbered screenshot marks for canvas-heavy interfaces; those marks can then be passed to `browser_click`.

`browser_burst` combines multiple browser actions into one round trip. It supports native actions and higher-level sequences such as filling a form, navigating and reading, or scrolling and reading. Recent successful actions can also be compiled into a burst macro.

## Setup and configuration

Node.js 20 or newer is required. The package can be launched without a global installation:

```bash
npx -y @weavetab/mcp
```

A stdio MCP entry can use the following shape:

```json
{
  "mcpServers": {
    "weavetab": {
      "command": "npx",
      "args": ["-y", "@weavetab/mcp"]
    }
  }
}
```

The documented client locations include Claude Desktop, Claude Code, Cursor, VS Code Copilot, Windsurf, and Antigravity. Electron applications are registered in `~/.weavetab/config.json` under an `electron` object, where each name maps to the executable path. Tools can then receive an `app` value to target that process instead of a browser tab.

Secrets can be stored with the Weavetab secrets command and supplied through `browser_type_secret`. Secret values are resolved by the server and masked in responses, snapshots, and audit logs.

## Tools and capabilities

- Navigate to URLs or focus configured Electron applications with `browser_navigate`.
- List, open, switch, and close browser or application tabs with `browser_tabs`.
- Map interactive DOM content with scoped, queried, visual, or delta reads using `browser_map`.
- Find text, scrape structured page data, inspect console output, and capture screenshots or PDFs.
- Click, type, select, scroll, upload files, press keys, fill forms, and control pointer gestures.
- Use `browser_burst` for multi-step actions and reduced round trips.
- Handle JavaScript dialogs, cookies, local storage, session storage, and viewport or device emulation.
- Inspect or stub network responses and retrieve request timing, certificate, and failure details.
- Work with canvas content through image retrieval and simulated drawing.
- Detect and solve supported CAPTCHA flows through CDP mouse interaction without a third-party API.

## Limitations and notes

Reference IDs are tied to the current session and become invalid after DOM mutations, so agents should remap when the page changes. `browser_eval` runs JavaScript through CDP but cannot traverse shadow DOM or cross-origin iframes. XPath selectors do not support shadow DOM in scraping; CSS selectors are required there.

Canvas interaction should use `browser_canvas` rather than ordinary DOM clicks. Text-only models should generally prefer maps or canvas operations over screenshots. Electron automation requires the target application to be registered and available for CDP attachment. The server is designed for local connections and does not describe a cloud relay workflow.

_Full upstream README: https://allmcps.com/mcp/weavetab/readme_