universal-dev-mcp

A universal MCP (Model Context Protocol) server that gives AI tools live access to your running local development application. Connect Claude Desktop, Cursor, Windsurf, Zed, Gemini, ChatGPT, or any MCP-compatible tool to your localhost dev server — view pages, call APIs, read and edit source files, run commands, and switch between projects — all with configurable safety guardrails.

How it works

universal-dev-mcp sits between your AI tool and your local dev environment. It exposes two transport layers depending on what your AI tool supports:

┌──────────────────────────────────────────────────────────────────┐
│                           AI Tools                               │
│                                                                  │
│   ┌─────────────────────────┐    ┌────────────────────────────┐  │
│   │  Claude Desktop         │    │  Gemini  │  ChatGPT  │ etc │  │
│   │  Cursor / Windsurf / Zed│    └────────────────────────────┘  │
│   │  any MCP-compatible tool│              │                     │
│   └────────────┬────────────┘              │ HTTP + SSE          │
│                │ MCP stdio (JSON-RPC)       │ localhost:3333      │
└────────────────┼──────────────────────────-┼────────────────────-┘
                 │                            │
       ┌─────────▼──────────┐      ┌──────────▼─────────┐
       │    server.ts        │      │   http-server.ts    │
       │    (stdio mode)     │      │   (HTTP/SSE mode)   │
       └─────────┬───────────┘      └──────────┬──────────┘
                 └──────────────┬───────────────┘
                                │
                    ┌───────────▼───────────┐
                    │      12 MCP Tools      │
                    │                        │
                    │  get_active_project    │
                    │  get_project_info      │
                    │  check_port            │
                    │  view_page             │
                    │  get_api_response      │
                    │  read_file             │
                    │  edit_file             │
                    │  patch_file            │
                    │  list_files            │
                    │  delete_file           │
                    │  move_file             │
                    │  search_files          │
                    │  run_command           │
                    └───────────┬───────────┘
                                │  allowlist guards + auto-backup
                                │
               ┌────────────────▼────────────────┐
               │      Your local dev project      │
               │      localhost:5173 / :3000      │
               │      src/  package.json  etc.    │
               └─────────────────────────────────-┘

MCP stdio (server.ts) — used by editors that support MCP natively (Claude Desktop, Cursor, Windsurf, Zed). The editor spawns the server as a child process and communicates over stdin/stdout.

HTTP/SSE (http-server.ts) — used by tools that don't support MCP stdio. Exposes a REST API and an OpenAI-compatible tool-calling interface so any HTTP client can call the same tools.

All tool calls go through the same security layer regardless of transport: port allowlist, command allowlist, write directory scope, and automatic file backups.

Available tools

Tool	Description
`get_active_project`	Show which project is currently active — name, root, git branch, file count. Use this to confirm a project switch worked.
`get_project_info`	Read package.json, scripts, dependencies, config files, and project structure. Run this first.
`check_port`	Verify a dev server is running and responding on a given port.
`view_page`	Fetch a page from a running local dev server — returns title, meta tags, scripts, and visible text.
`get_api_response`	Make HTTP requests (GET/POST/PUT/DELETE/PATCH) to API endpoints on a local server.
`read_file`	Read a source file, optionally limiting output to a line range.
`edit_file`	Overwrite a file with new content. A timestamped backup is created automatically.
`patch_file`	Replace a unique string within a file without rewriting it entirely. Backup created automatically.
`list_files`	Display the project directory as a file tree.
`delete_file`	Delete a file. A timestamped backup is created automatically before deletion.
`move_file`	Move or rename a file within the project. A backup is created automatically.
`search_files`	Search for a text string or regex across all project files with optional filename glob filter.
`run_command`	Run an allowlisted shell command (tests, lint, build, type-check) in the project root.

Project structure

