MCP Bridge

Securely connect ChatGPT to your local files, terminal, and existing Chrome session through OpenAI Secure MCP Tunnel.

Website · Latest Release · Glama · Security · Issues

What is MCP Bridge?

MCP Bridge is a desktop app for Linux and Windows that keeps powerful local tools on your own computer while making them available to ChatGPT through OpenAI Secure MCP Tunnel.

It exposes three independent connections:

Your files, browser session, and terminal remain on your machine. MCP Bridge only exposes the roots and capabilities you explicitly allow.

Related MCP server: agent-mcp-gateway

Highlights in v0.2.1

• Fresh product-level desktop UI

• Dedicated Bridge / Gateway app identity and production icon

• Proper Linux taskbar/window identity — no longer grouped under ChatGPT

• System tray controls for Local MCP and Web MCP

• Closing the window minimizes instead of terminating active tunnels

• Automatic Linux mounted-drive discovery

• Friendly labels for external SSDs and mounted volumes

• Read/write validation before a mounted root is exposed

• Existing encrypted Runtime API key survives upgrades

• Built-in cross-platform update system

• SHA-256 verification before an update can be installed

• Linux .deb, Linux AppImage, and Windows NSIS .exe releases

• Local MCP and Web MCP remain completely independent

Architecture

                         OpenAI Secure MCP Tunnel
                                  |
                  +---------------+---------------+
                  |                               |
              Local MCP                        Web MCP
                  |                               |
          approved local roots              Chrome DevTools MCP
         /        |        \                       |
      files    folders    shell               existing Chrome
                  \                               /
                   +--------- MCP Bridge --------+
                             Linux / Windows

No public local MCP port needs to be exposed directly to the internet.

Quick start

1. Install MCP Bridge

Linux

Current packaged releases target Debian / Ubuntu / Linux Mint on amd64/x86_64.

curl -fsSL -H "Accept: application/vnd.github.raw+json" \
  "https://api.github.com/repos/haseebgb92/ChatGPT-MCp/contents/install-linux.sh?ref=main" | bash

If Chrome/Chromium is already installed:

curl -fsSL -H "Accept: application/vnd.github.raw+json" \
  "https://api.github.com/repos/haseebgb92/ChatGPT-MCp/contents/install-linux.sh?ref=main" | SKIP_CHROME=1 bash

Or download the latest .deb from GitHub Releases:

sudo apt install ./MCP-Bridge-*-linux-amd64.deb

Windows

Open PowerShell:

Set-ExecutionPolicy -Scope Process Bypass -Force
irm "https://raw.githubusercontent.com/haseebgb92/ChatGPT-MCp/main/install-windows.ps1" | iex

Or download the latest Windows .exe from GitHub Releases.

2. Create two OpenAI tunnels

Open:

https://platform.openai.com/settings/organization/tunnels

Create separate tunnel IDs for Local MCP and Web MCP.

Local Files
Chrome

Use different tunnel IDs when both services will run at the same time.

3. Create a Runtime API key

Open:

https://platform.openai.com/settings/organization/api-keys

For least privilege, use a restricted key whose principal has:

Tunnels: Read
Tunnels: Use

Do not use an OpenAI Admin API key as the long-running Runtime API key.

When Remember API key securely is enabled, MCP Bridge stores it through Electron safeStorage / operating-system credential encryption instead of normal settings.

4. Configure MCP Bridge

1. Enter the Runtime API key.

2. Enter the Local tunnel ID.

3. Enter the Web tunnel ID.

4. Add one or more approved folders.

5. Choose read-only or read/write access per root.

6. Enable file writing only if needed.

7. Enable terminal access only if needed.

8. Enable Browser vision tools if needed.

9. Optionally start MCP Bridge at OS login.

10. Start Local MCP, Web MCP, or both.

5. Add the connections in ChatGPT

In ChatGPT, enable Developer mode and add MCP connections using Tunnel as the connection method.

Local connection:

