Skip to main content
Glama

extension.dev MCP Version Downloads Discord

Build, run, debug, test and ship Chrome, Firefox, Edge and Safari extensions from your AI agent.

extension.dev MCP is the MCP server for building browser extensions in Claude Code, Cursor, VS Code, Codex and any MCP client. Your agent creates an extension, runs it, proves it works and ships it to four stores.

Documentation · Tools · Skill · Changelog · Troubleshooting · Discord

Install

claude mcp add extension-dev -- npx @extension.dev/mcp --features=local,platform

Or install the extension-dev plugin, the MCP server pinned to one published version plus the browser-extension skill, in one step:

/plugin marketplace add extensiondev/skill
/plugin install extension-dev@extensiondev

Install in Cursor Install in VS Code

Other clients take the same server as .mcp.json; every client's block, with a local-only form, is on Install in your client.

{
  "mcpServers": {
    "extension-dev": {
      "command": "npx",
      "args": [
        "@extension.dev/mcp",
        "--features=local,platform"
      ]
    }
  }
}

The local tools need no account; the platform tools, on with --features=local,platform, ask for a login the first time they reach extension.dev. Add extras (--features=local,platform,extras) to list extension_theme_verify and extension_network.

Related MCP server: @nimbus21.ai/chrome-devtools-mcp

Your first prompt

Build it and prove it works

Create a Chrome and Firefox extension that highlights external links, run it, and prove the content script injected.

The agent scaffolds from a template, starts the dev session, a browser opens with the extension loaded, and extension_assert answers with a verdict instead of a guess.

Then ship it

Submit this build to the Chrome Web Store and Firefox Add-ons as a dry run and tell me what is missing.

extension_submit defaults to a dry run, so nothing goes into review until a workspace owner approves the real submit.

Ship to four stores

extension_submit sends a built extension into review at the four stores through extension.dev, which holds your store credentials. It defaults to a dry run, and a real submit waits for a workspace owner to approve that exact act on extension.dev: the server never submits or publishes on its own. Reaching the App Store needs no Mac: the Safari lane signs with keys the platform holds encrypted at rest, under the same approval.

The platform tools need a login once. You approve a code at extension.dev/device; the project-scoped token stays on this machine, is never returned to the agent, and lives at most 7 days. No project yet? Request access at extension.dev.

npx @extension.dev/mcp login --project <workspace>/<project>

Details under Platform tools.

Watch it work

Asked to run the extension, the agent starts the dev session and Chrome opens with it loaded, from a real Claude Code session

What it does

Extensions fail silently, with content scripts that never inject and panels that never open, so these tools give the agent eyes on the live browser.

  • Ship: validate the manifest cross-browser, build, share a preview, promote, submit

  • Scaffold from 50+ templates, or add a popup, sidebar or content script

  • Run the dev server with HMR in every browser below

  • See the live DOM, logs from every context, chrome.storage, the loaded extensions

  • Act: evaluate code in any context, trigger the action button and commands, reload

  • Test: extension_assert answers pass, fail or inconclusive, the last naming the evidence that would settle it

Every engine command runs the project's own engine when it has one, else the version this server pins (Engine pinning).

Supported AI agents

Works in

How it connects

Claude Code

claude mcp add or the extension-dev plugin, Install

Cursor

One-click link, Install

VS Code

One-click link for Copilot agent mode, Install

Codex

codex mcp add or ~/.codex/config.toml, Install in your client

Any other MCP client takes the same .mcp.json block.

Supported frameworks

Build a browser extension with

Ask your agent

React (11 templates)

"Create a React side panel extension and run it in Chrome"

Preact (6 templates)

"Build a Preact new tab page with a router and test it in Firefox"

Vue (6 templates)

"Make a Vue popup that saves notes to chrome.storage"

Svelte (6 templates)

"Scaffold a Svelte content script that highlights links"

TypeScript (11 templates)

"Start a TypeScript DevTools panel that stores data in SQLite"

JavaScript (26 templates)

"Add a popup to my plain JavaScript extension and ship it to Edge"

Every template builds for Chrome, Edge and Firefox, and the same project ships to Safari through the App Store lane.

Requirements

  • Node 22.12 or later.

  • A Chromium or Firefox browser, or extension_browsers installs one.

  • macOS with Xcode only for a local Safari session; the App Store lane needs no Mac.

  • An extension.dev login only for the platform tools.

Browsers

