Interceptor

Interceptor reads GitHub stats, fills a Numbers sheet, and builds an on-screen overlay.

https://github.com/user-attachments/assets/b8af57d1-8a22-4955-8b2b-f43f09d52286

30-second edited demo. The terminal is staged from real Interceptor output.

Interceptor connects an AI agent or script to your signed-in browser, native apps on macOS, Windows, and Linux, and a physical iPhone. It combines structured UI reads and actions with access to page traffic, rich editors, app internals, and device state. The agent can inspect what happened after an action and use that evidence for its next step.

Work you can build with Interceptor	Tools available
Research in your existing browser session	Page text, tables, links, browser search, multiple contexts, and a source-ledger research workflow.
Edit a document, slide, or design and save the result	Rich-editor scenes, canvas input, file uploads, and direct capture of page-produced export bytes.
Complete a native desktop task while you keep working	Accessibility controls, background input, and capture of covered windows on macOS, Windows, and Linux; Apple Events on the Mac.
Operate an app on a real iPhone and inspect its state	Element trees, taps, text entry, screenshots, process telemetry, and WebKit inspection.
Turn a demonstrated workflow into reusable commands	Browser and Mac recording, event timelines, and replay-plan export.

Use it from any agent that can run shell commands, or through its built-in Model Context Protocol (MCP) server. Interceptor does not require a model API key; your chosen agent or model may have its own subscription or API costs.

What Interceptor adds

Many tools now let an agent use your signed-in Chrome, and several work on a Mac in the background. Interceptor does both, and adds what the tools in How it compares don't:

• Safari and Chromium in one CLI. Chrome, Brave, Edge, and Safari pages, with the same commands, in the profiles you already use.
• Your own iPhone. Drive the apps on a physical iPhone, not a simulator, over USB, Wi-Fi, or Tailscale away from home, including on cellular.
• Page traffic without a debugger. Read fetch, XHR, SSE, WebSocket, Beacon, and BroadcastChannel traffic through standard page APIs. The browser shows no debugging banner and needs no remote-debugging switch.
• Real editors, not screenshots. Read and change Google Docs, Slides, Sheets, and Canva through their scene graphs, and save the files they export.
• Admin work without showing the password. Vault secrets go by name into a web login, sudo, the macOS administrator prompt, or the iPhone passcode. The model never sees the value.
• One tool across browser, Mac, Windows, Linux, and iPhone, with any agent and any model. Work runs in the background so you keep using your computer. Behavior and exceptions.

Get started

Install with one command

macOS (Apple silicon) and Linux:

curl -fsSL https://raw.githubusercontent.com/Hacker-Valley-Media/Interceptor/main/scripts/get-interceptor.sh | bash

Windows (PowerShell):

irm https://raw.githubusercontent.com/Hacker-Valley-Media/Interceptor/main/scripts/get-interceptor.ps1 | iex

It asks two questions. Press Enter for both to get everything:

1. Full or Browser only? Full (the default) is your browser plus desktop apps, and the iPhone on a Mac. Browser only is web pages.
2. Register the MCP server? Yes is the default. It lists the AI apps it found that don't have the server yet (Claude Code, Codex, Cursor, Gemini CLI, Claude Desktop) and turns every tool on.

It downloads the latest release from updates.hackervalley.media, checks its SHA-256 and the Hacker Valley Media signature, and installs it with no Installer wizard. Nothing installs if a check fails. It adds Interceptor's skills to every AI agent on your computer. A Mac asks for your password once. Run it again any time to update: it keeps your edition and leaves an existing MCP setup alone.

Options go after bash -s --, for example curl -fsSL … | bash -s -- --browser --no-mcp:

Option	Does
--full, --browser	Pick the edition instead of being asked. Full is the default.
--mcp, --no-mcp	Register the MCP server in every AI app it finds, or skip it, instead of being asked (--mcp=claude,codex for some).
--safari	macOS: also install the Safari extension package.
--no-skills	Skip adding the skills.

On Windows, pass the same as parameters: & ([scriptblock]::Create((irm <url>))) -Browser -NoMcp.

"Every tool on" means the agent can also run the actions that are off by default, such as quitting apps, writing files, and running scripts in a page (INTERCEPTOR_MCP_ALLOW=all,raw). The agent still marks each of those calls as confirmed. For reading and clicking only, run interceptor mcp install afterward.

The last step is the browser extension. On a Mac, the Interceptor window opens by itself and walks you through it. On Windows, the Chrome Web Store page opens.