Name: Local Files
Connection: Tunnel
Tunnel: <your Local tunnel ID>

Browser connection:

Name: Chrome
Connection: Tunnel
Tunnel: <your Web tunnel ID>

Start the matching service in MCP Bridge before refreshing/scanning its tools in ChatGPT.

Mounted drives on Linux

MCP Bridge automatically discovers mounted filesystems under common Linux mount locations such as:

/mnt
/media/<user>
/run/media/<user>

Instead of making you work with an opaque mount path such as:

/mnt/289E678E9E6752FC

the UI can show the volume label, filesystem, size, and actual mount path.

Before a mounted root is exposed, MCP Bridge resolves the real path and confirms that the current user can read it. Read/write roots are also checked for write access.

This makes external SSDs and secondary drives first-class without weakening the Local MCP path-security model.

Desktop experience

• Dedicated app and tray icon

• Separate Linux WM_CLASS / desktop identity

• Click X to minimize instead of killing active tunnels

• Tray menu to reopen the app

• Start/stop Local MCP from the tray

• Start/stop Web MCP from the tray

• Restart running services

• Explicit Quit when you want the bridge terminated

• Optional launch at login

• Optional automatic Local/Web startup

• Runtime activity logs

Built-in updates

Starting with v0.2.1, MCP Bridge can update itself from GitHub Releases.

Update flow

1. Check the latest GitHub Release.

2. Compare semantic versions.

3. Select the correct installer for the current OS and architecture.

4. Download the installer locally.

5. Download the matching .sha256 file.

6. Verify the installer before installation is enabled.

7. You explicitly choose Install & restart.

Automatic checks happen shortly after launch and then periodically. They can be disabled in Settings.

Linux

download → SHA-256 verify → pkexec → apt install → relaunch MCP Bridge

The system elevation dialog is used. MCP Bridge does not store your sudo password.

Windows

download NSIS .exe → SHA-256 verify → launch installer → MCP Bridge exits

Updates are not silently installed.

Local MCP

Files and folders

• Multiple approved roots

• Read-only/read/write mode per root

• Mounted Linux drive support

• List files and directories

• File metadata

• Read UTF-8 text files

• Recursive filename/content search

• Create folders

• Create or replace text files

• Real-path and traversal protection

• Symlink escape protection

Shell

Terminal execution is optional.

Restricted shell supports normal development work while blocking several obvious destructive/system-level commands.

Examples:

npm install
npm run build
git status
git diff
git pull
git push
python script.py
adb devices

Restricted shell is a guardrail, not a complete OS sandbox.

Full shell executes Bash on Linux or PowerShell on Windows with the current user's privileges.

Treat Full Shell as local-user-equivalent code execution. Enable it only for a machine and MCP connection you trust.

Web MCP / Chrome

Web MCP uses chrome-devtools-mcp with your existing Chrome session, so ChatGPT can work with tabs and authenticated sessions already open on your computer.

Capabilities include:

• list/select/open/close tabs

• navigation

• click, hover, typing, forms, and keyboard input

• screenshots and accessibility snapshots

• console and network inspection

• performance tooling

• optional coordinate/vision tools

• optional usage-statistics opt-out

Chrome setup

Open:

chrome://inspect/#remote-debugging

Enable remote debugging for the Chrome profile you want MCP Bridge to use.

When Browser vision tools are enabled, MCP Bridge launches Chrome DevTools MCP with:

--experimentalVision

Packaged releases include

• MCP Bridge desktop app

• Local MCP server

• Chrome DevTools MCP

• Electron/Node runtime

• Full OpenAI tunnel-client

• Production app/tray icons

You do not need to manually install Node.js, npm, Go, the MCP SDK, Chrome DevTools MCP, or tunnel-client when using an official packaged release.

Release artifacts

Every installer also has a matching:

<installer>.sha256

The built-in updater refuses to install an update if its checksum is missing or does not match.

Build from source

Linux