extension_dev opens the extension in the browser you name. The Chromium family and Firefox get HMR, control, eval, inspect and assert, and so does any Chromium or Gecko binary by path. On macOS with Xcode, browser: "safari" builds the app, opens it, reloads it on every save and streams its logs; no eval, no extension_inspect, limits under Safari.

Security

  • Local by default. Every local tool runs on your machine. The control channel (extension_storage, extension_reload, extension_open, extension_dom_snapshot) is same machine, same user, on unless extension_dev is called with allowControl: false.

  • The eval gate. extension_eval stays off until extension_dev is called with allowEval: true. A session never grows a gate on a second call: call extension_dev again with replace: true (Session gates).

    extension_element clicks, fills, reads and waits for one element, and sends trusted mouse and keyboard input (move, press, release, type, key, scroll) that pages read as isTrusted: true, over the debug port with no gate, since it runs no caller code.

  • What leaves the machine. Nothing until you ask. A platform tool is answered by extension.dev's hosted lane at mcp.extension.dev, which gets a credential that lasts ten minutes, never the login. --no-ship refuses every call that puts something in front of other people.

    Nothing until you ask. The local tools send nothing to extension.dev. A platform tool is answered by extension.dev's hosted lane at mcp.extension.dev: this server exchanges the stored login at www.extension.dev for a credential that lasts ten minutes and sends the lane that credential, the tool's arguments and the project ref, never the login, a file path or the api override. A store check or a listing sync also sends what it read from the project (the text of STORE.md, the icon and screenshot sizes and digests, the git HEAD); a listing image is uploaded to www.extension.dev only when the listing write needs it. A shared preview uploads the build it just made, a project created from a folder uploads that folder, a capture sync uploads the capture files, and a login stores a project-scoped token locally. Signing in and out, a create and its device approval, a preview, a build download, a capture sync and a share create run on this machine. --no-ship refuses every call that puts something in front of other people.

  • Approvals stay human. A real submit, a channel promotion and a share revoke answer approval-required; a workspace owner approves the exact act on extension.dev, the call is repeated with the returned approvalId, and the server never approves anything itself. extension_submit_check carries the reads and the asks under readOnlyHint: true; extension_submit carries the act.

  • Untrusted text from pages comes back inside an <untrusted-data-ID> fence, and every tool carries MCP annotations.

Telemetry

extension_create sends one draft_seeded event to us.i.posthog.com after a scaffold (template slug, source and commit, a random per-process id, never a path or a name), and the platform tools send a per-install id header. EXTENSION_DEV_NO_TELEMETRY=1 or DO_NOT_TRACK=1 stops both (payload).

Hosted server

https://mcp.extension.dev/mcp serves the platform reads and promotions over Streamable HTTP: a client connects with the URL alone, signs in at www.extension.dev through OAuth, and gets extension_workspace, extension_project_create, extension_builds (reads), extension_builds_act, extension_release_status, extension_release_promote and extension_auth (status only). Local tools, publish, submit and share links stay on the stdio server.

claude mcp add --transport http extension-dev https://mcp.extension.dev/mcp

Flags

Flag

Environment variable

Default

Effect

--features=<groups>

EXTENSION_DEV_FEATURES

local

local,platform adds the platform group; extras, off unless named, adds the theme check and the network stubs; a group named alone lists only its tools

--no-ship

EXTENSION_DEV_NO_SHIP=1

off

Refuses publish, promote, a real submit, a store act (the listing sync included), a shared preview, a share create or revoke

--project <workspace>/<project>

EXTENSION_DEV_PROJECT

unset

Refuses any call that names another project

none

EXTENSION_DEV_TOKEN

unset

An access token in place of the device login, for CI

none

EXTENSION_DEV_NO_AUTO_OPEN=1

off

Never opens the approval page in the default browser

none

EXTENSION_DEV_NO_TELEMETRY=1 or DO_NOT_TRACK=1

off

Turns off the draft_seeded event and the per-install id header

none

EXTENSION_MCP_CLI_VERSION

this release's pin

The engine version run when the project has none of its own

none

EXTENSION_MCP_ENGINE_DIR or EXTENSION_MCP_ENGINE_BIN

unset

Runs every engine command from a compiled engine checkout or one bin file

login, logout, whoami and release promote run headless; see Server flags.

Tools

The local group scaffolds, builds, runs, inspects, drives and asserts; the platform group logs in, shares, promotes, submits, reads builds, releases and approvals, and runs a published build with extension_try; the extras group, off unless named, verifies a Chrome theme and stubs network responses. Every tool has a page under the tool reference, generated from the schema the server registers, with its inputs, whether it only reads, the gate it needs and a prompt that reaches for it.