Want your AI agent to do it? Ask it to run the same command. With no terminal to answer, it takes the defaults: Full and the MCP server with every tool on. A Mac then opens the verified package in Installer for you to type your password.

Prefer to run each step yourself? On a Mac, the same install with Apple's own tools:

curl -fLo /tmp/Interceptor.pkg https://updates.hackervalley.media/latest/Interceptor-Full.pkg
spctl -a -vv -t install /tmp/Interceptor.pkg && sudo installer -pkg /tmp/Interceptor.pkg -target /
interceptor skills adopt

spctl is Apple's Gatekeeper check. It prints Notarized Developer ID and HACKER VALLEY MEDIA, LLC (TPWBZD35WW), and if the package is not signed and notarized, installer never runs. For the Browser edition, use Interceptor-Browser.pkg. Add interceptor mcp install --allow all,raw to register the MCP server with every tool on.

Download an installer

Each link below always gets the newest release. Start with Browser for web tasks, or Full for native apps and the iPhone. Every version is on Releases, and SHA256SUMS-ALL lists each file's SHA-256. The macOS packages are built for Apple silicon. On an Intel Mac, build from source (see Development and contributions).

Package	Download	What it enables
macOS Browser	Interceptor-Browser.pkg	CLI, daemon, and browser extension files.
macOS Full	Interceptor-Full.pkg	Browser package plus the native Mac bridge and iPhone tooling. The bridge requires macOS 15+.
macOS Safari add-on	Interceptor-Safari.pkg	Safari extension, installed after either core package.
Windows Browser	x64 · ARM64	Browser automation on Windows 10 22H2+ or Windows 11 (x64); Windows 11 24H2+ (ARM64). Windows guide.
Windows Full	x64 · ARM64	Browser automation plus native app control with interceptor desktop. Windows 10 22H2 x64 or Windows 11 24H2+ (x64/ARM64).
Linux Browser	x64 · ARM64	Browser automation and install scripts.
Linux Full	x64 · ARM64	Browser automation plus native app control with interceptor desktop.

The macOS release binaries target Apple silicon. On Windows and Linux, the Full packages add native app control through interceptor desktop; run interceptor desktop capabilities to see what works on that computer. iPhone setup requires a Mac.

macOS installation

1. Install the Browser or Full .pkg. On a first install, the Interceptor window opens: it checks whether the extension is already in your browser, and if not, walks you through adding it from the Chrome Web Store, as an unpacked extension (with a step-by-step guide in the browser), or for Safari. Open it again any time with interceptor diagnose extension --welcome.
2. In Chrome or Brave, install the Interceptor extension if the window did not already do it. The local runtime and browser extension are both required.
3. For Safari, also install the Safari .pkg, open /Applications/InterceptorSafari.app once, then enable Interceptor and website access in Safari → Settings → Extensions. Safari requires your approval.
4. With Full, grant the permissions needed by your task to interceptor-bridge. Run interceptor macos trust --walkthrough for guidance. Accessibility enables native UI control; screen, microphone, and app-automation access are needed for their respective features.

For an unpacked Chrome/Brave extension, enable Developer Mode on the browser's extensions page and load /Library/Application Support/Interceptor/extension/. Keep one copy per profile. Store and unpacked installations share an extension ID; store updates arrive after store review.

Windows and Linux

On Windows, run the installer for your PC (x64 or ARM64), install the browser extension, then open a new terminal. Chrome, Brave, and Edge can use the Chrome Web Store listing; Edge requires allowing extensions from other stores. The Windows guide also covers unpacked extensions, silent installation, updates, and removal.

On Linux, extract the archive for your machine (x64 or ARM64) and run this from its directory:

bash scripts/install.sh --browser-only --brave
# For Chrome, use --chrome instead of --brave.
./dist/interceptor open "https://example.com"

Follow the installer's extension-loading instructions. The archive includes compiled binaries, so a separate Bun installation is not needed for this release path.

For native app control on Linux, the one-command install checks the signed checksum list for you. To do it by hand, download the Full archive with SHA256SUMS, SHA256SUMS.cms, verify-release-manifest.sh and linux-release-apple-root.pem, run bash verify-release-manifest.sh <folder> (it checks every archive the list names, so put all four Linux archives in the folder), then run bash scripts/install.sh --full from your graphical session. On Windows, run the Full installer instead of the Browser one. The desktop guide lists what each OS supports and the optional Linux packages that light up OCR, face detection, and personal data.

Your first browser task

With the extension enabled and browser open:

interceptor open "https://example.com" --group first-task
interceptor read --group first-task
interceptor group close first-task

open starts the daemon when needed, opens a managed tab in the background, and returns the page's tree and text. You should see Example Domain. read inspects it again; group close cleans up that task's tabs.

If several browser contexts are connected, run interceptor contexts and add --context <id> to your browser commands. Safari's ID is safari. interceptor status reports local health but does not start the daemon by itself.

Connect your agent

For a shell-capable agent, adopt the bundled skills into detected agent runtimes. The Mac and Windows installers and the Linux archives each bundle the skills for their operating system:

interceptor skills adopt

For an MCP client, register Interceptor and restart the client. The installer detects Claude Code, Codex, Gemini CLI, Cursor, and Claude Desktop:

interceptor mcp install
interceptor mcp status

The MCP server exposes browser, macOS, iOS, read, local, and raw tools, plus discovery resources. Its permissions are configured by the operator. See the MCP guide.

Browser automation

Read and operate the web apps you are already signed into. Chrome, Brave, and Safari use Interceptor's extension. Browser-specific limits are described in the browser guide.

• Pages and forms: read text, HTML, tables, links, frames, and accessibility-style element references. Click, type, select, drag, scroll, and navigate. Native dropdown selection validates exact values or unique labels and rejects invalid options.
• Rich editors and canvases: inspect supported scene graphs, select objects, navigate slides, and enter text in canvas-rendered editors. Workflows cover Google Docs, Slides, Sheets, Canva, and WebGL viewers; support depends on the app and operation.
• Network and application state: inspect fetch/XHR, SSE, WebSocket, Beacon, and BroadcastChannel traffic; examine headers, rewrite matching requests, and export captured traffic. Passive inspection uses standard page APIs without attaching a debugger.
• Files and exports: upload local files to inputs, drop zones, and supported file pickers. Save page-produced Blob, buffer, or blob: URL bytes directly to disk with save, including native exports from supported web apps.
• Capture and browser data: screenshots, OCR, canvas inspection, cookies, storage, history, bookmarks, downloads, and session management.
• Multiple tasks: select a browser profile with --context, a tab with --tab, and a task's managed tabs with --group. Use a distinct group for each concurrent worker.
• Tab cleanup: when no command has touched a managed tab group for 10 minutes, Interceptor closes its idle tabs. It keeps the tab you are looking at, audible tabs, tabs with unsaved form input, and a window's last tab, so the group itself can remain. The extension popup changes the idle time and can delete the whole idle group instead (off by default). Administrators can set both through managed browser policy. interceptor sessions restore <id> reopens a closed page in the background.

interceptor open "https://example.com" --group browser-task
interceptor find "Learn more" --group browser-task
interceptor inspect --group browser-task
interceptor group close browser-task

To interact, use the current reference returned by read or find: interceptor act <ref> clicks it; interceptor act <ref> "text" enters text. Re-read after navigation or a stale-reference error, and check the resulting state after an action.

Browser command reference · Rich-editor workflows · Export capture

macOS automation

Desktop automation for native Mac apps, windows, menus, and dialogs, including supported background workflows. The Full package provides a Swift bridge with Accessibility, capture, input, and Apple framework integrations.

interceptor macos trust
interceptor macos tree --app "Finder"
interceptor macos windows --app "Finder"

These commands inspect Finder without activating it. Use returned element references with macos act, click, or type; use macos open "Finder" --activate when you want to bring it forward.

Area	Capabilities
App control	Accessibility trees, text and values, clicks, typing, keyboard input, scrolling, dragging, menus, app lifecycle, and window placement.
Capture and perception	Covered/minimized-window screenshots, screen streaming, OCR and vision over a window or a saved image file (including an iPhone screenshot), system/microphone audio, speech recognition, sound classification, and language analysis.
Files and system work	Spotlight search, file reads/writes/watchers, clipboard, URL fetching, OS logs, AppleScript/JXA, JavaScriptCore scripts, and Apple Events.
Documents	PDF text, forms, annotations, merge/split operations, data detection, translation, and thumbnails.
Personal apps	Calendar, reminders, contacts, photos, location, music, maps, sharing, and notifications through the corresponding system frameworks and permissions.
Visual tools	HTML and SpriteKit overlays, window-anchored HUDs, capture streams, and virtual displays.
Local compute	Apple Intelligence on supported macOS 26+ systems, OCI containers, and Linux/macOS VM lifecycle and guest tools. See the guides for runtime, model, and guest prerequisites.

Mac command reference · Background behavior · System and media tools · Documents · Personal data · Overlays · VMs

Windows and Linux automation

Drive native apps on Windows and Linux with the same commands as on the Mac. The Full package adds interceptor desktop, which takes the same verbs, flags and JSON replies as interceptor macos. Input goes to the target window in the background, without bringing it forward or moving your cursor. Not every operation exists on every system, so check first: capabilities says whether each one works on this computer, and why not when it doesn't.

interceptor desktop capabilities
interceptor desktop windows --app "Notepad"
interceptor desktop tree --app "Notepad"

Area	Capabilities
App control	Accessibility trees, element search, values and text. Clicks, typing, keys, scrolling, dragging, menus and actions sent to a background window. List, open, resize, and move apps and windows.
Capture and perception	Screenshots, screen capture and streaming with recording, OCR, face, hand and body detection, image classification, speech recognition, and sound classification.
Local AI	Prompts, translation, entity and sentiment analysis, and data detection with Gemma 4 E2B, downloaded once on first use (2.8 GB) and run on your computer by the bundled llama.cpp server.
Files and system work	Files, thumbnails, clipboard, URL fetching, PDF, logs, JavaScript scripts, monitor and replay, and overlays.
Personal data	Contacts, calendar, reminders, notifications, and sharing.
Secrets and updates	Vault secrets typed by name into apps, plus sudo on Linux. Updates ask first, like Sparkle on a Mac: you see the release notes and click Install Update.

Windows

Browser-only supports Windows 10 22H2+ and Windows 11 on x64; ARM64 requires Windows 11 24H2+. Full supports Windows 10 22H2 x64 or Windows 11 24H2+ (x64/ARM64); it does not support Windows 11 builds 22000–26099. The Full installer is signed by Hacker Valley Media LLC and installs for your user only, with no administrator prompt. Desktop commands run in your signed-in desktop session; one started over SSH is refused. OCR, face detection and speech recognition use the engines Windows ships. The signed Full install/upgrade/uninstall lifecycle has not yet been tested on Windows 10. Windows guide

Linux

Tested on Arch Linux ARM64 with Hyprland on Wayland. Run commands from your own graphical session; a plain SSH shell is refused. OCR, face detection, language detection, and contacts and calendar each need one optional distribution package, and capabilities names the package when it is missing. Package list

Desktop guide · Desktop skill

iPhone and iOS automation

Drive apps on a physical iPhone and inspect more than its screen. Interceptor's own on-device XCUITest runner handles UI work; additional interfaces expose developer and device services.

Setup requires an owned, unlocked iPhone in Developer Mode, pairing with your Mac, a Full installation, and Xcode signed into an Apple ID (a free personal team works; its signing lasts 7 days and Interceptor renews it). Connect by USB for initial pairing. Wi-Fi operation is available once paired, with network reachability between the phone and Mac. Away from your Mac, including on cellular, open InterceptorRunner on the phone and it connects back over Tailscale.

interceptor ios discover
interceptor ios setup
interceptor ios tree

setup builds, signs, installs, and launches the runner. Complete any on-device XCTest authorization prompt yourself, grant Local Network access when needed, and keep the phone unlocked and awake during automation. This operates the phone's foreground UI. It does not provide the desktop's background-use guarantee.

Area	Capabilities
App interaction	Ref-tagged element trees, find/inspect, taps, text, scrolling, dragging, long presses, multi-finger gestures, hardware buttons, screenshots, a continuous frame stream over Wi-Fi, and app launch/activate/terminate. Taps, drags, swipes, and gestures also take screen coordinates, for games and canvas apps with no element tree.
On-device scripts	ios eval runs JavaScript inside the runner, combining UI reads, decisions, and actions in one request.
Developer telemetry	Process lists, CPU/memory and GPU sampling, app launch with arguments, and location simulation through supported device services.
Web content	ios web inspects exposed Safari and WKWebView targets: page structure, JavaScript, console, and network activity.
Device inspection	Logs, diagnostics, crash reports, profiles, and supported media or app-container file access. Availability depends on iOS, pairing, and service permissions.

Use --on <alias> to select a phone when several are configured. For setup, exact verbs, service limits, and connection recovery, see the iPhone guide and command reference.

Record and reuse workflows

Teach a browser workflow by doing it once while Interceptor records clicks, inputs, navigation, DOM changes, and correlated traffic. Export the session as a timeline or a replay plan:

# Start with an open Interceptor-managed browser tab.
interceptor monitor start --instruction "Search the catalog and compare two items"
# Perform the workflow.
interceptor monitor stop
# Use the session ID returned above:
interceptor monitor export <session-id> --plan

Native Mac recording uses interceptor macos monitor and the same export <session-id> --plan pattern. Review a generated plan, supply any missing inputs, and check the result when replaying it.

For longer browser jobs, monitor task stores checkpoints, target context, lessons, and verification checks. Resume a task across agent sessions; task complete runs its checks and marks it complete only when they all return true.

Browser recording · Mac recording · Durable task state

How it compares

As of 2026-10-22, from each project's own documentation (sources below the table). Corrections are welcome in Discussions.

Tool	Browsers it drives	How it reaches the page	Desktop apps	Physical iPhone	Works with
Interceptor	Chrome, Brave, Edge, Safari, in your own profiles	Its extension; Chrome's debugger only when you ask for it	macOS, Windows, Linux	Yes, installed apps	Any agent that runs commands, or MCP
Playwright MCP, --extension mode	Chrome, Edge (its own launched Chromium, Firefox, or WebKit otherwise)	An extension that uses Chrome's debugger permission	No	No	Any MCP client
Chrome DevTools MCP, --autoConnect	Chrome 144+	Chrome DevTools Protocol; you turn on remote debugging and click Allow	No	No	Any MCP client
agent-browser	Chrome and Chromium (your profile with --profile or --auto-connect); Safari on iOS through Appium	Chrome DevTools Protocol; WebDriver for Safari	Electron apps, through CDP	Safari only, over USB with WebDriverAgent	Any agent that runs commands
Claude in Chrome	Chrome, Edge, and other Chromium browsers	An extension that declares Chrome's debugger permission	Separate product: Claude Desktop computer use	No (Claude's iOS pane drives simulators only)	Claude, with a direct Anthropic plan
Cua Driver	Chrome and Edge windows, Electron apps; Safari and Firefox are not supported	Chrome DevTools Protocol	macOS, Windows, Linux	No	Any agent that runs commands, or MCP
Tencent BrowserSkill	Chrome, Edge	An extension that drives pages through chrome.debugger	No	No	Any agent that runs commands

Sources: Playwright MCP README (--extension: "Edge/Chrome only") and extension manifest; Chrome auto-connect guide; agent-browser README (iOS and real-device sections); Claude Code Chrome docs, iOS Simulator docs, Claude Desktop docs, and the Claude extension package manifest (version 1.0.102); Cua Driver docs and browser guide; BrowserSkill README and extension config.

When to use something else

• Headless runs in CI, or many browsers in the cloud: use Playwright or a cloud browser service. Interceptor drives a desktop browser on your own computer.
• Chrome only, and one assistant already covers the task: Claude in Chrome or your assistant's own browser extension may be enough.
• Testing your own iOS app in the Simulator: Xcode's simulator tooling or Claude's iOS Simulator pane fits better. Interceptor is for a physical iPhone.
• Android phones: Interceptor does not drive Android; mobile-mcp does.
• Disposable virtual machines or sandboxes for agents: see Cua.

Go deeper

These interfaces add access beyond ordinary UI controls. Each has its own setup and support boundaries.

Interface	What it adds	Guide
Electron / Chromium apps	Read DOM, execute JavaScript, inspect traffic, and capture an app's web contents with macos cdp or macos cdp app. Some attachment paths require an app relaunch.	App control
Native runtime	Inspect live objects and layers, call selectors, change rendered text, and observe calls with macos runtime. Requires a compatible target and an agent dylib; advanced extensions are separate from the core package.	Runtime setup and commands
Research	A browser-based investigation workflow with query planning, saved sources, corroboration, and an evidence ledger. Start with interceptor research or the research skill.	Research skill
Extensions	Add operator-supplied bridge domains, commands, runtime agents, and skills. Inspect installed extensions with interceptor extensions list.	Extension authoring

The default browser path and passive capture do not require CDP. Electron control uses CDP where appropriate, and optional browser debugger commands are available separately.

Permissions and data

Interceptor runs locally and hands results to the agent or script you choose. That agent may send content to its model provider. Interceptor's browser extension has no publisher analytics; see the privacy policy for its access, passive page buffers, and storage behavior.

