FileForge

v0.2.0 · Available on npm and GitHub

Give your AI agent a DevTools seat in the Chrome you already use.

FileForge connects your AI coding assistant to your open Chrome tabs. Inspect page content, console errors, network requests and screenshots in the browser where you're already signed in. A local MCP server and Chrome extension bring that context into your debugging workflow.

View on GitHub Get it on npmView setup requirementsExplore the tools

Your agent, with FileForge

I'm logged into staging in my open tab. Find out why the checkout button does nothing.
The click handler throws before any request is sent, so the button looks dead.
Start capturing, I'll click Save. Then tell me which request failed and show me the response body.
Got it. One request failed when you clicked Save.
Find what's causing horizontal scrolling on this page at mobile widths.
The pricing table extends past its container at the narrowest width. Start with its minimum width.
The Continue button is visible but won't click. Inspect what's blocking it.
A transparent overlay sits above the button and intercepts pointer events.
Inspect the computed styles on this heading. Which font and spacing are actually applied?
The heading uses the fallback font. Its computed spacing is shown below.
Check this page for broken images and visible error messages before I review it.
One image hasn't loaded, and the page is showing a retry message.
Save a snapshot of this page so we can compare its content after the next update.
The current page is saved locally. We can compare it with a later visit.
Inspect the WebSocket frames captured while I reconnect the live dashboard.
The connection opens, but the server sends a subscription error instead of dashboard updates.
Dry-run a replay of that failed request and tell me what would be sent. Don't execute it.
The preview targets the profile endpoint. No request was sent; replaying this write would require an explicit override.
Capture this component at mobile and desktop widths. I'll bring the target tab into view first.
Both captures are saved locally. The mobile image shows the clipped filter controls.
Turn the current browser evidence into a bug report I can review before sharing.
The report bundle is ready for review. Check screenshots and request data for private information before sharing it.
Check whether the FileForge extension is running and whether its page injection is present.
The service worker is running, but injection wasn't found in this tab. Check whether the page allows extension access.
Save a local note that the checkout failure only happens when the discount field is empty.
The note is saved locally so we can find it in a later investigation.
Validate my saved routine before running it. Check its steps and required permissions.
One step uses an unknown action. Fix that step before running the routine, and keep the local server running during execution.
Compare this page against my saved baseline and tell me what changed.
Two areas look different from your baseline.
Capture the requests this dashboard makes and export them as MSW mocks.
I captured three requests and exported them as MSW mock material.
Watch my app and admin tabs while I place an order. Tell me where things go wrong.
The order went through in the app. It breaks when the admin tab reloads its list.
Grab the DOM, route, console and network context from this page, then find the bug in my code.
Here's the context. The error comes from the settings form, so I'll start in that component.
Pull the table on this page into structured data so we can work with it.
Done. The table is ready to work with.
Query the results we saved earlier and find what we captured about the login page.
We saved two results for the login page.
Run an accessibility check on this page and list the issues I should review first.
Three issues are worth reviewing. This isn't a conformance result, just a starting point.
Export that failing request as curl so I can share it with the backend team.
Here it is. Review captured request data for private information before sharing.
Illustrative conversation. Not real output, and not a real site.

Stop being your agent's copy-paste relay.

Debugging with an AI assistant often means copying errors, describing what happened and taking screenshots by hand. Problems inside signed-in applications can require even more setup.

FileForge lets your agent inspect the live browser directly, gather relevant evidence and interact with the page through structured tools.

What your agent can reach.

These capabilities ship in v0.2.0: 26 tools with 228 actions. The full reference is in docs/tools.md.

Tabs

Your existing browser sessions

Inspect the Chrome tabs you already have open, including signed-in apps. No separate browser profile to set up.

Debug

DevTools evidence

Console messages, JavaScript errors, network requests, response bodies, screenshots, and page context bundles for a coding task.

DOM

Page interaction

Read text and forms, click controls, fill fields, and debug selectors through structured tools.

Local

Saved results

Save tool results locally and query them with SQL. Keep notes and page snapshots for later investigation.

Browse the tool reference

Also in v0.2.0

Visual baselines
Capture visible behavior and compare interface changes.
Multi-tab monitoring
Watch tabs you select for network, console and DOM activity.
Scraping and extraction
Pull page content, tables, links, metadata and design information.
Audits
Accessibility, responsive, performance and other checks that flag issues for developer review.
Recipes and routines
Replay steps you define or schedule multi-step routines while the local server is running.
API export
Export captured requests as curl, Postman collections or MSW mock material.

A local bridge to your tabs.

Your MCP client starts the server; Chrome must have the extension loaded and enabled. The local Node.js server talks to the extension, which reaches your tabs through Chrome APIs and the DevTools Protocol.

The server and Chrome must run on the same machine.

  1. AI agent / MCP client
  2. ↓ MCP over stdio
  3. Local Node.js server
  4. ↓ WebSocket at 127.0.0.1:47821
  5. Chrome extension
  6. ↓ Chrome APIs and DevTools Protocol
  7. Your browser tabs

Debugging workflow

  1. Step 1

    Start capture

    Begin capture before reproducing the issue. FileForge can't recover all past network activity.

  2. Step 2

    Reproduce the bug

    Trigger the failure in your own tab, signed in as usual.

  3. Step 3

    Inspect the evidence

    Ask your agent to inspect console errors and failed requests. Bring the target tab into view before capturing a screenshot.

  4. Step 4

    Verify the fix

    After you or your coding assistant changes the application code, reproduce the action again and inspect the new browser evidence.