Pair with the skill

This server gives agents hands; @extension.dev/skill gives them judgment: cross-browser rules, silent-failure gotchas, debugging playbooks and the store checklist.

npx skills add extensiondev/skill

Questions

How do I publish a Chrome extension from Claude Code or Cursor?

Add the server with the line under Install, then ask the agent to submit the build. extension_submit defaults to a dry run, and a real submit waits for a workspace owner to approve it on extension.dev.

Can an AI agent submit to the App Store without a Mac?

Yes. The Safari lane signs with keys the platform holds encrypted at rest; only a local Safari session needs macOS with Xcode.

Does it need an account?

The local tools need none. The platform tools ask for an extension.dev login the first time they reach extension.dev.

Troubleshooting

Every refusal carries an error code and a hint (error.hint) naming what to change or the next call. The five most common:

  • E_TOOL_DISABLED: the tool's group is off, or the call reaches outside this machine in no-ship mode. Add the group the hint names (platform or extras) to --features, or drop --no-ship, in the client's config, then call again.

  • approval-required: have a workspace owner approve the act at the link, then repeat the call with the same arguments and the returned approvalId.

  • E_AUTH_REQUIRED or E_AUTH_EXPIRED: the login lives at most 7 days. Run extension_auth (action: "login", project: "<workspace>/<project>"), then call again.

  • E_NO_SESSION: nothing is running. Start extension_dev, then extension_wait for ready.

  • extension_eval refused: the session started without the gate. Call extension_dev again with allowEval: true and replace: true; reads need no eval.

extension_doctor names the broken leg of a session. After a new version lands a tool may answer E_SERVER_STALE: run /mcp, pick extension-dev, and call again. More under When it fails.

Community

Help and feedback on Discord; templates at templates.extension.dev; issues at extensiondev/mcp.

License

Apache-2.0 (c) 2026 Cezar Augusto and the extension.dev collaborators. See LICENSE.

Available Tools

32 tools
extension_add_featureA
Read-onlyIdempotent

Plan a new feature surface for an existing extension. This returns step-by-step instructions, the manifest additions to make, and reference templates from the extension.dev catalog. It modifies no files: apply the returned plan yourself.

Inputs: feature (required), projectPath (required), framework.

extension_analyzeA
Read-onlyIdempotent

Analyze a BUILT extension on disk: file sizes, declared entry points, permissions, bundle composition, and store-readiness checks. This is static only: it reads dist/ from the filesystem and never touches a browser, so build first with extension_build. Use extension_inspect for a running extension's live DOM and console.

Inputs: projectPath (required), format, browser.

extension_assertA
Idempotent

Run a test stage against a live dev session: state expectations and read one verdict for each, instead of reading a blob and hand-rolling the judgement. Every expectation comes back pass, fail or inconclusive, where inconclusive means this platform cannot cover the question today and the verdict says what would settle it. An inconclusive check is never a pass. Start the session with extension_dev; use extension_inspect or extension_logs when you want the raw reading instead of a verdict.

Inputs: expect (required), projectPath (required), browser, timeout.

extension_authA
Destructive