universal-dev-mcp/
├── src/
│   ├── cli/
│   │   └── switch.ts          Cross-platform CLI for switching projects (mcp-switch)
│   ├── config.ts              Environment variables and defaults
│   ├── server.ts              MCP stdio entry point
│   ├── http-server.ts         HTTP/SSE server for tools that do not support MCP stdio
│   ├── tools/
│   │   ├── index.ts           Registers all tools onto the server
│   │   ├── browser.ts         view_page, check_port
│   │   ├── api.ts             get_api_response
│   │   ├── files.ts           read_file, edit_file, patch_file, list_files, delete_file, move_file
│   │   ├── search.ts          search_files
│   │   ├── commands.ts        run_command
│   │   └── project.ts         get_project_info, get_active_project
│   └── utils/
│       ├── security.ts        Port, command, and path access guards
│       ├── backup.ts          File backup creation, rotation, and cleanup
│       ├── fetch.ts           HTTP fetch helpers and HTML parsing utilities
│       └── fs.ts              File tree generation and path helpers
├── projects.json              List of projects for mcp-switch
├── .env.example               Configuration template
├── .gitignore
├── LICENSE                    MIT License
├── package.json
├── tsconfig.json
└── README.md

Installation

git clone https://github.com/rj9884/universal-dev-mcp
cd universal-dev-mcp
npm install
# npm install automatically compiles TypeScript via the prepare script

To make the mcp-switch CLI available globally on your machine:

npm link

Configuration

cp .env.example .env

Edit .env:

PROJECT_ROOT=/Users/yourname/projects/my-app

# Ports your dev servers run on
# Vite=5173  Next.js/CRA=3000  Angular=4200  Vue=8080
ALLOWED_PORTS=3000,5173

# Commands the AI may run
ALLOWED_COMMANDS=npm test,npm run lint,npm run build

# Port for the HTTP server (Gemini / ChatGPT mode)
HTTP_PORT=3333

# Optional: require an API key on all HTTP endpoints
# MCP_API_KEY=your-secret-key

Connecting to Claude Desktop

Edit your Claude Desktop config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json or %LOCALAPPDATA%\Packages\Claude_*\LocalCache\Roaming\Claude\claude_desktop_config.json (Windows Store install)
Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "universal-dev-mcp": {
      "command": "node",
      "args": ["/absolute/path/to/universal-dev-mcp/dist/server.js"],
      "env": {
        "PROJECT_ROOT": "/absolute/path/to/your/project",
        "ALLOWED_PORTS": "5173,3000",
        "ALLOWED_COMMANDS": "npm test,npm run lint,npm run build"
      }
    }
  }
}

Use absolute paths. Restart Claude Desktop after saving.

Switching projects

Instead of manually editing claude_desktop_config.json every time you switch projects, use the built-in mcp-switch CLI. It works on Windows, macOS, and Linux.

Setup

Add your projects to projects.json in the repo root:

{
  "projects": [
    {
      "name": "my-react-app",
      "root": "/Users/yourname/projects/my-react-app",
      "allowed_ports": "3000,5173",
      "allowed_commands": "npm run build,npm test,npm run dev"
    },
    {
      "name": "my-api-server",
      "root": "/Users/yourname/projects/my-api-server",
      "allowed_ports": "8080",
      "allowed_commands": "npm run build,npm test"
    }
  ]
}

Commands

# Interactive menu — pick a project by number
npx mcp-switch

# Switch directly by name
npx mcp-switch use my-react-app

# Show the currently active project
npx mcp-switch current

# List all projects (active one is marked with *)
npx mcp-switch list

# Add a new project interactively
npx mcp-switch add

After switching, restart Claude Desktop for the change to take effect.

Confirming the switch inside Claude

After restarting Claude Desktop, ask Claude:

"which project is active?"

Claude will call get_active_project and show you the project name, root path, git branch, and file count — so you can visually confirm the switch worked.

Connecting to MCP-compatible editors

Any editor that supports MCP stdio (Cursor, Windsurf, Zed, and others) uses the same configuration format. Open your editor's MCP settings and add the same server block shown in the Claude Desktop section above, then restart the editor.

Connecting to Gemini / ChatGPT (HTTP mode)

Start the HTTP server:

npm run start:http

The server starts on http://localhost:3333.

Available HTTP endpoints

Method	Path	Description
GET	`/`	Server info and endpoint list
GET	`/health`	Health check
GET	`/tools`	List all tools
POST	`/call`	Call a tool by name
GET	`/openai/tools`	Tool schemas in OpenAI function-calling format
POST	`/openai/call`	Execute OpenAI-format tool calls
GET	`/sse`	Server-Sent Events stream
POST	`/sse/broadcast`	Broadcast an event to all SSE clients

Example: calling a tool directly

curl -X POST http://localhost:3333/call \
  -H "Content-Type: application/json" \
  -d '{"name": "get_project_info", "arguments": {}}'

Example: Gemini integration (TypeScript)

