Log inSubmit server
Core logo

Core

Drives, inspects, and validates real Electron desktop apps through MCP tools for agents.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install Core

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "core": {
      "command": "npx",
      "args": [
        "-y",
        "--package",
        "@electron-stagewright/core@0.5.0",
        "--package",
        "playwright@1.61.1",
        "--package",
        "electron@42.3.0",
        "electron-stagewright"
      ]
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Automated check passed— started and listed 55 tools correctly (2d ago).

Overview

The core MCP server drives real Electron desktop applications through launch, attach, and inject workflows. It exposes accessibility-tree snapshots, semantic element queries, ref-based interactions, state waits, assertions, screenshots, diagnostics, and session traces. Reach for it when browser automation does not cover Electron windows, native dialogs, packaged apps, or signed release validation.

Use cases

  • Test Electron interfaces through accessibility roles and stable references
  • Attach to running development applications without restarting them
  • Assert UI state with retries and composite wait predicates
  • Capture screenshots, console output, dialogs, and session traces
  • Validate packaged and signed macOS Electron applications

Key features

  • Launch, attach, and inject into Electron apps
  • Accessibility-tree snapshots with state and diff support
  • Semantic element finding and ref-based interaction
  • Retrying expectations and composite state waits
  • Diagnostics and replayable session traces
  • Packaged app and release-artifact validation

Tools55

What Core lets your agent do. Expand a tool for its parameters.

Verified live~18.5k tokens of context

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 3d ago

Recent health check succeeded.

7/7 checks healthy over the last 41d

What it can do

From the 55 tools this server returned when we ran it; 55 declare their own safety hints.

Runs commands · 3Can delete or modify data · 5Handles credentials · 2Makes network requests · 2Read-only tools · 47
Network at startup4 connections
Files written at startupNone
Install scriptsNone
npm provenanceNot published
Package age5268 days
Maintainers2

Observed 2026-10-21 in an isolated sandbox. A description of reach, not a security audit.

Supply-chain signal

29 high-severity advisories on record for this package. Most advisories affect transitive dependencies and may not be exploitable in this server's actual usage — this is a directional signal, not a security audit.

Critical 3High 26Medium 32Low 10

Scanned 15d ago via OSV.dev · electron@42.3.0 (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars12Stargazers on the source repository.
npm downloads32MPackage downloads in the last 30 days.
Last commit6d agoMost recent push to the default branch.
Availability100%Our rolling endpoint + install checks that succeeded.
Install checkPassedOur sandbox started it and listed its tools.
Tools exposed55Callable tools this server registers over MCP.
Directory activity3 viewsConfig copies, upvotes, and views on AllMCPs.

How Core works

What the core MCP server does

The core MCP server gives MCP-compatible agents a way to operate real Electron applications rather than only browser pages. It can start an application, connect to an existing development process, or inject into a running main process through the Node Inspector handshake. This makes it suitable for testing renderer interfaces alongside Electron-specific behavior such as multiple windows, native menus, dialogs, packaged runtimes, and release artifacts.

UI inspection is based on accessibility roles and ARIA information. Agents can work with stable element references instead of CSS selectors or XPath, and can query for elements by role, partial name, and visibility. Snapshot results can include visibility, enabled state, focus, checked state, expansion, busy state, and validation state. Snapshots can also report changed elements and renderer reloads that may invalidate earlier references.

How it works

The server communicates with an MCP host over its default local launch transport. The documented setup uses the published core package together with pinned Playwright and Electron packages. An agent starts or connects to an application, reads a snapshot, interacts with returned references, waits for state changes, and asserts expected results before stopping the session.

Composite state predicates are evaluated by the server in one wait operation. Expectation tools combine checking and retry behavior, reducing the need for repeated read-and-compare calls. Snapshot output can be requested as compact text when a one-line-per-element representation is more useful than the full JSON state. Session traces record tool calls, arguments, results, timings, and token estimates, and can be replayed against a fresh app instance with per-tool budgets.

Setup and configuration

For a published installation, prime the package cache before starting an MCP stdio session. The documented command pins @electron-stagewright/core 0.5.0, Playwright 1.61.1, and Electron 42.3.0, then runs electron-stagewright doctor --json. This avoids first-run Electron download output interfering with the MCP session.

Claude Code can be configured with an npx command using those same packages. A local development setup instead runs pnpm install, pnpm build, and points the host at packages/core/dist/cli.js. The server can launch an app with a main-process path and environment values, or connect to an application that exposes the required loopback debugging endpoint. A separate demo package is available for verifying a host configuration without supplying an application path.

Tools and capabilities

The core MCP server includes capabilities for:

  • Launching, attaching to, injecting into, and stopping Electron sessions.
  • Inspecting accessibility snapshots, snapshot deltas, compact text output, and renderer reload status.
  • Finding elements semantically by role, name text, and visibility.
  • Clicking and otherwise interacting with elements through stable references.
  • Waiting for composite conditions such as visible, enabled, or focused.
  • Asserting text and other UI expectations with retrying operations.
  • Capturing screenshots, console output, dialogs, and session traces.
  • Inspecting plugins, their enabled tools, and safe configuration.
  • Supporting validation workflows for signed and notarized .app bundles, including code signing, Gatekeeper assessment, updater feeds, URL schemes, and crash reporting machinery.

The documented fixtures cover vanilla, React, Vue, and Angular renderers, while the broader renderer matrix is still expanding. The server also returns token-cost information with responses, which helps an agent account for inspection overhead.

Limitations and notes

The server is designed for Electron applications and does not replace a general browser automation service. The default workflow depends on Playwright and an Electron runtime, and the release-tested package versions should be pinned for the documented setup. Attaching requires an exposed loopback CDP endpoint; injection is intended for cases where a debug flag was not configured in advance.

References are tied to the inspected UI state. After a renderer reload, agents should refresh their snapshot before using older references. The accessibility-based approach avoids framework internals, but coverage beyond the currently documented fixture frameworks is still developing. The full tool inventory and parameters are maintained in the repository's generated tool reference.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Core

core is an MCP server that connects AI agents to real Electron desktop applications through launch, attach, and inject workflows. Its main tools inspect accessibility trees, find and interact with UI elements, wait for or assert state, capture diagnostics, and manage session traces.

Install it with the documented npx command using pinned versions of @electron-stagewright/core, Playwright, and Electron. Run the same command with `doctor --json` first to prime the cache, then register the package command with your MCP host.

Yes, core works with Cursor because the project documents Cursor as an MCP-compatible agent. Configure Cursor with the server's stdio command, using the published package and its pinned Playwright and Electron dependencies.

Yes, it can attach to a running development app through a loopback CDP endpoint. When no debug flag was configured in advance, `electron_inject` can connect to a running main process through the Node Inspector handshake.

It tests UI state through accessibility snapshots, semantic queries, stable element references, composite waits, and retrying expectation tools. Agents can inspect visibility, enabled state, focus, and other reported properties without relying on CSS selectors or XPath.

Related MCP servers

All in OS Automation All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewCore AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/core?style=directory)](https://allmcps.com/mcp/core)
HTML Embed
<a href="https://allmcps.com/mcp/core"><img src="https://allmcps.com/api/badge/core?style=directory" alt="Core on AllMCPs" /></a>