Serveur MCP unplugin-devpilot
Commit 22 oct. 2026Un framework de plugins universel permettant aux agents IA d'interagir avec des applications web via une communication navigateur-serveur en temps réel et des outils MCP.
Aussi connu sous zcf0508/unplugin-devpilot
- Étoiles
- 33
- Outils
- —
- Téléchargements, 30 jours
- —
- Dernière version
- —
- Dernier commit
- 22 oct. 2026
- Licence
- MIT
Qu'est-ce que unplugin-devpilot MCP ?
Un framework de plugins universel permettant aux agents IA d'interagir avec des applications web via une communication navigateur-serveur en temps réel et des outils MCP.
Résumé généré à partir du README du projet
À propos du MCP server unplugin-devpilot
La fonction principale de unplugin-devpilot est de permettre aux agents IA d'interagir avec des applications web via une communication navigateur-serveur en temps réel. Ce framework fournit un système de plugins universel qui s'intègre au Model Context Protocol, permettant aux LLM d'automatiser des tâches web. Il est conçu pour les développeurs travaillant dans des environnements de développement locaux et fonctionne avec les principaux bundlers, notamment Vite, Webpack, Rspack et Farm.
Les utilisateurs configurent le serveur en installant le package principal et les plugins souhaités, comme le devpilot-plugin-dom-inspector, puis en important un module virtuel dans le point d'entrée de leur projet. Le système utilise un RPC bidirectionnel basé sur WebSocket pour faire le pont entre le navigateur et le serveur de développement. Il fonctionne exclusivement en mode développement pour garantir une absence totale de surcharge en production. Le plugin d'inspection DOM inclus fournit des outils spécifiques permettant à un agent de capturer des captures d'écran, de cliquer sur des éléments, de saisir du texte et d'accéder aux logs de la console du navigateur en utilisant des identifiants d'éléments spécialisés.
Ce que vous pouvez faire avec
- 1Automatiser les interactions webUn agent IA peut effectuer de l'automatisation de navigateur et de la manipulation du DOM à des fins de test.
- 2Inspecter la structure des applications webLes développeurs peuvent utiliser une IA pour analyser la hiérarchie visuelle et la structure du DOM d'une page.
- 3Créer des outils de développement personnalisésLes développeurs peuvent créer des extensions spécialisées disposant d'un accès en temps réel au navigateur.
Extrait du README du projet. Chaque cas d'utilisation est vérifié par rapport à une citation du document.
Vérifications automatisées
Exécuté le 14 nov. 2026Rapport complet →Pas encore vérifié. Un serveur nécessite un score de 80, aucune faille sérieuse et suffisamment de données pour que nous puissions effectuer les vérifications. Fonctionnement des vérifications · Ce qu'il faut corriger pour gagner des points
- Dépôt source lié et accessiblezcf0508/unplugin-devpilot is public and reachablegithub.com/zcf0508/unplugin-devpilot ↗Réussi
- Le nom du package correspond au dépôt sourceNon vérifié
- Provenance du build (attestation Sigstore)Non vérifié
- Licence open source (OSI)MITspdx.org/licenses/MIT.html ↗Réussi
- Commit ou version publiée au cours de l'année écouléeLast commit or release 2026-10-22github.com/zcf0508/unplugin-devpilot ↗Réussi
- OpenSSF ScorecardNon vérifié
- Nom du package non proche d'un package populaireNon vérifié
- Aucun avis critique dans le package ou ses dépendancesNon vérifié
- Aucune instruction cachée destinée au modèle0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersRéussi
- Les outils destructifs sont étiquetésNon vérifié
- Le point de terminaison distant répond à la poignée de main MCPNon vérifié
README
Voir sur GitHubunplugin-devpilot
A universal plugin framework for development tools that enables seamless browser-server communication and MCP (Model Context Protocol) integration with AI/LLM systems.
Features
- 🔌 Universal Plugin System - Create plugins once, use everywhere
- 🌐 Multi-Bundler Support - Works with Vite, Webpack, Rspack, Farm, and more via unplugin
- 🔄 Real-time Communication - WebSocket-based bidirectional RPC between browser and development server (works with HTTP and HTTPS)
- 🤖 MCP Integration - Built-in Model Context Protocol server for AI/LLM automation
- 🎯 DOM Inspector Plugin - Out-of-the-box DOM inspection and manipulation for web automation
- 🛠️ Development-Only - Zero production overhead, only runs in dev mode
- 🔒 HTTPS Support - Works seamlessly with HTTPS dev servers via automatic WebSocket proxy
Quick Start
Installation
npm install -D unplugin-devpilot
npm install -D devpilot-plugin-dom-inspector
Setup
// vite.config.ts
import DomInspector from 'devpilot-plugin-dom-inspector';
import Devpilot from 'unplugin-devpilot/vite';
import { defineConfig } from 'vite';
export default defineConfig({
plugins: [
Devpilot({
plugins: [DomInspector],
}),
],
});
The WebSocket proxy is automatically configured for both HTTP and HTTPS development servers.
// webpack.config.js
import DomInspector from 'devpilot-plugin-dom-inspector';
import Devpilot from 'unplugin-devpilot/webpack';
export default {
plugins: [
Devpilot({
plugins: [DomInspector],
}),
],
};
The WebSocket proxy is automatically configured in webpack-dev-server.
// rspack.config.ts
import DomInspector from 'devpilot-plugin-dom-inspector';
import Devpilot from 'unplugin-devpilot/rspack';
export default {
plugins: [
Devpilot({
plugins: [DomInspector],
}),
],
};
The WebSocket proxy is automatically configured in rspack-dev-server.
// farm.config.ts
import DomInspector from 'devpilot-plugin-dom-inspector';
import Devpilot, { getProxyConfig } from 'unplugin-devpilot/farm';
// Note: wsPort is the WebSocket server port (obtained from console output)
export default defineConfig({
plugins: [
Devpilot({
plugins: [DomInspector],
}),
],
server: {
proxy: getProxyConfig(60427),
},
});
Farm requires manual proxy configuration. The getProxyConfig(wsPort) helper generates the correct proxy settings. The actual wsPort will be logged to the console when the dev server starts.
Client Import
Add this import to your project entry point to enable the devpilot client:
// main.ts or main.js (entry point)
import 'virtual:devpilot-client';
For TypeScript projects, add type support for the virtual module in your tsconfig.json:
{
"compilerOptions": {
"types": ["unplugin-devpilot/virtual"]
}
}
This import activates the WebSocket connection to the development server and initializes all registered plugins on the client side.
In dev, a Lit + Shadow DOM task overlay loads: Tasks polls the queue every second and lists pending + in progress; use Get approval token before complete_task in MCP. Alt+Shift+I enqueues a task; the agent uses get_pending_tasks (often with clearAfterFetch: false), claim_task, then complete_task with a developer-issued token. The Devpilot badge shows the pending count.
Plugins can export a taskPayloadHook from their client module to enrich the task payload before submission. For example, devpilot-plugin-dom-inspector lazily assigns a devpilotId (e* encoding) to the picked element, so the agent can reference it directly via MCP tools.
Packages
unplugin-devpilot
Core plugin framework providing:
- Multi-bundler support through unplugin
- WebSocket server for browser-server communication
- MCP server for AI/LLM integration
- Plugin system with namespace isolation
- Virtual module generation for client-side code
devpilot-plugin-dom-inspector
Built-in DOM inspection plugin offering:
- Compact DOM snapshots optimized for LLM tokens
- Element querying via devpilot-id or CSS selectors (supports :has() and advanced selectors)
- Element interaction (click, text input)
- Scroll elements into view
- Visual layout analysis
- Browser console log access
- Page and element screenshot capture
- 8 MCP tools for web automation
MCP Tools:
get_page_snapshot- Get LLM-friendly DOM structure (compact, token-efficient)get_visual_hierarchy- Analyze visual layout hierarchy and coverageget_element_details- Get comprehensive element info (HTML + accessibility + position)click_element- Click elementsinput_text- Fill form fieldsget_console_logs- Access browser logs (error/warn/info/debug only;console.logis NOT captured)scroll_to_element- Scroll element into view (for scrollable containers)capture_screenshot- Capture page or element screenshot (cross-origin images without CORS headers may appear blank)
Element ID Format: All element identifiers use the e prefix format (e.g., e1, e2, e123). The get_page_snapshot tool returns devpilotId in this format, which can be directly used in other APIs.
Use Cases
Web Automation
Automate browser interactions and DOM manipulation for testing and scripting.
AI/LLM Integration
Enable AI systems to interact with web applications through standardized MCP tools.
Development Tools
Build custom development tools and extensions with real-time browser access.
Browser-Based Debugging
Debug and inspect web applications with real-time server communication.
Architecture Overview
┌────────────────────────────────────────────┐
│ Web Application Browser │
│ ┌─────────────────────────────────────┐ │
│ │ Virtual Module: devpilot-client │ │
│ │ - WebSocket Connection │ │
│ │ - RPC Handlers │ │
│ │ - Plugin Client Modules │ │
│ └─────────────────────────────────────┘ │
│ ▲ ▲ │
│ │ WebSocket │ RPC │
└───────────┼────────────────────┼───────────┘
│ │
│ WSS (via dev │ WS (direct)
│ server proxy) │
┌───────────┼────────────────────┼──────────┐
│ ▼ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ Development Server (Node.js) │ │
│ │ ┌──────────────────────────────┐ │ │
│ │ │ WebSocket Proxy │ │ │
│ │ │ (auto-configured for all │ │ │
│ │ │ bundlers) │ │ │
│ │ └──────────────────────────────┘ │ │
│ │ ┌──────────────────────────────┐ │ │
│ │ │ WebSocket Server (:3100) │ │ │
│ │ │ - Client Management │ │ │
│ │ │ - RPC Routing │ │ │
│ │ └──────────────────────────────┘ │ │
│ │ ┌──────────────────────────────┐ │ │
│ │ │ MCP Server (:3101) │ │ │
│ │ │ - Tool Registration │ │ │
│ │ │ - Tool Invocation │ │ │
│ │ └──────────────────────────────┘ │ │
│ │ ┌──────────────────────────────┐ │ │
│ │ │ Plugin System │ │ │
│ │ │ - DOM Inspector │ │ │
│ │ │ - Custom Plugins │ │ │
│ │ └──────────────────────────────┘ │ │
│ └─────────────────────────────────────┘ │
│ ▲ │
│ │ MCP Protocol │
└───────────┼───────────────────────────────┘
│
┌───────┴───────┐
│ │
┌───▼──┐ ┌─────▼────┐
│ LLM │ │ AI Tools │
└──────┘ └──────────┘
Plugin Development
Create a custom plugin:
import type { DevpilotPlugin } from 'unplugin-devpilot';
import { defineMcpToolRegister, resolveClientModule } from 'unplugin-devpilot';
export default {
namespace: 'my-plugin',
clientModule: resolveClientModule(import.meta.url, './client/index.mjs'),
serverSetup(ctx) {
return {
// Server-side RPC methods
myServerMethod: (arg: string) => `Result: ${arg}`,
};
},
mcpSetup(ctx) {
return [
defineMcpToolRegister(
'my_tool',
{
title: 'My Tool',
description: 'A custom MCP tool',
inputSchema: z.object({
param: z.string(),
}),
},
async (params) => {
// Tool implementation
return {
content: [{
type: 'text' as const,
text: `Tool result: ${params.param}`,
}],
};
},
),
];
},
} satisfies DevpilotPlugin;
Skill File
Plugins can provide a skillModule to help LLMs understand and use the plugin's capabilities. This is a markdown file or folder that describes the plugin's purpose, available tools, and usage patterns.
import type { DevpilotPlugin } from 'unplugin-devpilot';
import { resolveModule } from 'unplugin-devpilot';
export default {
namespace: 'my-plugin',
clientModule: resolveClientModule(import.meta.url, './client/index.mjs'),
skillModule: resolveModule(import.meta.url, './skill.md'), // or './skills' for a folder
// ...
} satisfies DevpilotPlugin;
Single File Mode:
skillModule: resolveModule(import.meta.url, './skill.md');
The skill file is copied to the output directory as {namespace}.md.
Folder Mode:
skillModule: resolveModule(import.meta.url, './skills');
When using a folder:
- If
index.mdexists, the link points to{namespace}/index.md - If no
index.md, the link points to{namespace}/and LLM explores the folder - All files in the folder are copied recursively
Skill File Guidelines:
- Keep under 100 lines for core instructions
- Include tool descriptions, parameters, and usage examples
- Put the applicable scope in the frontmatter
description; the core skill quotes it verbatim so agents can pick the right plugin before reading the file - For complex plugins, use folder mode with multiple
.mdfiles
Each Available Skills entry in the generated core skill combines the namespace with the frontmatter description of the entry file. Single-file skills read {namespace}.md itself; folder skills prefer index.md and fall back to SKILL.md. Without a description, the entry falls back to {namespace} capabilities.
Plugin Storage
Each plugin gets a namespaced storage instance (powered by unstorage) via ctx.storage, available in both serverSetup and mcpSetup. Storage is isolated per plugin namespace, so plugins won't interfere with each other.
Server-side: Reading and Writing
export default {
// In serverSetup or mcpSetup
serverSetup(ctx) {
return {
async saveData(items: MyData[]) {
// Domain-specific logic runs on the server
const existing = await ctx.storage.getItem<MyData[]>('key') || [];
const merged = [...existing, ...items];
await ctx.storage.setItem('key', merged);
},
};
},
mcpSetup(ctx) {
// MCP tools read directly from storage - no browser RPC needed
const data = await ctx.storage.getItem<MyData[]>('key') || [];
},
};
Client-side: Basic KV via RPC Bridge
The client can use createClientStorage for simple key-value operations that bridge to server storage via WebSocket RPC:
import { createClientStorage, getDevpilotClient } from 'unplugin-devpilot/client';
const client = getDevpilotClient();
const storage = createClientStorage(client, 'my-plugin');
await storage.setItem('key', value);
const data = await storage.getItem<MyType>('key');
Client-side: Calling Plugin Server Methods
For domain-specific operations (e.g., incremental append with deduplication), define methods in serverSetup and call them from the client via rpcCall:
// shared-types.ts - Shared type ensures client and server stay in sync
export interface MyPluginServerMethods extends Record<string, (...args: any[]) => any> {
appendData: (items: MyData[]) => Promise<void>
}
// server (index.ts)
export default <DevpilotPlugin>{
serverSetup(ctx): MyPluginServerMethods {
return {
async appendData(items) {
const existing = await ctx.storage.getItem<MyData[]>('data') || [];
await ctx.storage.setItem('data', [...existing, ...items].slice(-500));
},
};
},
};
// client
import { getDevpilotClient } from 'unplugin-devpilot/client';
const client = getDevpilotClient<MyPluginServerMethods>();
client.rpcCall('appendData', batch);
This pattern keeps domain logic on the server, minimizes RPC payload, and maintains type safety across both sides.
Development
Prerequisites
- Node.js 22+
- pnpm@~9
Install dependencies
pnpm install
Build
pnpm build
Development mode
pnpm dev
Run tests
pnpm test
Type checking
pnpm typecheck
Configuration
Port Configuration
The plugin automatically manages port allocation internally:
Devpilot({
mcpPort: 3101, // Optional: MCP server port (defaults to 3101)
plugins: [/* ... */],
});
Port Allocation:
- WebSocket: Port is automatically allocated internally. The WebSocket connection is proxied through the dev server (via
/__devpilot_ws), so it works seamlessly with both HTTP and HTTPS. - MCP: Defaults to port 3101. If occupied, specify a different port or free up the occupied port.
HTTPS Support
The plugin automatically works with HTTPS development servers (e.g., using unplugin-https-reverse-proxy or Vite's built-in HTTPS). The WebSocket connection is proxied through the dev server using the same protocol:
- HTTP pages: Connects via
ws://(WebSocket) - HTTPS pages: Connects via
wss://(Secure WebSocket)
No additional configuration is required for HTTPS support.
Plugin Options
Each plugin can be configured based on its implementation. Refer to individual plugin documentation.
Performance
- Zero Production Cost - Only runs in development mode
- Minimal Overhead - Lazy-loads plugin client modules
- Efficient Communication - Binary WebSocket messages
- Token Optimized - Compact DOM snapshots for LLM usage
Troubleshooting
WebSocket Connection Failed
- Ensure development server is running
- For HTTPS servers, ensure the certificate is trusted by your browser
- Check browser console for connection errors
MCP Tools Not Available
- Confirm plugins are registered in configuration
- Check server logs for plugin loading errors
- Verify MCP server is running on port 3101
Client Not Found
- Refresh the browser page to reconnect
- Check browser console for connection errors
- Use
get_visual_hierarchyorlist_clientstools to discover available clients
License
MIT © 2025 zcf0508
Contributing
Contributions welcome! Please feel free to submit a Pull Request.
Resources
Questions sur unplugin-devpilot MCP
Puis-je l'utiliser en production ?
Non, il est conçu uniquement pour le développement et n'ajoute aucune charge en production.
Prend-il en charge le HTTPS ?
Oui, il fonctionne avec les serveurs de développement HTTPS grâce à un proxy WebSocket automatique.