git clone https://github.com/haseebgb92/ChatGPT-MCp.git
cd ChatGPT-MCp
npm install
npm start

Windows

git clone https://github.com/haseebgb92/ChatGPT-MCp.git
cd ChatGPT-MCp
npm install
npm start

A development run expects a full tunnel-client either on PATH or selected in Advanced settings.

Build installers

npm install
npm run check

Linux:

npm run dist:linux

Windows:

npm run dist:win

GitHub Actions builds the official release artifacts and SHA-256 sidecars from version tags.

Security

MCP Bridge deliberately exposes powerful local capabilities, so use the smallest access level that fits the task.

• Never commit Runtime API keys.

• Prefer a restricted Runtime API key.

• Use separate tunnel IDs for Local and Web MCP.

• Prefer read-only roots unless write access is required.

• Mounted roots are real-path checked before use.

• Enable shell only when required.

• Full shell is not a sandbox.

• Chrome MCP can act inside logged-in browser sessions.

• Review consequential actions before allowing them.

• Runtime logs redact OpenAI-style sk- keys.

• Update installers are SHA-256 verified before installation.

See SECURITY.md for details.

Project structure

.
├── .github/workflows/build.yml
├── assets/
├── bundled/
│   └── local-mcp/
├── docs/
│   └── images/
├── install-linux.sh
├── install-windows.ps1
├── src/
│   ├── main.js
│   ├── preload.js
│   ├── updater.js
│   └── renderer/
├── LICENSE
├── package.json
└── README.md

Current release

v0.2.1

This release adds the verified cross-platform updater on top of the v0.2.0 redesign, standalone desktop identity, tray workflow, and Linux mounted-drive support.

Download the latest release

License

MIT License.

Credits

• OpenAI Secure MCP Tunnel / tunnel-client

• Model Context Protocol

• Chrome DevTools MCP

• Electron

Built by Advertpreneur.

Meta Manager MCP (v0.2.9)

1. Install and open Meta Manager v0.1.21 or later on the same Windows or Linux computer. In Meta Manager → Settings verify that Local MCP is online.

2. Create a separate tunnel ID using OpenAI Tunnels. Never reuse your Local or Web tunnel IDs.

3. In MCP Bridge → Connection settings, enter the Meta Manager tunnel ID and your Runtime API key, then select Save settings.

4. Choose Start Meta in Connections. The tunnel client uses native HTTP transport to http://127.0.0.1:38939/mcp over the secure OpenAI tunnel (no extra proxy process required).

5. Connect the corresponding tunnel in ChatGPT. Both applications must be running to use local MCP tools; posts already scheduled through Meta Manager Cloud do not require either PC to remain on.

The Runtime API key is kept in secure local storage and is never included in installer files or public links. The Meta Manager local MCP service stays bound to 127.0.0.1 rather than a public HTTP listener. The tunnel ID alone is not a credential and cannot establish the connection without a Runtime API key and a running tunnel client.

Combined diagnostics and private GitHub report (v0.2.11)

Meta Manager v0.1.24+ records structured error categories for Facebook, Instagram, LinkedIn OAuth and MCP startup. MCP Bridge records its tunnel startup and runtime failures. Both applications keep their diagnostics in their own local app-data folders.

To send a reproducible support report:

1. Reproduce the error in Meta Manager or MCP Bridge.

2. In MCP Bridge, open Support diagnostics → Generate report.

3. Inspect the preview, which includes only allowlisted error categories, optional HTTP status, timestamps, application version, OS and local MCP reachability.

4. Choose Copy sanitized report, or Open GitHub issue draft.

5. GitHub opens an issue draft in the private Meta Manager repository (GitHub access required). Only you can submit it.

The applications do not automatically post reports, do not include raw process logs, and do not include OAuth codes/states, account names, tokens, Runtime API keys, tunnel IDs, passwords, usernames, email addresses or full file paths. Keep raw traces on your computer and never paste them into public issues.