import { GoogleGenerativeAI } from "@google/generative-ai";

const MCP_URL = "http://localhost:3333";

async function getMcpTools() {
  const res = await fetch(`${MCP_URL}/openai/tools`);
  const { tools } = await res.json();
  return tools;
}

async function callMcpTool(name: string, args: Record<string, unknown>): Promise<string> {
  const res = await fetch(`${MCP_URL}/openai/call`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      tool_calls: [
        { id: "call_1", function: { name, arguments: JSON.stringify(args) } },
      ],
    }),
  });
  const { tool_results } = await res.json();
  return tool_results[0].content;
}

async function main() {
  const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);
  const tools = await getMcpTools();

  const model = genAI.getGenerativeModel({
    model: "gemini-1.5-pro",
    tools: [{ functionDeclarations: tools.map((t: any) => t.function) }],
  });

  const chat = model.startChat();
  let result = await chat.sendMessage("Get an overview of my project.");

  while (result.response.functionCalls()?.length) {
    const toolResponses = await Promise.all(
      result.response.functionCalls()!.map(async (call) => {
        const output = await callMcpTool(call.name, call.args as Record<string, unknown>);
        return { functionResponse: { name: call.name, response: { result: output } } };
      })
    );
    result = await chat.sendMessage(toolResponses);
  }

  console.log(result.response.text());
}

main();

Security

All tool calls are restricted by the following controls:

Port allowlist — AI can only connect to ports listed in ALLOWED_PORTS.
Command allowlist — AI can only run commands listed in ALLOWED_COMMANDS.
Write directory scope — File writes are restricted to ALLOWED_WRITE_DIRS (defaults to PROJECT_ROOT).
Path traversal protection — All paths are resolved and validated against allowed directories before any operation.
Automatic backups — Every file write or delete creates a .mcp-backups/filename.timestamp.bak before making any change. Backups older than 7 days are cleaned up automatically; at most 10 backups are kept per file.
API key — Set MCP_API_KEY to require authentication on all HTTP endpoints.

Restoring a backup

ls .mcp-backups/
cp .mcp-backups/App.tsx.2026-03-13T10-00-00.bak src/App.tsx

npm scripts

npm run build         # Compile TypeScript to dist/
npm run start         # Start stdio server (Claude Desktop, Cursor, Windsurf, Zed)
npm run start:http    # Start HTTP/SSE server (Gemini / ChatGPT)
npm run dev           # stdio server with ts-node (no build step)
npm run dev:http      # HTTP server with ts-node (no build step)

Example prompts

Once connected to your AI tool:

Which project is currently active?

Check if my dev server is running on port 5173.

Get an overview of my project and tell me what tech stack it uses.

Fetch the homepage from localhost:5173 and describe the UI structure.

Search for all usages of the useAuth hook across the project.

Read src/App.tsx and identify any potential issues.

Run npm test and summarize any failures.

Fix the TypeScript error in src/utils/api.ts on line 42.

Rename src/utils/helpers.ts to src/utils/format.ts.

License

See LICENSE for the full text.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

universal-dev-mcp

Table of contents

How it works

Available tools

Project structure

Installation

Configuration

Connecting to Claude Desktop

Switching projects

Setup

Commands

Confirming the switch inside Claude

Connecting to MCP-compatible editors

Connecting to Gemini / ChatGPT (HTTP mode)

Available HTTP endpoints

Example: calling a tool directly

Example: Gemini integration (TypeScript)

Security

Restoring a backup

npm scripts

Example prompts

License

About

Uh oh!

Releases

Packages

Uh oh!

Contributors

Uh oh!

Languages

Name		Name	Last commit message	Last commit date
Latest commit History 38 Commits
src		src
.env.example		.env.example
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
package-lock.json		package-lock.json
package.json		package.json
projects.json		projects.json
tsconfig.json		tsconfig.json

Folders and files

Latest commit

History

Repository files navigation

universal-dev-mcp

Table of contents

How it works

Available tools

Project structure

Installation

Configuration

Connecting to Claude Desktop

Switching projects

Setup

Commands

Confirming the switch inside Claude

Connecting to MCP-compatible editors

Connecting to Gemini / ChatGPT (HTTP mode)

Available HTTP endpoints

Example: calling a tool directly

Example: Gemini integration (TypeScript)

Security

Restoring a backup

npm scripts

Example prompts

License

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages