gomoufox MCP server
Commit 29. Okt. 2026Bietet einen Go-Driver und einen MCP server zum Starten und Steuern des Camoufox Browser-Stacks für automatisierte Web-Interaktionen.
Auch bekannt als ehmo/gomoufox
- Stars
- 25
- Tools
- —
- Downloads, 30 Tage
- —
- Neueste Version
- —
- Letzter Commit
- 29. Okt. 2026
- Lizenz
- —
Was ist gomoufox MCP?
Bietet einen Go-Driver und einen MCP server zum Starten und Steuern des Camoufox Browser-Stacks für automatisierte Web-Interaktionen.
Zusammenfassung generiert aus dem README des Projekts
Über gomoufox MCP server
gomoufox ermöglicht es Entwicklern, die Go, Shell-Skripte oder AI Agents nutzen, Web-Interaktionen über den Camoufox Browser-Stack zu automatisieren. Es bietet einen typisierten Driver und einen MCP server, mit dem Nutzer Browser starten und steuern können, ohne Python-Glue-Code schreiben zu müssen. Das System unterstützt die lokale Ausführung über eine Go-verwaltete node-direct Runtime oder die Remote-Ausführung über einen containerisierten Daemon unter Verwendung eines Bearer-Tokens zur Authentifizierung.
Nutzer können den Server über die Setup- und Agents-Install-Commands in Agents wie Claude, Cursor oder Gemini integrieren. Der Server bietet eine Vielzahl spezialisierter Tools, darunter Screenshot-Generierung, das Abrufen von Markdown-Inhalten und interaktive Traffic-Erfassung via HAR-Recording. Er ist für Entwickler konzipiert, die Browser-Lifecycles verwalten, Netzwerk-Requests abfangen oder authentifizierte Sessions mithilfe von gespeicherten State-Files automatisieren müssen.
Was du damit machen kannst
- 1Web-Aufgaben mit AI Agents automatisierenEin AI Agent kann den MCP server nutzen, um mithilfe integrierter Browser-Tools mit Websites zu interagieren.
- 2Netzwerk-Traffic zum Debugging erfassenEntwickler können den Workflow eines Nutzers in einer HAR-Datei aufzeichnen, um Netzwerk-Requests und Responses zu inspizieren.
- 3Headless Browser Automation in Go durchführenGo-Programmierer können die Library nutzen, um eine Browser-Instanz zu steuern und spezifische URLs aufzurufen.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
Konfiguration
GOMOUFOX_DAEMON_TOKEN
| Name | Beschreibung | Typ |
|---|---|---|
| GOMOUFOX_DAEMON_TOKEN | — |
Automatisierte Checks
Geluften am 14. Nov. 2026Vollständiger Bericht →Noch nicht verifiziert. Ein Server benötigt einen Score von 80, keine kritischen Befunde und genug Daten für unsere Prüfung. Wie die Checks funktionieren · Was du für mehr Punkte verbessern kannst
- Source Repository verknüpft und erreichbarehmo/gomoufox is public and reachablegithub.com/ehmo/gomoufox ↗Bestanden
- Paket nennt dieses Repository als QuelleNicht geprüft
- Build-Provenienz (Sigstore-Attestierung)Nicht geprüft
- Open Source Lizenz (OSI)No licenseBefund
- Commit oder Release im letzten JahrLast commit or release 2026-10-29github.com/ehmo/gomoufox ↗Bestanden
- OpenSSF ScorecardNicht geprüft
- Package-Name ähnelt keinem populären PackageNicht geprüft
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenNicht geprüft
- Keine versteckten Anweisungen an das Modell0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersBestanden
- Destruktive Tools sind markiertNicht geprüft
- Remote-Endpoint beantwortet den MCP-HandshakeNicht geprüft
README
Auf GitHub ansehengomoufox
gomoufox is a Go driver for Camoufox.
It gives Go programs, shell scripts, and MCP agents a typed way to launch and control the pinned Camoufox browser stack without writing Python glue.
Use it only on sites you own, test, or have permission to automate.
Add gomoufox to an agent
Install the bundled skills and MCP server config in one step:
gomoufox setup --dry-run
gomoufox setup --target all --features skills,mcp --yes
gomoufox agents install --target all --features skills,mcp --dry-run --json
gomoufox agents install --target all --features skills,mcp
Use --target codex, claude, cursor, or gemini to install for one
agent. Use --scope project when you want repo-local MCP config. The default
writes skill files plus a stdio MCP entry that runs
gomoufox mcp --toolset core.
Run the dry run first. It prints the exact files gomoufox would write. Without
--force, exact skill matches report unchanged; differing files report needs_force
and the apply step stops until you pass --force. MCP config files are merged.
JSON plans use wrote, updated, and unchanged for applied actions;
dry-run actions use would_write, would_update, unchanged, or needs_force.
At a glance
| Need | Use |
|---|---|
| Go browser automation | github.com/ehmo/gomoufox |
| Shell automation | gomoufox get, gomoufox screenshot, gomoufox fetch |
| Containerized remote browser | ghcr.io/ehmo/gomoufox plus gomoufox --server |
| Interactive traffic capture | gomoufox record |
| Agent browser tools | gomoufox mcp |
| Guided setup | gomoufox setup, gomoufox agents install |
| Release evidence | docs/BENCHMARKS.md |
flowchart LR
GoApp["Go app"] --> GoAPI["Go API"]
Shell["Shell script"] --> CLI["gomoufox CLI"]
Agent["Agent"] --> Skills["SKILL.md"]
Skills --> MCP["gomoufox mcp"]
GoAPI --> Sidecar["gomoufox sidecar"]
CLI --> Sidecar
MCP --> Sidecar
Sidecar --> Camoufox["Pinned Camoufox"]
Camoufox --> Web["Permitted sites"]
classDef api fill:#00ADD8,color:#ffffff,stroke:#00758f;
classDef agent fill:#7c3aed,color:#ffffff,stroke:#5b21b6;
classDef browser fill:#f97316,color:#ffffff,stroke:#c2410c;
classDef web fill:#16a34a,color:#ffffff,stroke:#15803d;
class GoAPI,CLI api;
class Agent,Skills,MCP agent;
class Sidecar,Camoufox browser;
class Web web;
Install
Library:
go get github.com/ehmo/gomoufox
CLI:
go install github.com/ehmo/gomoufox/cmd/gomoufox@latest
gomoufox -h
gomoufox install
gomoufox doctor
Homebrew:
brew tap ehmo/gomoufox https://github.com/ehmo/gomoufox
if brew commands | grep -qx trust; then
brew trust --formula ehmo/gomoufox/gomoufox
fi
brew install gomoufox
gomoufox install
gomoufox doctor
Install through the tap. The release gomoufox.rb file is there for audit and
tap metadata; Homebrew wants formulae inside taps. Run brew trust only if your
Homebrew build still has that command.
Docker and remote commands
The official Linux amd64 image runs the authenticated gomoufox daemon with the pinned node-direct runtime already installed. Keep the host port on loopback when the client runs on the same host:
export GOMOUFOX_DAEMON_TOKEN="$(openssl rand -hex 32)"
docker run --detach --rm --init \
--name gomoufox \
--publish 127.0.0.1:3741:3741 \
--env GOMOUFOX_DAEMON_TOKEN \
ghcr.io/ehmo/gomoufox:latest
gomoufox \
--server http://127.0.0.1:3741 \
get https://example.com \
--markdown
Pin ghcr.io/ehmo/gomoufox:vX.Y.Z in deployment manifests. For connections
across hosts, put the daemon behind a private network or an HTTPS reverse proxy;
the bearer token does not encrypt plain HTTP. The remote API supports get,
screenshot, fetch, eval, and session import or export. It does not expose
the raw Playwright WebSocket, which would bypass gomoufox's network and data
guardrails.
The container defaults to the same conservative URL policy as local commands.
Arguments after the image name replace its default command, so include serve
and the container bind when overriding daemon flags:
docker run --rm --init \
--publish 127.0.0.1:3741:3741 \
--env GOMOUFOX_DAEMON_TOKEN \
ghcr.io/ehmo/gomoufox:vX.Y.Z \
serve --bind 0.0.0.0 --session-dir /opt/gomoufox/sessions \
--allowed-hosts example.com
Add --enable-eval to allow remote eval, or --allow-session-export to
allow session export. Session files live under /opt/gomoufox/sessions; mount
that directory only when the deployment needs persistent session state.
| Path | Status | Use it when |
|---|---|---|
gomoufox install |
You want the Go-managed node-direct runtime. | |
gomoufox install --runtime python |
You need BrowserForge, geoip, humanize launch options, or the legacy Python sidecar. | |
GOMOUFOX_CAMOUFOX_PATH=/path/to/browser |
You already have a compatible Camoufox browser directory. |
Default Go, CLI, and MCP flows use the Go-managed node-direct runtime. The
default install assembles the exact Playwright 1.57 driver from checksum-pinned
official playwright-core npm and Node.js artifacts, writes the bundled launch
server and fetches the pinned Camoufox browser archive. Persistent profiles and
browser-context locale settings use the node-direct runtime; geoip and humanize
launch options still require the Python sidecar.
Use gomoufox install --runtime python only for the explicit legacy
Python-sidecar path. That path uses hash-locked wheels and the same exact-tag,
manifest-verified browser tree and checksum-pinned Playwright driver as
node-direct. It does not use Camoufox's moving global browser download, and
fails closed on a missing package or hash mismatch.
Homebrew installs on macOS Apple Silicon and Linux amd64, because those are the hosts where the pinned browser has an upstream binary. Other Go archives still ship for library and CLI users.
Use GOMOUFOX_TRUST_UNVERIFIED_CAMOUFOX_PATH=1 only for a trusted local browser
build that does not match the release manifest. gomoufox doctor reports that
as a warning.
Go library
package main
import (
"context"
"fmt"
gomoufox "github.com/ehmo/gomoufox"
)
func main() {
ctx := context.Background()
browser, err := gomoufox.New(ctx)
if err != nil {
panic(err)
}
defer browser.Close()
page, err := browser.NewPage(ctx)
if err != nil {
panic(err)
}
if _, err := page.Goto(ctx, "https://example.com"); err != nil {
panic(err)
}
text, err := page.Content(ctx)
if err != nil {
panic(err)
}
fmt.Println(text)
}
Use the library when your program owns the browser lifecycle. Use the CLI when a shell script needs a page snapshot, screenshot, or browser-context fetch. Use MCP when an agent needs browser tools over stdio or HTTP.
The node-direct runtime targets a history of 512 completed network requests, plus requests still in flight or serving a protocol call. This collector preserves those requests; upstream dispatcher limits still apply. Older request and response handles can be reclaimed. Copy metadata and consume response bodies promptly instead of retaining those handles for the session's lifetime.
HAR recording is a context option and finalizes on Context.Close (or when its
owning page closes):
recording, err := browser.NewContext(ctx, gomoufox.WithHARRecording(gomoufox.HAROptions{
Path: "capture.har",
Capture: gomoufox.HARCaptureMetadata,
}))
if err != nil {
panic(err)
}
defer recording.Abort() // discards an unfinished capture on an early return
page, err := recording.NewPage(ctx)
if err != nil {
panic(err)
}
if _, err := page.Goto(ctx, "https://example.com"); err != nil {
panic(err)
}
if err := recording.Close(); err != nil {
panic(err)
}
result, ok := recording.HARResult()
Check ok before using result. Metadata capture is the default and redacts
standard value-bearing fields while dropping unknown fields; it is still
sensitive. HARCaptureFull preserves request and response content. A successful
Close makes the deferred Abort a no-op.
CLI
gomoufox get https://example.com --markdown
gomoufox screenshot https://example.com --out page.png --full-page
gomoufox screenshot https://example.com --out mobile.png --width 390 --height 844
gomoufox fetch https://api.example.com/me --navigate-first https://example.com
gomoufox open https://app.example.com --save-session state.json --wait
gomoufox fetch https://app.example.com/api/me --cookies-file state.json
gomoufox record https://app.example.com --out capture.har
get, eval and screenshot accept --width and --height in CSS pixels.
Their --timeout budget starts after browser startup and covers navigation,
selector readiness and capture; a selector wait uses the remaining budget.
MCP session_create accepts the same settings as width and height.
Screenshot JSON reports encoded image width and height, the
requested_viewport, and rendering metrics with effective CSS dimensions and
device_pixel_ratio. Full-page and clipped captures can have different image
and viewport dimensions.
rendering also reports the host OS, requested OS fingerprint, browser platform,
body font family and up to 32 web-font loading states. --os selects a Camoufox
fingerprint; it does not install fonts or turn the host into that OS. Loaded
fonts do not prove that every character has a glyph, so glyph_coverage remains
not_verified. For repeatable typography, serve the required web fonts with the
page and inspect representative characters in the capture. Unavailable metrics
are marked explicitly.
Fetch responses are read through a bounded browser stream. gomoufox fetch
defaults to 512 KiB, reports truncation in JSON output, and cancels the reader
when the cap is reached.
gomoufox record opens a headful browser and records the operator's workflow
until the window closes. The default metadata capture removes bodies and
redacts header, cookie, query, and form values, but the resulting HAR is still
sensitive. --capture full preserves request and response content and prints a
warning; use a narrow --url-filter, keep the file private, and inspect it
before sharing.
Agent-friendly discovery:
gomoufox -h
gomoufox -v
gomoufox version
gomoufox help
gomoufox help --json --fields commands
gomoufox help skills --json
gomoufox help mcp --json
gomoufox skills list --json
gomoufox skills show core
gomoufox mcp --help
Automation tips:
- Use
--jsonfor machine-readable output and keep status logs on stderr. - Use
--timeout <dur>for bounded shell jobs. - Use
open --save-sessionfor human login, then reuse the state with--cookies-file. Save storage state for session-cookie handoff; Firefox drops session cookies on restart, so a profile alone does not keep them.open --profilewithout--save-sessionwarns on stderr when the run set session cookies. - Use
--profile <dir>when a workflow needs full persistent browser state. Relative CLI paths resolve from the command's working directory. Each local CLI call starts and closes its own browser; without a profile or imported state, separate calls do not share login or page state. Use MCP named sessions or a running daemon when later calls need the same live browser. - Keep the default URL policy for normal work. Use
--allow-localhostonly for explicit localhost or loopback HTTP(S) targets.
Local development servers
CLI browser commands can reach a local server with the narrow loopback opt-in:
gomoufox --allow-localhost get http://127.0.0.1:3000 --text
gomoufox --allow-localhost screenshot http://localhost:3000 --out page.png
For MCP, set the policy when starting the server. It cannot be enabled by an individual tool call:
gomoufox mcp --allow-localhost
Go callers set the same browser filtering proxy policy with an option:
b, err := gomoufox.New(ctx, gomoufox.WithAllowLocalhost(true))
The option permits explicit localhost, 127.0.0.0/8, and ::1 HTTP(S)
targets. It does not permit broader private networks or metadata endpoints.
Skills
gomoufox ships versioned agent skills in the binary and as checked SKILL.md
files. Skills give agents a compact operating guide for the Go API, CLI, and MCP
tools. They do not install npm packages, run npx, or call the network.
| Skill | Path | Use it when |
|---|---|---|
core |
skills/gomoufox/SKILL.md |
An agent needs the Go library or CLI workflow. |
mcp |
skills/gomoufox-mcp/SKILL.md |
An agent needs MCP setup, tool choice, and browser safety rules. |
Inspect the embedded skills:
gomoufox skills list --json
gomoufox skills show core
gomoufox skills show mcp
Export installable copies:
gomoufox skills export --out ./skills
gomoufox skills export --out ./skills --force
Install skill files only for Codex:
gomoufox skills install --target codex --dry-run --json
gomoufox skills install --target codex
By default, the Codex target writes to $CODEX_HOME/skills or
~/.codex/skills. Use --dir <path> to choose another skill directory. The
installer writes:
gomoufox/SKILL.mdgomoufox/agents/openai.yamlgomoufox-mcp/SKILL.mdgomoufox-mcp/agents/openai.yaml
list and show read from the embedded skill bodies, so agents can discover
the right instructions even when no skill directory exists yet. export and
install write the same checked bodies that ship in the repo. They refuse to
replace existing files unless you pass --force.
Install skills plus MCP configuration for a specific agent or project:
gomoufox agents install --target all --dry-run --json
gomoufox agents install --target cursor --scope project --features skills,mcp
agents install supports codex, claude, cursor, gemini, or all, with
--scope user|project and --features skills,mcp. MCP entries use stdio and
default to gomoufox mcp --toolset core. Use --toolset full for the full MCP
surface. Reserve repeated --mcp-arg <arg> for extra MCP server flags. Use
--force when needs_force identifies a differing skill file that you intend
to replace, or to rewrite an exact match with mode 0600. MCP config is merged.
| Target | User-scope MCP file | Project-scope MCP file | Skill root |
|---|---|---|---|
codex |
~/.codex/config.toml |
.codex/config.toml |
~/.agents/skills or .agents/skills |
claude |
~/.claude/mcp.json |
.mcp.json |
~/.claude/skills or .claude/skills |
cursor |
~/.cursor/mcp.json |
.cursor/mcp.json |
~/.agents/skills or .agents/skills |
gemini |
~/.gemini/settings.json |
.gemini/settings.json |
~/.agents/skills or .agents/skills |
Dry-run output shows the exact absolute paths that would be written.
MCP
Rejected tool arguments include argument_error with the field, rule and
correction from the live schema. Browser failures retain their error code and
add a safe reason, message and hint. Reasons distinguish timeout, closed
sessions, stale refs, ambiguous selectors, frame changes, runtime/launch
failures, network failures and script errors. Raw driver text and supplied
values are omitted.
Form-batch failures report phase, completed_actions, zero-based
failed_index and total_actions. Validation failures mean no actions ran.
Execution failures leave completed actions applied and mark the failed action
as possibly applied. Inspect the page before resuming; replaying the whole
batch can repeat side effects.
Run browser tools over stdio:
gomoufox mcp
Claude Code example:
claude mcp add gomoufox -- gomoufox mcp
HTTP transport requires a bearer token:
gomoufox mcp --transport http --auth-token "$TOKEN"
MCP defaults:
- Use
gomoufox mcp --toolset corefor a smaller agent tool surface. It keeps navigation, snapshots/content, common form actions, sessions, and skill tools. The defaultfulltoolset keeps diagnostics, eval, fetch, cookies, storage, upload, and other gated tools available. file://, private IP ranges, link-local addresses, and metadata hosts are blocked.gomoufox mcp --allow-localhostpermits explicit loopback HTTP(S) targets (localhost,127.0.0.0/8,::1) for local app testing while keeping broader private networks, metadata hosts, DNS rebinding, and unsafe redirects blocked.- JavaScript evaluation is disabled unless you start MCP with
--enable-eval. - Response sizes are capped.
- MCP-owned helper scripts use a startup-probed internal helper evaluation path and do not install a page-visible helper object.
- Browser-derived MCP responses include
provenance.trust: "untrusted"so agents can separate website content from trusted instructions. This label helps agent policy. It is not a sandbox. - Console, page-error, network, and performance diagnosis tools are bounded, redacted, and clearable where they keep event buffers. Network summaries do not include request or response bodies.
- Ref-based interaction tools cover click, type, key press, hover, scroll, select option, checkbox/radio state, dialog policy, and bounded form batches.
browser_snapshotform values stay redacted unless you start MCP with--allow-snapshot-valuesand the tool call setsinclude_values: true.- Browser-context fetches, cookie values, cookie mutation, session export, session import, session proxy use, file upload, and file download stay disabled unless you enable their matching operator flags.
- HAR recording stays disabled unless MCP starts with
--allow-har-recording. Callbrowser_har_startbefore using its named session andbrowser_har_stopto finalize it. Passstorage_state_pathat start rather than callingsession_loadon an active recording; each destination remains exclusively reserved until finalization returns. Full capture also requires--allow-har-sensitive-values; even metadata HAR files remain sensitive and returned routes are untrusted website-controlled data. - For login inside MCP, create
session_createwithheadful: true, then navigate using that session ID to open its visible window. Complete login, wait for a signed-in selector, and callsession_savewhile the session is alive (--allow-session-exportis required). Continue with the same session ID. The session owns a dedicated browser;session_destroycloses it. - MCP profile paths resolve under
--session-dir/profiles. A profile belongs to one named session until cleanup finishes.profile_in_usenames the owning session when this server knows it; reuse that ID. For a profile held by another process, close its owner or choose another directory. Keep lock files intact.session_list.state_sourcedistinguishes ephemeral, profile and imported state. - To reuse a CLI login in MCP, save state with
gomoufox open --save-session, place the file under--session-dir, start MCP with--allow-session-import, then callsession_createwithstorage_state_pathorsession_loadwithpath. browser_upload_filerequires--allow-file-upload; paths must resolve under--session-dir, and responses do not echo file paths.browser_downloadrequires--allow-file-download; destination paths must resolve under--session-dir. Suggested filenames from the browser are returned as metadata only and are never used as write paths.browser_fetchrequires--allow-browser-fetchplus at least one--allowed-originsor--allowed-hostsentry. It still uses gomoufox network policy, so private and metadata destinations stay blocked.
gomoufox MCP Fragen
Kann ich gomoufox in einem Container ausführen?
Ja, du kannst das offizielle Linux amd64 Docker Image verwenden, um einen authentifizierten gomoufox daemon auszuführen.
Unterstützt gomoufox Session-Persistence?
Ja, du kannst Sessions mit dem Befehl open --save-session speichern und sie später mit dem --cookies-file Flag wiederverwenden.