• Real access: commands act in your accounts and apps. Browser commands normally target managed tabs, but the extension's permissions and local capture hooks are broader than that task boundary.
• Credentials by name: the macOS keychain-backed vault can deliver a secret to an allowed target with --secret; supported Chromium saved logins can also be filled by host. Standard browser reads mask password and credential-marked fields. This is not blanket redaction of screenshots, scene reads, eval, or network data.
• MCP permissions: reads and UI mutations are enabled by default. Destructive and arbitrary-code execution tiers require operator opt-in and confirmation. These gates belong to MCP; the direct CLI follows its own command contracts.
• Focus: default browser and Mac actions preserve your working context. Browser --os input requires a focused target; browser pixel-screenshot fallback may briefly borrow focus. Use --no-fallback when that is unacceptable.

Permission guide · Credential delivery · MCP controls

Documentation

Start with the browser guide, Mac guide, or iPhone guide. For implementation details, read Architecture; for agent operating rules, read AGENTS.md.

interceptor help                  # Capability overview for your installation
interceptor help <command>        # One command's usage and options
interceptor help --all            # Full command reference
interceptor manifest              # Machine-readable command contracts
interceptor diagnose              # Runtime and extension diagnostics

Updates and troubleshooting

On a Full Mac installation, interceptor update checks for an update and interceptor update status reports progress. Windows and Linux Full installs update the way Sparkle updates a Mac: once a day the native provider checks the signed feed on updates.hackervalley.media, and a newer release opens Interceptor's update window with its release notes and Skip This Version, Remind Me Later, and Install Update. Nothing downloads or installs until you click. The installer is checked against the signed feed (plus its Authenticode signature on Windows), then Install and Relaunch installs it. interceptor update checks now and opens the window when there is an update; interceptor update status shows what happened. Set INTERCEPTOR_AUTO_UPDATE=off in the provider's login environment to stop the daily checks. Browser-only users can run a newer installer; interceptor upgrade --full adds Mac native capabilities.

If no browser context connects, check that both the runtime and extension are installed and enabled. interceptor diagnose distinguishes store and unpacked versions. If Interceptor disappears every time the browser restarts, run interceptor diagnose extension. It finds a profile that loaded the unpacked copy before 1.0.1 (an entry for the old extension ID blocks the folder), a load from scripts/install.sh that lasts one session, and two copies running at once. --fix repairs the first by restarting Brave, Vivaldi or Chromium on macOS; everything else gets exact steps. Installs and updates run the same check and ask before touching a browser. On macOS 27, an app needs your permission to read Chrome, Brave and Edge settings, so the check runs inside the bridge: in System Settings > Privacy & Security > Files & Folders, turn on each browser under interceptor-bridge, or give interceptor-bridge Full Disk Access. On a Mac that had Interceptor before 1.0.1, the installer asks and checks as soon as access is on. interceptor reload --context <id> reloads an unpacked extension; a store copy remains subject to store publication. For missing native permissions, use interceptor macos trust --walkthrough.

macOS package removal: sudo bash "/Library/Application Support/Interceptor/uninstall.sh". Add --bridge-only to remove native Mac support while retaining Browser.

Development and contributions

The CLI, daemon, and browser extension use TypeScript and Bun. The native Mac bridge and iPhone runner use Swift. A local daemon routes commands to the selected browser, bridge, app runtime, or device.

For a source install, use Bun and an installed Chrome or Brave browser. The default build on macOS also builds the native bridge and requires macOS 15+ and a Swift 6.2 toolchain. Source builds work on Apple silicon and Intel Macs. The interceptor macos vm commands require Apple silicon.

git clone https://github.com/Hacker-Valley-Media/Interceptor.git
cd Interceptor
bun install
bun run build
bash scripts/install.sh --browser-only --brave
# On macOS, use --full instead of --browser-only for native capabilities.
./dist/interceptor open "https://example.com"

Enable Developer Mode in the selected browser profile before loading an unpacked extension. Branded Chrome requires manually loading extension/dist/ from its extensions page. The installer can relaunch Brave and asks before closing a running instance. Windows source installs use scripts/install.ps1; see the Windows guide.

For code changes, run the checks appropriate to the affected surface:

bun run typecheck
bun test
bun run build

Report a bug with the version, OS/browser or device, command, expected result, and relevant redacted output. Contributions to code, reproducible workflows, and documentation are welcome.

License and credits

Interceptor is licensed under Elastic License 2.0. See commercial terms.

If Interceptor saves you time, a star on this repo helps other people find it.

Created by Ron Eddings. Thanks to Pedram Amini for early feedback and Maestro, Daniel Miessler for the name and PAI, Klaus Agnoletti for Edge/Vivaldi installer support, and Alex Tabisz for Linux support.