@yawlabs/electron-mcp
OfficialProvides read-only Electron development intelligence for secure IPC, security, builds, migration, performance, and core concepts.
Scaffold secure IPC channels, preload bridges, multi-window managers, and complete Electron projects.
Audit IPC and app security against official Electron recommendations and dangerous patterns.
Generate production hardening config for Electron fuses, CSP, auto-updates, and deep linking.
Diagnose electron-builder/forge/packager build and signing errors.
Plan major-version migrations and scan for deprecated/removed APIs.
Audit performance anti-patterns and get targeted fixes.
Explain Electron concepts, process model details, and embedded-knowledge freshness.
All tools are read-only/idempotent and do not modify files or execute code.
Provides tools for Electron app development: IPC scaffolding, security auditing, migration guidance, performance analysis, and more.
Provides tools for diagnosing electron-builder/forge build errors, configuring auto-updates, and managing code signing.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@@yawlabs/electron-mcp Audit my Electron security settings"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@yawlabs/electron-mcp
One click adds this to your local Yaw MCP config so it's available in every Yaw Terminal session. Tested with Yaw MCP 1.1.13 or newer. Or install manually below.
Make your AI assistant actually good at Electron. 18 tools for the stuff AI models hallucinate about: context isolation, preload bridges, fuses, CSP, signing, auto-updates, breaking changes between majors, and the 20 official security recommendations.
This is not a runtime debugger. It is a development-intelligence layer that turns "write me some Electron code" from hit-or-miss into correct-on-the-first-try.
Built and maintained by Yaw Labs.
Why this one?
Other Electron MCP servers give your model a shell and hope. This one doesn't.
IPC that isn't a security hole —
electron_scaffold_ipc_channelgenerates main handler + typed preload bridge + contextBridge exposure + renderer usage in one call. NonodeIntegration: true, no directipcRendereronwindow.The official security recommendations, enforced —
electron_audit_securitychecks yourBrowserWindowconfig, preload scripts, and CSP against 19 of the 20 items from electronjs.org/docs/latest/tutorial/security that can be verified from static inputs. (The 20th, session permission handling, needs runtime context and is flagged in the report footer.) Not a vibe check.Version-aware migration —
electron_migrate_versionknows the breaking changes from v28 through v41 and tells you exactly what will break when you bump.electron_check_deprecated_apisscans your code for APIs that were removed.Build errors, explained —
electron_diagnose_build_errorparses electron-builder/forge output and identifies root causes: Apple signing, Windows code signing, native module rebuilds, ASAR packaging, entitlements, path quoting.Modern production hardening —
electron_configure_fusesgenerates the@electron/fusesblock for disabling unused runtime features (cookie encryption, Node CLI flags, legacy load behaviour).electron_configure_cspgenerates a CSP that actually works with your bundler and framework instead of blocking your own assets.Knowledge freshness is declared, not assumed — every response includes a
_Knowledge last verified YYYY-MM-DD (Electron vN stable)_footer. Callelectron_knowledge_versionto get the metadata directly. If your Electron is newer than the footer, the tool tells you.Read-only, no side effects — every tool declares
readOnlyHint,destructiveHint: false,idempotentHint: true, so MCP clients can skip confirmation. The tools never touch your filesystem, never run code, never callexec.Zero runtime dependencies — ships as a single bundled file. No 5-minute
node_modulesinstall, noelectronorelectron-builderinstalled as dependencies to inflate your project. The published package'sdependenciesis{}; Dependabot alerts on this repo are against devDependencies. Most of that surface (the MCP SDK's HTTP transport:hono,express,ip-address,qs) is not in the bundle — this server uses stdio only — butfast-uri, which the SDK's default JSON Schema validator (ajv) needs, is inlined intodist/index.js, so an advisory against it is cleared by a new release, not by reinstalling.
Related MCP server: MCP Frontend Tools Server
Quick start
No API keys. No environment variables required. Just install it.
1. Create .mcp.json in your project root
macOS / Linux / WSL:
{
"mcpServers": {
"electron": {
"command": "npx",
"args": ["-y", "@yawlabs/electron-mcp@latest"]
}
}
}Windows:
{
"mcpServers": {
"electron": {
"command": "cmd",
"args": ["/c", "npx", "-y", "@yawlabs/electron-mcp@latest"]
}
}
}Why the extra step on Windows? Since Node 20,
child_process.spawncannot directly execute.cmdfiles (that's whatnpxis on Windows). Wrapping withcmd /cis the standard workaround.
2. Restart and approve
Restart Claude Code (or your MCP client) and approve the Electron MCP server when prompted.
That's it. Now ask your AI assistant:
"Add a file picker to my Electron app"
"Audit my BrowserWindow config for security issues"
"My electron-builder is failing with a signing error — here's the output"
"Generate a CSP for my Vite + React renderer"
"What breaks if I upgrade from Electron 32 to 41?"
Alternate MCP clients
Client | Config file |
Claude Code |
|
Claude Desktop |
|
Cursor |
|
Windsurf |
|
VS Code |
|
Use the same JSON block shown above in any of these.
Runtime and sandbox
The launcher prefers the oam runtime when a current one (0.20.2 or newer) is installed, and falls back to the Node that is already running it. Nothing to configure; both serve the same server.
Opt-in sandbox. With oam, the server can run under --permission with no grants at all: no filesystem, no child processes, no network, no environment. This server needs none of them (every tool computes over its arguments and returns markdown), so the sandbox costs no capability and turns anything the server merely happens not to use into a runtime refusal. Add an env block to whichever config block you used above (npx on macOS / Linux / WSL, cmd /c npx on Windows):
"env": { "ELECTRON_MCP_SANDBOX": "1", "ELECTRON_MCP_RUNTIME": "oam" }The second variable is what makes the sandbox required: it needs a freshly spawned oam (0.20.2 or newer) to apply it, and with ELECTRON_MCP_RUNTIME=oam a missing or unusable oam is a startup error instead of an unsandboxed server. Under the default ELECTRON_MCP_RUNTIME=auto the launcher still serves in that case, without --permission, and prints a line on stderr saying so and how to fix it. Use auto when you want the sandbox where available; use oam when you want to be sure.
How to tell it took: every path that serves without the sandbox after it was asked for prints an electron-mcp: line on stderr containing runs WITHOUT --permission, plus how to fix it (most MCP clients show server stderr in their logs). When the sandbox is applied there is no such line. To confirm from a shell:
ELECTRON_MCP_SANDBOX=1 ELECTRON_MCP_RUNTIME=oam npx -y @yawlabs/electron-mcp@latest --versionThe version on stdout, exit 0, and no WITHOUT --permission line means a sandboxed oam served it; with ELECTRON_MCP_RUNTIME=oam set, a missing oam is an error instead.
It is off by default because it is a behaviour change: a future version that legitimately needs a capability should fail in review, not in your session. Two more things to know:
If the launcher itself is already running under oam (Yaw MCP does this), the sandbox spawns a second oam (the host's own binary, if nothing newer is installed), because only a fresh one can apply a process-level flag. That adds one runtime boot to startup, plus a
--versionprobe per oam binary the launcher finds.Request the sandbox through the variable, not by putting
--permissionon the host command: a launcher running under bare--permissioncannot read its environment, so everyELECTRON_MCP_*setting would be ignored. A host that also grants--allow-env(with--allow-child-process) does let them through; then a handoff to Node (ELECTRON_MCP_RUNTIME=node, or a host oam below the floor) runsnode --permissionwith no grants, because oam otherwise copies the host's--permission/--allow-*flags into Node'sNODE_OPTIONSand Node refuses oam-only ones such as--allow-env=(exit 9, nothing served); the launcher prints oneelectron-mcp:line saying so. (The direct, no-launcher form isoam --permission run <path>/dist/index.js.)
Variable | Effect |
| newest usable oam, else Node (default) |
| newest usable oam, else exit with an error |
| always Node (the sandbox is not applied, and the launcher says so) |
| run oam under |
| use this oam when it is usable, before discovery |
| oam's own install-target variable; when set, |
Both values are case-insensitive and trimmed. A value the launcher does not recognise is never a silent no-op: it is treated as the default (auto; sandbox off) and named on stderr, so a typo cannot quietly turn "sandbox required" into "sandbox if convenient".
Tools (18)
IPC & process architecture (5)
electron_scaffold_ipc_channel — Generate a complete IPC round-trip: main handler, preload bridge,
contextBridgeexposure, TypeScript types, renderer usage.electron_generate_preload_bridge — Generate a secure
preload.tswithcontextBridgefor multiple API methods.electron_audit_ipc_security — Analyze preload/main/renderer code for IPC security issues (direct
ipcRenderer, missing sender validation, channel injection).electron_generate_window_manager — Multi-window management with lifecycle tracking and inter-window communication.
electron_explain_process_model — Version-aware explanation of Electron's multi-process architecture (main vs renderer vs utility, what lives where).
Security (4)
electron_audit_security — Audit against 19 of the 20 official security recommendations that can be detected from static inputs: BrowserWindow, preload, CSP, remote content, sandbox. (Session permission handling is the 20th; it needs runtime context and is flagged in the report footer.)
electron_configure_fuses — Generate
@electron/fusesconfig for production hardening (disable cookie encryption fallback, Node CLI flags, legacy load behaviour).electron_configure_csp — Generate a Content Security Policy aware of your bundler (Vite/webpack/Parcel) and framework (React/Vue/Svelte).
electron_lint_security — Static analysis for dangerous patterns:
shell.openExternalwith untrusted input,@electron/remote,enableBlinkFeatures, etc.
Build & distribution (4)
electron_diagnose_build_error — Parse electron-builder/forge errors and identify root causes: code signing, native modules, ASAR, entitlements, path quoting.
electron_configure_auto_update — Generate complete
electron-updatersetup with events and platform-specific signing concerns.electron_configure_deep_linking — Custom protocol registration across Windows/macOS/Linux.
electron_scaffold_project — Generate a secure, modern Electron project scaffold (contextIsolation: true, sandbox: true, preload, TypeScript, chosen framework).
Migration & compatibility (2)
electron_migrate_version — Migration checklist between Electron versions with breaking changes, deprecated APIs, platform support changes.
electron_check_deprecated_apis — Scan source for APIs deprecated or removed in the target Electron version.
Performance (1)
electron_audit_performance — Detect the 7 official Electron performance anti-patterns (sync I/O on main, eager loading of heavy modules, etc).
Reference (2)
electron_explain_concept — Authoritative explainer for 8 topics: process model, context isolation, sandbox, IPC, ASAR, fuses, code signing, build tools.
electron_knowledge_version — Metadata about the embedded knowledge: last-verified date, Electron stable at verification, supported version range. Call this if an agent is unsure whether advice is current.
Knowledge freshness
Tools that depend on embedded Electron knowledge (breaking changes, deprecated APIs, security recommendations, anti-patterns, concept explanations) append a footer like:
_Knowledge last verified 2026-04-13 (Electron v41 stable). For anything newer, check https://releases.electronjs.org._Call electron_knowledge_version to get the metadata directly. When a new Electron major releases, KNOWLEDGE.md documents the update process.
Examples
Add a file picker the safe way
> "Add a file picker that lets the renderer read the selected file's contents"
→ electron_scaffold_ipc_channel({
direction: "renderer-to-main",
channel: "open-file",
returns: "string"
})
# Generates: main handler (dialog.showOpenDialog + fs.readFile),
# preload bridge (contextBridge.exposeInMainWorld),
# TypeScript types for window.api.openFile,
# renderer usage exampleAudit an existing app's security
> "Check my Electron app for security issues — here's my main.ts and preload.ts"
→ electron_audit_security({ mainCode: "...", preloadCode: "..." })
# Returns a graded report against 19 of 20 recommendations
# (session permissions needs runtime context),
# flagging nodeIntegration, missing contextIsolation,
# unsandboxed renderers, loose CSP, and more.Diagnose a failing signing step
> "electron-builder is exiting with: errSecInternalComponent — help"
→ electron_diagnose_build_error({ output: "..." })
# Identifies macOS Keychain Access issue with code signing,
# returns specific `security` CLI fix and CI reconfiguration.Plan an Electron major bump
> "We're on Electron 32. What breaks if we jump to 41?"
→ electron_migrate_version({ from: 32, to: 41, sourceCode: "..." })
# Returns breaking changes across each major (33, 34, 35, ...),
# deprecated APIs found in your code,
# platform support changes,
# recommended test plan.Generate a real CSP
> "Generate a CSP for my Vite + React renderer that actually works"
→ electron_configure_csp({
bundler: "vite",
framework: "react",
allowedOrigins: ["https://api.mycompany.com"]
})
# Returns a CSP that accounts for Vite's dev-mode WebSocket,
# React's inline runtime, and blocks everything else.Troubleshooting
"Tool output is cut off / too long"
A few scaffolders produce >10KB of generated code. Ask the assistant to regenerate with a narrower scope (single channel vs multi-channel bridge; one framework scaffold vs comparison).
"The advice is wrong for my Electron version"
Check
electron_knowledge_version. If Electron has shipped a new major since the verified date, cross-check with the official breaking-changes page linked there.File an issue on the repo with the specific tool + version + expected vs actual. Knowledge updates ship in minor versions.
"Windows: MCP server doesn't start"
Use the
cmd /c npx ...pattern from the Quick start section. Node 20+ can't spawn.cmdfiles directly.
Requirements
Node.js 20.11+
No runtime dependencies
Contributing
git clone https://github.com/YawLabs/electron-mcp.git
cd electron-mcp
npm install
npm run lint # Biome check
npm run lint:fix # Auto-fix
npm run build # tsc + esbuild bundle
npm test # node --testSee CONTRIBUTING.md for the full workflow, including release process.
License
MIT
Available Tools
18 toolselectron_audit_ipc_securityBRead-onlyIdempotent
Analyze preload script and main process IPC code for security issues. Checks for: raw ipcRenderer exposure, missing sender validation, synchronous IPC usage, listener memory leaks, prototype pollution via contextBridge, and insecure channel patterns. Provide the actual code content to analyze.
Inputs: mainCode, preloadCode, rendererCode.
electron_audit_performanceARead-onlyIdempotent
Analyze Electron app code for 7 official performance anti-patterns: eager module loading, synchronous main-process operations, excessive BrowserWindows at startup, unnecessary polyfills, CDN-loaded assets, heavy preload scripts, and unbundled dependencies. Returns specific fixes.
Inputs: mainCode, packageJson, preloadCode, rendererCode.
electron_audit_securityARead-onlyIdempotent
Audit an Electron app against the official security checklist. Covers 19 of the items that can be detected from static inputs (BrowserWindow configuration, main process code, package.json, preload, HTML): HTTPS-only content, nodeIntegration, contextIsolation, sandbox, webSecurity, CSP, allowRunningInsecureContent, experimentalFeatures, enableBlinkFeatures, raw ipcRenderer exposure, direct window assignment, @electron/remote, supported Electron version, shell.openExternal validation, file:// usage, tag, will-navigate handler, setWindowOpenHandler, and IPC sender validation. The remaining checklist items (session permissions, fuse configuration) require runtime / packaging context and are flagged in the report's footer.
Inputs: mainCode, htmlContent, packageJson, preloadCode, +2 more.
electron_check_deprecated_apisARead-onlyIdempotent
Scan code for usage of deprecated or removed Electron APIs. Returns a list of deprecated APIs found with their replacements and the version they were deprecated/removed in.
Inputs: code (required), electronVersion.
electron_configure_auto_updateBRead-onlyIdempotent
Generate complete auto-update configuration using electron-updater. Produces main process setup, update event handling, renderer notification UI code, and platform-specific signing requirements. Supports GitHub releases, S3, and generic HTTP update servers.
Inputs: provider (required), s3Bucket, genericUrl, githubRepo, +3 more.
electron_configure_cspARead-onlyIdempotent
Generate a Content Security Policy for an Electron app. Accounts for the bundler (Vite, webpack), framework (React, Vue, Svelte), and whether dev-mode exceptions are needed. Returns both meta-tag and session.webRequest approaches.
Inputs: bundler, needsEval, externalImages, needsInlineStyles, +1 more.
electron_configure_deep_linkingARead-onlyIdempotent
Generate complete custom protocol / deep linking setup for Electron. Produces protocol registration, URL handling in both single-instance and multi-instance modes, platform-specific configuration (macOS Info.plist, Windows registry, Linux .desktop), and electron-builder/forge config.
Inputs: protocol (required), routes, singleInstance.
electron_configure_fusesARead-onlyIdempotent
Generate @electron/fuses configuration to harden your Electron app. Fuses are compile-time toggles that disable dangerous Electron features (like ELECTRON_RUN_AS_NODE, NODE_OPTIONS) and cannot be re-enabled by end users. Essential for production apps.
Inputs: level (required), customFuses.
electron_diagnose_build_errorARead-onlyIdempotent
Diagnose Electron build/packaging errors from electron-builder, electron-forge, or electron-packager output. Identifies common failures: code signing errors, native module rebuild issues, ASAR packaging problems, missing platform-specific configuration, and __dirname path resolution bugs.
Inputs: errorOutput (required), platform, buildTool.
electron_explain_conceptARead-onlyIdempotent
Get a clear, authoritative explanation of an Electron concept. Counters outdated tutorial content with accurate, version-aware information. Covers: process model, context isolation, sandbox, IPC, ASAR, fuses, code signing, and build tool comparison.
Inputs: concept (required).
electron_explain_process_modelARead-onlyIdempotent
Get a clear, version-aware explanation of Electron's multi-process architecture. Covers the main process, renderer processes, preload scripts, utility processes, contextBridge, and how they interact. Useful for understanding the mental model before building features.
Inputs: topic (required), electronVersion.
electron_generate_preload_bridgeARead-onlyIdempotent
Generate a complete, secure preload.ts with contextBridge.exposeInMainWorld for multiple API methods. Produces the preload script, TypeScript declarations for window.electronAPI, and security best practices. Use this when you need to expose several main-process APIs to the renderer at once.
Inputs: methods (required), namespace.
electron_generate_window_managerBRead-onlyIdempotent
Generate multi-window management boilerplate for Electron apps. Creates a WindowManager class that handles window lifecycle, inter-window communication, window state persistence, and proper cleanup. Supports common patterns like main + child windows, modal dialogs, and detached panels.
Inputs: windows (required), persistState.
electron_knowledge_versionARead-onlyIdempotent
Return metadata about the embedded Electron knowledge used by this MCP's analysis tools -- the date it was last verified against official Electron docs, the current Electron stable version at that time, and the supported version range for migration/deprecation checks. Call this when you need to know whether the advice from other tools is current.
Inputs: no named parameters.
electron_lint_securityARead-onlyIdempotent
Static analysis of Electron code for dangerous patterns: shell.openExternal with user input, @electron/remote usage, disabled webSecurity, missing navigation restrictions, unrestricted window creation, and other OWASP-style vulnerabilities specific to Electron.
Inputs: code (required), fileType.
electron_migrate_versionARead-onlyIdempotent
Generate a migration checklist for upgrading between Electron versions. Lists all breaking changes, deprecated APIs, and required code modifications between the current and target versions.
Inputs: targetVersion (required), currentVersion (required).
electron_scaffold_ipc_channelARead-onlyIdempotent
Generate complete IPC boilerplate for a new feature: ipcMain handler in the main process, preload bridge function with contextBridge, TypeScript type declarations, and renderer-side usage example. Produces all the files needed for a secure, type-safe IPC channel.
Inputs: direction (required), channelName (required), description (required), args, +2 more.
electron_scaffold_projectBRead-onlyIdempotent
Generate a complete, secure, modern Electron project scaffold. Includes proper process separation, TypeScript configuration, framework integration, build tooling, security defaults, and an example IPC channel. Produces a full project structure ready to develop.
Inputs: name (required), features, buildTool, framework.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 18 tools
Most tools have a clearly distinct action and resource, and the security tools are separated by scope (general checklist, lint patterns, IPC-specific, performance). However, electron_explain_concept overlaps with electron_explain_process_model, and the multiple audit/lint tools could still cause some hesitation.
All tools use a consistent electron_ prefix and snake_case, and nearly all follow a verb_noun pattern (explain, scaffold, generate, audit, configure, lint, diagnose, migrate, check). The main deviation is electron_knowledge_version, which is noun-based rather than verb-based.
18 tools is slightly above the typical 3-15 range, but the broad Electron development domain justifies the surface. Each tool maps to a distinct workflow area such as scaffolding, security, configuration, migration, or diagnosis, so the count is reasonable rather than bloated.
The tool set covers a wide Electron lifecycle: concepts, scaffolding, IPC/preload generation, security audits, performance auditing, build diagnosis, auto-update, deep linking, migration, and deprecation checks. Minor gaps remain around explicit packaging/code-signing configuration generation and testing support, but agents can work around them.
Maintenance
Related MCP Connectors
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Email inboxes, webhooks, mock APIs, 2FA codes, approvals and 170 tools for AI agents.
13 micro-tools for agents: read pages, verify email, convert, validate, diff, extract. AI-operated.
MCP-first toolbox for agents: KV storage, auth, queue, and utility tools. Free in early access.
Related MCP Servers
- AlicenseNot gradedqualityNot gradedmaintenanceProvides unified development tools including code analysis, debugging, refactoring, documentation, testing, and project automation through multiple LLM providers (KIMI, GLM, OpenRouter). Features agentic audit capabilities with multi-model consensus for finding issues and generating direct fixes.Apache 2.0
- AlicenseAqualityDmaintenanceProvides AI assistants with frontend development tools including component scaffolding, bundle analysis, accessibility checks, and responsive design guidance. Enables automated generation of React components with tests and stories, bundle optimization recommendations, and WCAG compliance fixes.6MIT
- AlicenseNot gradedqualityCmaintenanceProvides 13 MCP tools for codebase analysis, wiki generation, and knowledge mapping, enabling AI assistants to understand project structure and context efficiently.3,835 npm1,427MIT
- AlicenseNot gradedqualityDmaintenanceProvides AI assistants with 28 developer tools across file, git, code analysis, HTTP, and system domains, enabling tasks like file editing, repository management, code analysis, and shell command execution.2MIT