Sign this machine in to extension.dev, report that login, or clear it. Pass action:'status' (the default) to name the workspace and project the stored token is scoped to and when it expires, never the token itself; that identity comes from the stored token alone, and does not change with the current working directory or whichever project folder you are in. Status also asks the platform's whoami endpoint whether that credential actually resolves there: the answer rides value.server.verdict as confirmed, refused or unavailable (when the server could not be reached), with status logged-in for the first and last and refused-by-server for the second, so a local file claiming a login the server refused is never reported as logged in. Pass action:'login' for a two-phase flow: call with project to get a code plus a URL the user authorizes at extension.dev/device, then call again with the returned deviceCode. GitHub federation happens server-side, so no GitHub token lands on this machine. Minted tokens live at most 7 days, server-enforced, so CI must re-mint before expiry on the console's project settings, Access tokens page. Pass action:'logout' to delete the local credentials only (with project, just that project's login); the token stays valid server-side until it is revoked at the URL the response returns. Several logins live side by side on one machine, one per workspace/project, and status lists them all under logins. To sign in to several existing projects of one workspace at once, pass projects instead of project: one approval, one stored token per project.

Inputs: api, action, project, projects, +1 more.

extension_browsersA
Destructive

Find, install and remove the browsers Extension.js tooling can launch. Pass action:'detect' (the default) to scan both system-installed and managed browsers, and report each one's binary path, version, engine and debugger support. Pass action:'list' for the managed cache this tool downloads into, with sizes on disk. Pass action:'install' to download a managed binary: several hundred MB in one blocking call, so allow a generous client timeout. Pass action:'uninstall' to remove managed binaries; it never touches a system install.

Inputs: all, action, browser, browsers.

extension_buildA
Idempotent

Build a browser extension for production. The output lands in dist//. Pass zip:true to also package a .zip for store submission. With browser:'safari' the build converts the extension into a macOS app through Xcode, and bundleId sets the identifier it ships under. The build refuses a manifest with build-blocking errors unless you pass skipValidation:true, because such a manifest yields a broken bundle the bundler itself never flags.

Inputs: projectPath (required), zip, mode, silent, +9 more.

extension_createA

Create a browser extension project from a template in the extension.dev catalog. Call extension_templates first to see what is available. The scaffolder may initialize a git repository in the new project (with a first commit), and it also writes store metadata and a .gitignore of its own. Read the result's defaultsApplied block for the decisions this tool can read back: parent directory, template, package manager, target browser and whether a git repository was initialized by this call.

Inputs: projectName (required), install, template, parentDir.

extension_devA

Run the extension while you edit it: dev build, hot module replacement, and a browser with the extension loaded. Reach for this first when the ask is "run my extension". ONLY this tool unlocks the control channel that extension_storage, extension_reload, extension_open and extension_dom_snapshot need (allowControl:true) and the eval channel that extension_eval needs (allowEval:true, which implies allowControl, so you never need to pass both). Use extension_start instead to run the production build in a browser. The result carries the process info that extension_wait and extension_inspect need.

Inputs: projectPath (required), host, port, browser, +12 more.

extension_doctorA
Read-onlyIdempotent

Diagnose a dev session end to end: ready contract, dev-server process, control-port agreement, control channel, eval token, executor, browser liveness. This returns one {check, status, detail, remediation?} per leg, in dependency order. Read a 'skip' as blocked, not as a pass: it names the check that blocked it. A session started without allowControl comes back ok:true with status 'read-only', not as an error: its control channel is off by choice. Run this first when any act tool (storage, reload, eval, open) errors unexpectedly. Call it with no projectPath for a pre-flight environment check (node, the Extension.js CLI, the template cache) before any project exists.

Inputs: browser, projectPath.

extension_dom_snapshotA
Read-onlyIdempotent

Take a shallow structured DOM snapshot of one chosen surface through the agent bridge (localhost only; the snapshot itself needs no CDP, but listTargets and tabUrl resolution ask the browser directly and need the session's debug port: CDP page targets on Chromium, RDP tab descriptors on Firefox): element counts, extension roots, open shadow roots, optional byte-capped HTML, and optional recent console lines. This is the SURFACE PICKER: the only tool that reads an open extension surface by name (context: popup, options, sidebar, devtools) or an override page, the only one that takes a numeric chrome.tabs id, and the only one that enumerates what is open (listTargets for CDP targetIds and RDP tab actors, listTabs for numeric tab ids). An ambiguous tabUrl returns the candidates instead of guessing. It does not pierce closed shadow roots, run selector probes, or navigate: use extension_inspect for those, and for a deep read of an already-open web page. Start the session with allowControl:true (extension_dev).

Inputs: projectPath (required), tab, url, tabUrl, +8 more.

extension_evalA
Destructive

Evaluate an expression in a running extension context. Start the session with allowEval:true (extension_dev), which writes a 0600 session token; without that token every route of this tool, the debug port included, answers eval-disabled. Context defaults to 'background', except on a Chromium MV3 session (the default template) where it defaults to 'page', the active tab; pass context:'background' to evaluate in the service worker, which on Chromium goes over the debug port. Debug-port evaluates run with a user gesture, so gesture-gated APIs (permissions.request, sidePanel.open) can succeed here and still fail when the extension's own code calls them. For content and page, pass url to pick the tab, or omit both url and tab for the active tab; a numeric tab only disambiguates. Extension surfaces (popup, options, sidebar, devtools) and override pages (newtab, history, bookmarks) need no tab id but must already be open: open one with extension_open first, because a closed one returns an explicit error. On a Chromium MV3 session those pages, and context:'page' with a chrome-extension:// url, evaluate over CDP, the inspector path the extension page CSP does not govern; elsewhere they evaluate over the in-bundle relay. On Firefox a document whose content security policy forbids eval (the extension's own pages, or a site's) is evaluated over the debugger protocol instead, which takes one expression; a page inside the extension that is no declared surface (pages/*) is reached the same way by context:'page' and its moz-extension:// url once a tab shows it. Call extension_dom_snapshot with listTabs:true to enumerate {tabId, url, title}.

Inputs: expression (required), projectPath (required), tab, url, +3 more.

extension_inspectA
Idempotent

Inspect a running extension deeply over the browser's debugger protocol: full HTML (open shadow roots of #extension-root and [data-extension-root] hosts inlined; other shadow roots are not crossed by html, dom_snapshot or probe), DOM structure, content-script injection, console messages, and CSS selector queries through probe. This is the ONLY tool that pierces closed shadow roots (deepDom), runs selector probes, and navigates a tab to url before reading it. It reads a web or override page and picks the first inspectable target, or the first whose url contains url; it cannot address an extension surface by name and takes no chrome.tabs id. Use extension_dom_snapshot to choose which tab or which open surface (popup, options, sidebar, devtools) to read, or to enumerate what is open. Use extension_analyze for a built extension's files and sizes on disk. Chromium rides the Chrome DevTools Protocol and needs the session's debug port, not allowControl. Firefox is fully paired: summary, meta, html, dom_snapshot, extension_roots and probes ride the agent bridge and need allowEval:true, console rides the RDP watcher replay on engine 4.0.15 and later, and deepDom needs an MV2 session with host permissions for the target url, because the Firefox MV3 background CSP blocks bridge evals. This requires an active dev or start session.

Inputs: projectPath (required), url, probe, browser, +3 more.

extension_list_extensionsA
Read-onlyIdempotent

List the extensions in the running dev browser: id, name, version, and, on Chromium, live contexts. This session's own extension carries ownExtension:true, with name and version from the ready contract even when the browser exposes no identity. Chromium rides the Chrome DevTools Protocol, so an entry needs at least one live context, and a dormant MV3 service worker may be absent until it wakes. Firefox rides the RDP root actor (listAddons, engine 4.0.15 and later), so entries are installed add-ons regardless of contexts, are marked temporarilyInstalled where relevant, and carry no contexts. Other extensions' contexts are never attached to or evaluated in. This requires an active dev or start session.

Inputs: projectPath (required), browser.

extension_logsA
Read-onlyIdempotent

Read or stream logs from every context of a running dev session (service worker, content scripts, popup, options, sidebar, devtools, pages) in one ordered timeline. This reads the same agent-bridge plane as the extension logs CLI: a one-shot returns the most recent matching lines from logs.ndjson, and follow:true connects to the live control channel, receives the broker's replay of its recent ring (up to 5,000 events, counted in value.replayed) and then the frames that arrive during followMs (value.live). This requires an active extension_dev session.

Inputs: projectPath (required), tab, url, level, +7 more.

extension_manifest_validateA
Read-onlyIdempotent

Validate a manifest.json across browsers. This reports missing fields, invalid permissions, dangling file references, and cross-browser compatibility issues. Read buildBlocking for the errors that make extension_build refuse.

Inputs: browser, browsers, projectPath, manifestPath.

extension_openA

Open an extension surface, or replay an event, in a running session. Pass surface:'popup', 'options' or 'sidebar' to open a UI surface, or 'newtab', 'history' or 'bookmarks' to open the matching chrome_url_overrides page in a tab (always a tab, resolved by the server, never sent to the engine). On Chromium, when Chrome refuses the sidebar for lack of a user gesture, the server opens the real panel through a synthetic click on the extension's own page and says so in warnings; if that fails too it renders the sidebar document as a tab. Pass surface:'devtools' to open the browser's DevTools on a tab (the one url matches, else the first web page) and show the extension's panel there, picked by panel title when there are several: Chromium only, over CDP Target.openDevTools, headed or headless; the result names the panel document's url, which extension_eval reads with context 'page' and that url (the panel is no tab, so the tab-based readers do not reach it). Pass surface:'action' to trigger the toolbar action, which opens its popup or replays chrome.action.onClicked when there is none. Pass surface:'command' with name to replay a chrome.commands.onCommand shortcut. Note that action and command replay invoke your listener without a user gesture, so the gesture-derived activeTab grant does not apply; the engine's own frame is returned as is. Start the session with allowControl:true (extension_dev).

Inputs: projectPath (required), tab, url, name, +7 more.

extension_preview_webA

Preview an in-progress extension in the web emulator, with no real browser. This builds the project (unless build:false) and previews dist/. Pass share:true unless you are working inside the extension.dev monorepo: it uploads the build and returns a link anyone can open, with no install, sign-in or dev server, and it is the only lane that works from an npm install of this server. Sharing also serves the build as a zip, so it hands over the built code; read the share property before using it. The default lane instead returns a deep link over the dev-only preview://build scheme, which resolves only against a preview.extension.dev dev server on this machine, so it is for people developing extension.dev itself. Call extension_shares to list and revoke every link shared this way, so one never vanishes with this response.

Inputs: projectPath (required), open, build, probe, +6 more.

extension_project_createA

Create an extension.dev project for an extension that does not have one yet, without opening the console. Use it right after extension_create and extension_build, once the extension's source is pushed to a GitHub repository, and BEFORE extension_auth: extension_auth can only log in to a project that already exists, and this tool is what brings that project into existence. Ask for nothing but the project slug and the repo; the platform finds the GitHub App installation on the approving account itself, and if there is none it returns a connect link to open. Two-phase, like login: the first call returns a code and a URL where a signed-in member of the workspace approves creating exactly this project; call again with the returned deviceCode to finish. The approval mints a provisioning grant that lives minutes, can only create the one named project, and is never stored on this machine. On success the platform creates the project and its mirror repository, and dispatches the first build when it can: the answer says in firstBuild whether one was dispatched and, when none was, why (no commits, no build workflow, a spent build allowance, a paused dispatch). Then run extension_auth (action: login) against the new project, and extension_publish to share it. To create several projects in one workspace under one approval, pass projects instead of project and repo: the approval page lists every name, each project is created by its own request, and each one's 7-day token is stored as that project's login, so no extension_auth call is needed afterwards. A list takes a few calls to finish: while projects remain the answer is status 'creating' with the same deviceCode to call again, and the grant is held in this server's memory only. One approval creates at most 10 projects, the cap the platform states in its login config, because it creates at most 10 per hour for one approving account; the next 10 can start in a new call once that limit allows. A longer list is refused before any approval is asked for, never split silently, and so is any list on a platform that does not advertise batch onboarding.

Inputs: api, repo, project, browsers, +9 more.

extension_publishA

Publish the project your stored token is scoped to (extension_auth, or EXTENSION_DEV_TOKEN) to extension.dev, and return its shareable URL. This is what "deploy" or "ship" an extension usually means; extension_submit is the separate store-review path. The target is the token's project: there is no projectPath, and no local file is uploaded. With several logins stored, pass project ('/') to pick which one; it outranks EXTENSION_DEV_TOKEN. For a public project the URL is the canonical public page and ttlHours does not apply. For a private one it is a fresh time-limited share link (?share=) whose lifetime is ttlHours.

Inputs: api, project, buildSha, ttlHours.

extension_release_promoteA
Destructive

Promote a built extension to a release channel (stable, preview, beta, …) on extension.dev, headless. This WRITES: it is the only verb that changes what a channel points at. It is auth-gated by your stored login (extension_auth) or a release token in EXTENSION_DEV_TOKEN, minted and revoked under project settings, Access tokens. Tokens live at most 7 days, so CI must re-mint before expiry. The project comes from the token; with several logins stored, project picks which one. Call extension_release_status to find a valid buildId. The status is 'promoted' only when the platform says every asked browser's release was dispatched and the channel pointer moved; 'promoted-partially' lists in its warnings what did not happen (a browser whose dispatch failed, a channel pointer that was not moved) and must not be repeated whole; 'promote-unconfirmed' means the platform's answer did not carry the result, so read extension_release_status before promoting again. Cutting a version-bump PR is not available headlessly, because it writes to your source repo and needs an interactive login.

Inputs: buildId (required), channel (required), api, project, +5 more.

extension_release_statusA
Read-onlyIdempotent

Read where a project stands on extension.dev, from the public registry (registry.extension.land). This is read-only: it dispatches nothing and promotes nothing. Pass include:'releases' for the release channels (channel to promoted build sha), recent builds, and a public build-page URL for each, which is how you find a valid sha for extension_release_promote, extension_submit or extension_publish. Pass include:'stores' for the per-store picture after an extension_submit (chrome, firefox, edge, safari): configured or not, the last credential health check, the last recorded submission, and the latest review status, read from stores/health.json, stores/status.json and stores/submissions.json. Both are included by default. This defaults to the logged-in project (extension_auth); pass workspace and project to read another. Private projects work when your stored login covers them. Registry state can lag the store dashboards by up to a polling interval.

Inputs: api, include, project, workspace.

extension_reloadA
Idempotent

Reload a running extension's background context, or a tab. Start the session with allowControl:true (extension_dev).

Inputs: projectPath (required), tab, browser, context, +1 more.

extension_sharesA
Destructive

List and revoke the public preview links this token has shared, which is what extension_preview_web share:true hands out. Pass action:'list' (the default) for every artifact the logged-in project owns, with its artifactId, name, version, live or dead state, createdAt, expiresAt, revokedAt, size, previewUrl, zipUrl and revokeUrl, so a link whose response you lost is findable again. Each row carries owner and sharedBy as the platform returned them. Read attribution.ownership for who may revoke a share: 'project' means the workspace holds it and any member can pull it back, 'personal' means one person holds it alone, 'unknown' means no owner was disclosed. Read attribution.credit as credit only, never access; it names the publisher, and reads 'CLI token ' or 'not recorded' when no person can be named. Pass action:'revoke' with an artifactId, or with any URL of the share, to kill one permanently. Pass projectPath to reconcile against the project's own append-only .extension.dev/shared-previews.json, which is read and never rewritten: a share made on another machine shows as remoteOnly, a record with no live artifact as localOnly. That record is append-only, so localOnly is counted by distinct artifactId and a build re-shared unchanged is one share, not two; server.count and server.matched are share counts, while server.scanned counts records the platform read and is never a share count. This needs the same token as sharing (extension_auth or EXTENSION_DEV_TOKEN); without one, listing still returns the local record with a login hint.

Inputs: api, url, limit, action, +5 more.

extension_startA

Run the PRODUCTION build in a browser: build the project, serve it, and launch. There is no hot module replacement and no control channel, so your edits are not picked up and extension_eval, extension_storage, extension_reload, extension_open and extension_dom_snapshot cannot attach to this session. Use extension_dev while writing code, and this to check what actually ships. Pass build:false to launch an existing dist/ without rebuilding, or outputPath to launch any prebuilt unpacked extension directory, one another toolchain produced included, which implies build:false.

Inputs: projectPath (required), host, port, build, +10 more.

extension_stopA
DestructiveIdempotent

Stop a session that extension_dev or extension_start is running: terminate the server and the browser it launched, and remove the live-preview carrier if extension_dev placed one. This covers extension_start build:false too, which the registry records as a preview session. Call it when you are done verifying, so sessions do not accumulate.

Inputs: all, browser, projectPath, includeOtherServers.

extension_storageA
Destructive

Read or write chrome.storage in a running extension. Every call runs in the extension's background (the engine honours no context), so it proves nothing about what a content script or page can read. A set is read back and the answer says whether the stored value matches. Start the session with allowControl:true (extension_dev). Set one key per call: there is no bulk-object set.

Inputs: action (required), projectPath (required), key, area, +3 more.

extension_submitA
Destructive

Submit a built extension for store REVIEW through extension.dev, which holds your store credentials and dispatches from your project's mirror CI: the Chrome Web Store, Firefox AMO, Edge Add-ons and the App Store (Safari). This is store review only. It does not push a build to the extension.dev platform, and it does not make a shareable link: that is extension_publish, which is what "deploy" or "ship" an extension almost always means. Reach for this only when the ask is explicitly a store submission. It defaults to a dry run that dispatches nothing: the platform verifies the token and project, finds the store workflow, reads the build from its index when that index is readable, reads store health itself and adds a Safari plan verdict; this tool re-reads the per-store health rows beside it. The dry run does not run the owner gate, the approval, the build quota, the dispatch pause or the submission-mode check, which the real run does first. Pass dryRun:false to actually submit, which is irreversible: only the workspace owner who issued the token may, and it dispatches the store workflow; a Chrome or Edge store with no saved submission mode is uploaded as a draft (absent_mode: safe) and does not enter review. A real submission answers 'submitted' only when the platform recorded a submission for every store asked; 'submitted-partially' names the stores it did not record, which are the only ones to submit again; 'submit-unconfirmed' means no usable answer came back, so read extension_release_status before submitting again, because a second call submits a second time. The project comes from your token (extension_auth or EXTENSION_DEV_TOKEN; tokens live at most 7 days, so CI must re-mint from the console's Access tokens page); with several logins stored, project picks which one. Store credentials are never arguments, and no local file is uploaded. Call extension_release_status for valid shas, and, after a real submission, for the recorded outcome and review state.

Inputs: browsers (required), buildSha (required), api, dryRun, +5 more.

extension_templatesA
Read-onlyIdempotent

Browse the extension.dev template catalog. Pass action:'list' (the default) to search and filter it and get metadata per template. Pass action:'source' with a slug to read one template's files, for learning a pattern before building something similar. Read framework as the UI framework only, never the language: TypeScript and JavaScript templates live under slugs ('typescript', 'content-typescript'), shadcn is a React variant ('sidebar-shadcn'), and provider AIs carry the 'ai' tag ('ai-chatgpt', 'ai-claude'). Reach those through query, tags or slug.

Inputs: slug, tags, files, query, +4 more.

extension_theme_verifyA
Read-onlyIdempotent

Verify a Chrome theme manifest before it ships. This settles the four-leg WYSIWYG contract (app-shows == manifest-says == chrome-paints, plus chrome-accepts) as far as is possible headless: it derives every color current Chrome would paint from the manifest through the transcribed Chromium resolver, and classifies each problem as D1 fabrication, D3 parity gap, or D4 acceptance gap (keys Chrome silently discards: dead legacy, incognito, unknown, out-of-range). It verifies only, and never authors or mutates a theme. The app-rendered and real-pixel legs need a browser, so they come back as needsAttended pointing at the assert:theme and install-parity harnesses, never as passed.

Inputs: manifest, manifestPath.

extension_waitA
Read-onlyIdempotent

Wait for a running dev or start session to be ready. This polls the ready.json contract and reports compiled (the compiler finished), browserAttached (the runtime executor connected), and guestLoaded (the browser's own target list shows your extension). Read guestLoaded as the trustworthy load signal: it catches a silently rejected --load-extension that leaves ready.json stamped attached with empty logs. It is null when it could not be checked, for example a gecko session with no CDP port. Every result reports budgetMs and elapsedMs; on status 'timeout', call again to keep waiting on the same contract. In a noBrowser session this returns as soon as the compile lands, instead of waiting for a browser that will never attach. Ports come from the contract, so they match what the server actually bound.

Inputs: projectPath (required), browser, timeout, timeoutMs.

extension_workspace_createA

Create an extension.dev workspace that does not exist yet, without opening the console. Use it before extension_project_create when the project's workspace is not there: project creation can only target an existing workspace, and this tool is what brings one into existence. Two-phase, like login: the first call returns a code and a URL where a signed-in GitHub user approves creating exactly this workspace and becomes its owner; call again with the returned deviceCode to finish. Check ownerGithubLogin in the answer: whoever approved the code owns the workspace. The approval mints a grant that lives minutes, can only create the one named workspace, names no project, and is never stored on this machine. Then run extension_project_create against '/'.

Inputs: workspace (required), api, deviceCode, description, +2 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 32 tools

    Disambiguation4/5

    There is heavy surface overlap between extension_build/extension_dev/extension_start/extension_preview_web and between extension_inspect/extension_dom_snapshot/extension_eval, but the descriptions explicitly delineate each (e.g. 'ONLY this tool pierces closed shadow roots', 'use extension_dom_snapshot to choose which tab'). An agent can generally pick correctly, though the sheer density of cross-references makes misselection plausible.

    Naming Consistency5/5

    Every tool uses the extension_ prefix with snake_case, and most follow a predictable verb or verb_noun shape (extension_build, extension_create, extension_release_promote, extension_manifest_validate). A few noun-only names (extension_templates, extension_browsers, extension_shares) are exceptions but consistent within their purpose.

    Tool Count3/5

    At 32 tools the set is heavy, exceeding the 25-tool 'too many' threshold, though the domain (full extension lifecycle: scaffold, build, dev, inspect, publish, store submit, auth, releases) is genuinely broad so most tools earn their place. It still leans toward being a lot of surface for an agent to navigate.

    Completeness5/5

    The surface covers the whole lifecycle: templating, scaffolding, build, dev/start/preview sessions, inspection, eval, storage, reload, stop, auth, workspace/project creation, publish, release promotion/status, store submission, manifest validation, diagnoses, and docs. No obvious dead ends or missing lifecycle operations.

    Maintenance

    ActivityActive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables AI agents to control the Google Chrome browser through a Node.js WebSocket bridge and a dedicated browser extension. It provides tools for capturing screenshots, executing JavaScript, managing tabs, and extracting page content via the MCP protocol.
      2
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to control and interact with a Chrome browser via MCP, providing tools for navigation, screenshots, clicking, form filling, content extraction, and tab management.
      1
      -
    • F
      license
      Not graded
      quality
      B
      maintenance
      Exposes your Chrome/Edge browser as MCP tools for AI agents, enabling browser automation through a Chrome extension with 47 tools for navigation, interaction, page reading, and more.
      17 npm
      -