Where it fits

Authenticated-app debugging
Investigate a signed-in staging environment in your own browser.
Route investigation
Collect DOM, framework, route, console and network context for one page.
UI regression evidence
Capture screenshots and compare them against visual baselines.
Structured extraction
Turn page content, tables and links into data your agent can use.

Setup requirements

Not on the Chrome Web Store, and for single-user machines only

You load the extension unpacked, and reload its card after updating. Use FileForge only where you are the sole user. Read why.

You'll need: Node.js 20 or newer, npm, Google Chrome and an MCP client, with the server and Chrome on the same machine. The full guide is in docs/setup.md.

  1. 1Install the server

    From npm (recommended; bundles the extension)

    npm install -g fileforge-mcp-server

    This puts fileforge-mcp, fileforge-verify and fileforge-pair on your PATH. Install globally rather than with npx, because Chrome loads the extension from the package folder.

    From source (git clone)

    git clone https://github.com/mayank1307/fileforge.git
cd fileforge/mcp-server
npm install

    better-sqlite3 is a native dependency built at install time. Install using the same Node version that will run the server. Some environments may need native compilation prerequisites.

  2. 2Load the Chrome extension

    1. Open chrome://extensions.
    2. Turn on Developer mode.
    3. Choose Load unpacked and select the extension/ folder for your install path, shown below.
    4. Confirm the extension ID is nlcebipkdgecilmgfpobamljieanadpn.

    From npm: print the folder

    echo "$(npm root -g)/fileforge-mcp-server/extension"

    From source: select fileforge/extension inside your clone.

  3. 3Register with your MCP client

    From npm

    claude mcp add fileforge -- fileforge-mcp

    From source

    claude mcp add fileforge -- node /absolute/path/to/fileforge/mcp-server/src/index.js

    For a source install, replace the placeholder with the actual absolute path. Claude Desktop and Cursor require manual MCP configuration, which is not shown in these tabs; see docs/setup.md. Desktop clients may also need the absolute Node path, because their environment can differ from your shell.

  4. 4Activate and verify

    Open or restart your MCP client so it starts the server, and keep Chrome running with the extension enabled. Then run the verifier:

    From npm

    fileforge-verify

    From source, in mcp-server/

    npm run verify

    Then ask your agent to make these two calls:

    Tool: fileforge_runtime_action
Arguments: {"action":"status"}

Tool: fileforge_browser_action
Arguments: {"action":"query_context"}

    The status call should report the extension as connected. The browser call returns browser context, including your open tabs.

Know what you're connecting.

What runs locally, and what doesn't

The server, bridge, extension and stored results run on your machine, with no telemetry. The bridge refuses web pages and any non-pinned extension, and ~/.fileforge is created with mode 0700. The Activity log keeps the last 1,000 requests in chrome.storage.local with token-like values redacted; page content is not redacted. Browser content returned to your MCP client is then subject to that client's and its model provider's data handling.

Powerful browser access

The extension requests broad host access and browser permissions, includingdebugger, history and bookmarks. The connected agent has real power in your signed-in browser, including running JavaScript in a tab. Review screenshots and captured request data before sharing them; signed-in pages can contain private information.

Where the protections stop

Page text can attempt prompt injection, and FileForge can't distinguish instructions from content. The security policy doesn't protect against malicious agents, and extension-origin checks have documented limitations involving other local users, so use FileForge only where you are the sole user. npm audit --omit=dev reports no advisories; one dev-only advisory (minimatch via ESLint) remains and never loads in the server.

This marketing website uses site analytics, separate from the local extension and server. Browser content passed through FileForge is subject to your MCP client's and model provider's data handling. The details are in SECURITY.md and docs/permissions.md.

Compatibility

Operating systems
Setup documented for macOS, Windows and Linux
Browser
Google Chrome, with the Manifest V3 extension loaded unpacked. It isn't on the Chrome Web Store. No minimum version is specified, and other browsers aren't verified.
MCP clients
Setup documented for Claude Code, Claude Desktop, Codex and Cursor. Availability varies by platform.
Runtime
Node.js 20 or newer, and npm
Same machine
The server and Chrome must run on the same machine

Current limits

Automatic workflow recording is unfinished.

Explicit recipe steps can be saved and replayed, but manual event capture isn't implemented.

It doesn't generate tests.

The Playwright workflow export produces commented step descriptions and JSON, not runnable tests. FileForge complements your test runner.

Audits aren't certifications.

Findings need review, and don't establish WCAG conformance or security certification.

Screenshots need a visible tab.

Viewport, full-page, element and region screenshots require the target tab to be visible in its window.

Chrome shows a debugging indicator.

It appears while the DevTools Protocol is attached.

Some upkeep is manual.

Unpacked extensions must be reloaded after updates, and scheduled routines need the server running.

It's for single-user machines.

The bridge identifies the extension by its Origin header, which any local process can forge. Use FileForge only where you are the sole user.

Extension pairing is optional and off by default.

With FILEFORGE_REQUIRE_PAIRING=1, the extension must present a token, which blocks a process posing as the extension.

The extension doesn't authenticate the server.

It connects to whatever listens on 127.0.0.1:47821, so another local user could bind the port. Pairing doesn't change this.