@extension.dev/mcp 10.10.3 → 10.10.5

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "extension-mcp",
       "source": "./",
       "description": "MCP tools for browser extension development: scaffold from 50+ templates, run the dev server with HMR, inspect the live DOM and logs, and publish store-ready builds for Chrome, Edge, and Firefox.",
-      "version": "10.10.3",
+      "version": "10.10.5",
       "category": "development",
       "author": {
         "name": "Cezar Augusto"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "extension-mcp",
   "description": "MCP tools for browser extension development: scaffold from 50+ templates, run the dev server with HMR, inspect the live DOM and logs, and publish store-ready builds for Chrome, Edge, and Firefox. Ships /extension, /extension-add, /extension-debug, and /extension-publish commands.",
-  "version": "10.10.3",
+  "version": "10.10.5",
   "author": {
     "name": "Cezar Augusto",
     "email": "hello@extension.dev",

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 10.10.5
+
+- `extension_build` and `extension_analyze` report store review risks
+  read off the built package, as `value.reviewRisks` plus one warning
+  each with the fix: access to every website, code the package did not
+  ship (`eval`, `new Function`, scripts or imports loaded from a URL), a
+  Firefox manifest without `data_collection_permissions`, and API
+  permissions no shipped script uses. They never block a build. On a
+  dev build only the manifest checks run, because the hot-reload runtime
+  and the injected `management` permission are not what a store
+  receives (measured on seven published extensions' dev builds against a
+  production build of an official template).
+
+- The bundled `/extension-publish` command now takes an extension through
+  store review with this server's own tools instead of sending people to
+  the store consoles by hand: it validates, builds, checks for review
+  risks, rehearses with `extension_submit` (dry run), and submits only on
+  the user's yes through the approval link. It covers Chrome, Firefox,
+  Edge and Safari, and keeps whatever manifest version the project
+  declares rather than migrating it during a submission.
+
+## 10.10.4
+
+- `--project <workspace>/<project>` (env `EXTENSION_DEV_PROJECT`) pins a
+  server to one project. Every unnamed credential read takes that
+  project's login instead of the most recent one, an agent signed in to
+  several projects can no longer act on the wrong one, and a call that
+  names a different project is refused with `status: "project-pinned"`.
+  A pinned project with no stored login falls back to
+  `EXTENSION_DEV_TOKEN`, so CI keeps working.
+- New `@extension.dev/mcp/clients` export: `CLIENTS` and
+  `buildRecipe({ client, reach, strictApproval, project })` build the
+  exact setup for Claude Code, Cursor, VS Code, Codex and any
+  `mcpServers` client. The README's Setup section is generated from it
+  (`pnpm readme:clients`, checked by a spec), and the extension.dev
+  console's Connect dialog renders the same recipes, so the instructions
+  cannot drift. It never emits a setting that turns approvals off.
+
 ## 10.10.3
 
 - The engine pin moves off the canary to Extension.js `4.1.31` stable:

package/README.md

@@ -45,10 +45,12 @@ Built on [Extension.js](https://extension.js.org), the open-source cross-browser
 
 ## Setup
 
+<!-- setup:start (generated from src/clients, run pnpm readme:clients) -->
+
 ### Claude Code
 
 ```bash
-claude mcp add extension-dev npx @extension.dev/mcp
+claude mcp add extension-dev -- npx @extension.dev/mcp
 ```
 
 Or install it as a plugin, the MCP server plus the `/extension`, `/extension-add`, `/extension-debug`, and `/extension-publish` commands in one step:
@@ -62,19 +64,84 @@ Or install it as a plugin, the MCP server plus the `/extension`, `/extension-add
 
 [![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=extension-dev&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyJAZXh0ZW5zaW9uLmRldi9tY3AiXX0%3D)
 
-### Claude Desktop / `.mcp.json`
+`.cursor/mcp.json`:
 
 ```json
 {
   "mcpServers": {
     "extension-dev": {
       "command": "npx",
-      "args": ["@extension.dev/mcp"]
+      "args": [
+        "@extension.dev/mcp"
+      ]
     }
   }
 }
 ```
 
+### VS Code (Also GitHub Copilot)
+
+```bash
+code --add-mcp '{"name":"extension-dev","command":"npx","args":["@extension.dev/mcp"]}'
+```
+
+`.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "extension-dev": {
+      "type": "stdio",
+      "command": "npx",
+      "args": [
+        "@extension.dev/mcp"
+      ]
+    }
+  }
+}
+```
+
+### Codex
+
+```bash
+codex mcp add extension-dev -- npx @extension.dev/mcp
+```
+
+`~/.codex/config.toml`:
+
+```toml
+[mcp_servers.extension-dev]
+command = "npx"
+args = ["@extension.dev/mcp"]
+```
+
+### Other clients (Claude Desktop and .mcp.json)
+
+`.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "extension-dev": {
+      "command": "npx",
+      "args": [
+        "@extension.dev/mcp"
+      ]
+    }
+  }
+}
+```
+
+### Signing in and pinning a project
+
+The platform tools need a login. Sign in once per project, then add `--project <workspace>/<project>` to the server's arguments (or set `EXTENSION_DEV_PROJECT`) so that server only ever acts on that project, however many logins this machine holds. The console's Connect dialog fills both in for your project.
+
+```bash
+npx @extension.dev/mcp login --project <workspace>/<project>
+```
+
+<!-- setup:end -->
+
 ### Choosing what the agent can reach
 
 Two flags (or environment variables) narrow the server before an agent sees it:

package/bin/extension-mcp.js

@@ -27,6 +27,7 @@ Server flags:
   --features=local,platform     Tool groups to expose (default: both)
   --no-ship                     Refuse publish, promote, real submits,
                                 share links and share revokes
+  --project <workspace>/<proj>  Use only this project's login
 `
 
 const [, , cmd, ...rest] = process.argv

package/claude/commands/extension-publish.md

@@ -1,62 +1,39 @@
 ---
-description: Prepare an extension for store submission (Chrome Web Store, Firefox Add-ons)
-argument-hint: "[chrome|firefox|both]"
+description: Get an extension through store review (Chrome Web Store, Firefox AMO, Edge Add-ons, App Store for Safari)
+argument-hint: "[chrome|firefox|edge|safari|all]"
 ---
 
-Prepare the current extension for store submission. The user said: $ARGUMENTS
+Take the current extension to store review. The user said: $ARGUMENTS
 
 ## Parse arguments
 
-Default to `both` (Chrome + Firefox). If the user specifies `chrome` or `firefox`, target only that store.
+Default to `chrome` and `firefox`. `all` means chrome, firefox, edge and safari. Accept any comma-separated mix.
 
 ## Steps
 
-1. **Validate the manifest**
-   If MCP tool `extension_manifest_validate` is available, use it with the target browsers.
-   Otherwise, read `src/manifest.json` and check:
-   - Has `name`, `version`, `description`
-   - Has appropriate `manifest_version` for each target
-   - Permissions are minimal (no unnecessary permissions)
-   - Has icons (at least 16x16, 48x48, 128x128)
-
-2. **Build for each target browser**
-
-   ```bash
-   npx extension build --browser=chrome --zip
-   npx extension build --browser=firefox --zip
-   ```
-
-3. **Inspect the builds**
-   If MCP tool `extension_analyze` is available, use it for each browser build.
-   Check:
-   - Total size under 10MB (store limit)
-   - No source maps in production build
-   - Has manifest.json in dist
-   - Has icons
-
-4. **Report store readiness**
-
-   ### Chrome Web Store
-   - Zip location: `dist/chrome/<name>.zip`
-   - Submit at: https://chrome.google.com/webstore/devconsole
-   - Checklist:
-     - [ ] manifest_version: 3
-     - [ ] Icons: 128x128 PNG
-     - [ ] Description under 132 characters (for listing)
-     - [ ] Screenshots: 1280x800 or 640x400
-     - [ ] Privacy policy URL (if using sensitive permissions)
-
-   ### Firefox Add-ons (AMO)
-   - Zip location: `dist/firefox/<name>.zip`
-   - Submit at: https://addons.mozilla.org/developers/
-   - Checklist:
-     - [ ] manifest_version: 2 (recommended for broadest compat) or 3
-     - [ ] No Chrome-only APIs without polyfill
-     - [ ] Source code zip if using a bundler: `npx extension build --browser=firefox --zip --zip-source`
-     - [ ] AMO requires source code review for minified/bundled code
-
-5. **Flag issues** that would cause store rejection:
-   - `<all_urls>` host permission without justification
-   - `activeTab` + `scripting` without clear use case
-   - Remote code loading (eval, Function constructor, remote scripts)
-   - Excessive permissions for the extension's functionality
+1. **Check the manifest.** Call `extension_manifest_validate` for each target browser. Fix every `buildBlocking` finding before going on; report warnings.
+
+2. **Build store bundles.** Call `extension_build` with `zip: true` for each target. If it refuses on a blocking manifest error or returns compiler errors in `value.errors`, fix and rebuild.
+
+3. **Look for review risks.** Call `extension_analyze` on each build and flag anything a reviewer rejects:
+   - `<all_urls>` or broad host permissions without a reason in the listing
+   - remote code (`eval`, `new Function`, scripts loaded from a URL)
+   - permissions the code never uses
+   - Firefox: a missing `browser_specific_settings.gecko.data_collection_permissions` declaration, which AMO now requires for new add-ons and updates
+   - a bundle over 10 MB, source maps in the production build, missing 128px icon
+
+4. **Pick the build to submit.** Store review runs from a build on extension.dev, not from local files. Call `extension_release_status` with `include: "releases"` to find the sha. If the user has not shipped this version yet, say so and offer `extension_publish` first.
+
+5. **Rehearse.** Call `extension_submit` with the browsers and `buildSha`, leaving `dryRun` at its default (`true`). Show the per-store credential rows. A store whose credentials are not healthy is fixed in the extension.dev console (the response names the page); drop it from `browsers` or stop.
+
+6. **Submit only on a clear yes.** Ask the user to confirm the exact stores, build and channel. Then call `extension_submit` with `dryRun: false`.
+   - It answers `approval-required` with an `approvalUrl`: give the user that link. A workspace owner approves exactly this submission on extension.dev.
+   - When they say it is approved, call `extension_submit` again with the same arguments plus the returned `approvalId`. It runs once.
+
+7. **Report.** Call `extension_release_status` for the recorded outcome and review state per store, and give the user each store's listing or dashboard link from the response.
+
+## Rules
+
+- Never submit without the user's confirmation in step 6, and never retry a real submission with a different build or store list under an old `approvalId`; request a new approval.
+- Keep the manifest version the project already declares. Extension.js templates use `chromium:manifest_version: 3` and `firefox:manifest_version: 2`, and AMO accepts both; do not migrate a manifest as part of a submission.
+- Store credentials are never arguments and never asked for in chat; they live in the extension.dev console.

package/dist/clients.js

@@ -0,0 +1,157 @@
+const CLIENTS = [
+    {
+        id: "claude-code",
+        label: "Claude Code"
+    },
+    {
+        id: "cursor",
+        label: "Cursor"
+    },
+    {
+        id: "vscode",
+        label: "VS Code",
+        subtitle: "Also GitHub Copilot"
+    },
+    {
+        id: "codex",
+        label: "Codex"
+    },
+    {
+        id: "json",
+        label: "Other clients",
+        subtitle: "Claude Desktop and .mcp.json"
+    }
+];
+const SERVER_NAME = "extension-dev";
+const PACKAGE = "@extension.dev/mcp";
+function serverArgs(input) {
+    const args = [
+        PACKAGE
+    ];
+    if ("local" !== input.reach && input.project) args.push("--project", input.project);
+    if ("no-ship" === input.reach) args.push("--no-ship");
+    if ("local" === input.reach) args.push("--features=local");
+    return args;
+}
+function serverEnv(input) {
+    return "everything" === input.reach && input.strictApproval ? {
+        EXTENSION_DEV_APPROVAL_GATE: "1"
+    } : {};
+}
+const shellQuote = (value)=>/^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+const base64 = (text)=>"function" == typeof btoa ? btoa(text) : globalThis.Buffer.from(text).toString("base64");
+const tomlString = (value)=>JSON.stringify(value);
+function loginCommand(project) {
+    return `npx ${PACKAGE} login --project ${shellQuote(project)}`;
+}
+function buildRecipe(input) {
+    const args = serverArgs(input);
+    const env = serverEnv(input);
+    const envEntries = Object.entries(env);
+    const stdio = {
+        command: "npx",
+        args,
+        ...envEntries.length ? {
+            env
+        } : {}
+    };
+    const login = loginCommand(input.project);
+    const argLine = args.map(shellQuote).join(" ");
+    switch(input.client){
+        case "claude-code":
+            return {
+                client: "claude-code",
+                command: [
+                    "claude mcp add",
+                    SERVER_NAME,
+                    ...envEntries.map(([k, v])=>`-e ${k}=${shellQuote(v)}`),
+                    "-- npx",
+                    argLine
+                ].join(" "),
+                login
+            };
+        case "cursor":
+            return {
+                client: "cursor",
+                deeplink: `https://cursor.com/en/install-mcp?name=${SERVER_NAME}&config=${encodeURIComponent(base64(JSON.stringify(stdio)))}`,
+                config: {
+                    language: "json",
+                    path: ".cursor/mcp.json",
+                    text: JSON.stringify({
+                        mcpServers: {
+                            [SERVER_NAME]: stdio
+                        }
+                    }, null, 2)
+                },
+                login
+            };
+        case "vscode":
+            {
+                const named = {
+                    name: SERVER_NAME,
+                    ...stdio
+                };
+                return {
+                    client: "vscode",
+                    command: `code --add-mcp ${shellQuote(JSON.stringify(named))}`,
+                    deeplink: `vscode:mcp/install?${encodeURIComponent(JSON.stringify(named))}`,
+                    config: {
+                        language: "json",
+                        path: ".vscode/mcp.json",
+                        text: JSON.stringify({
+                            servers: {
+                                [SERVER_NAME]: {
+                                    type: "stdio",
+                                    ...stdio
+                                }
+                            }
+                        }, null, 2)
+                    },
+                    login
+                };
+            }
+        case "codex":
+            {
+                const lines = [
+                    `[mcp_servers.${SERVER_NAME}]`,
+                    'command = "npx"',
+                    `args = [${args.map(tomlString).join(", ")}]`
+                ];
+                if (envEntries.length) {
+                    lines.push("", `[mcp_servers.${SERVER_NAME}.env]`);
+                    for (const [k, v] of envEntries)lines.push(`${k} = ${tomlString(v)}`);
+                }
+                return {
+                    client: "codex",
+                    command: [
+                        "codex mcp add",
+                        SERVER_NAME,
+                        ...envEntries.map(([k, v])=>`--env ${k}=${shellQuote(v)}`),
+                        "-- npx",
+                        argLine
+                    ].join(" "),
+                    config: {
+                        language: "toml",
+                        path: "~/.codex/config.toml",
+                        text: lines.join("\n")
+                    },
+                    login
+                };
+            }
+        case "json":
+            return {
+                client: "json",
+                config: {
+                    language: "json",
+                    path: ".mcp.json",
+                    text: JSON.stringify({
+                        mcpServers: {
+                            [SERVER_NAME]: stdio
+                        }
+                    }, null, 2)
+                },
+                login
+            };
+    }
+}
+export { CLIENTS, PACKAGE, SERVER_NAME, buildRecipe, loginCommand, serverArgs, serverEnv };

package/dist/module.js

@@ -236,7 +236,7 @@ __webpack_require__.d(workspace_create_namespaceObject, {
     handler: ()=>workspace_create_handler,
     schema: ()=>workspace_create_schema
 });
-var package_namespaceObject = JSON.parse('{"rE":"10.10.3","El":{"OP":"4.1.31"}}');
+var package_namespaceObject = JSON.parse('{"rE":"10.10.5","El":{"OP":"4.1.31"}}');
 const ENVELOPE_SCHEMA = 1;
 const collectWarnings = (warnings)=>{
     if (!warnings) return [];
@@ -509,8 +509,20 @@ function readCredentialStore() {
         entries
     };
 }
+const PROJECT_PIN_ENV = "EXTENSION_DEV_PROJECT";
+function pinnedProject() {
+    return String(process.env[PROJECT_PIN_ENV] || "").trim().toLowerCase();
+}
+function isProjectRef(value) {
+    return /^[a-z0-9][a-z0-9-_.]*\/[a-z0-9][a-z0-9-_.]*$/i.test(value);
+}
+function sameProject(named, pinned) {
+    const a = named.trim().toLowerCase();
+    if (!a || !pinned) return true;
+    return a.includes("/") ? a === pinned : a === pinned.split("/")[1];
+}
 function selectEntry(store, selector) {
-    const wanted = String(selector?.project ?? "").trim().toLowerCase();
+    const wanted = (String(selector?.project ?? "").trim() || pinnedProject()).toLowerCase();
     if (!wanted) return store.active && store.entries[store.active] || Object.values(store.entries)[0] || null;
     if (wanted.includes("/")) return store.entries[wanted] ?? null;
     const bySlug = Object.values(store.entries).filter((entry)=>entry.projectSlug.toLowerCase() === wanted);
@@ -3757,6 +3769,229 @@ function readZipEntryNames(zipPath) {
         } catch  {}
     }
 }
+const BROAD_PATTERNS = new Set([
+    "<all_urls>",
+    "*://*/*",
+    "http://*/*",
+    "https://*/*",
+    "*://*/"
+]);
+const API_PERMISSIONS = {
+    alarms: [
+        "alarms"
+    ],
+    bookmarks: [
+        "bookmarks"
+    ],
+    contextMenus: [
+        "contextMenus",
+        "menus"
+    ],
+    menus: [
+        "menus",
+        "contextMenus"
+    ],
+    cookies: [
+        "cookies"
+    ],
+    declarativeNetRequest: [
+        "declarativeNetRequest"
+    ],
+    downloads: [
+        "downloads"
+    ],
+    history: [
+        "history"
+    ],
+    identity: [
+        "identity"
+    ],
+    idle: [
+        "idle"
+    ],
+    management: [
+        "management"
+    ],
+    notifications: [
+        "notifications"
+    ],
+    offscreen: [
+        "offscreen"
+    ],
+    scripting: [
+        "scripting"
+    ],
+    sidePanel: [
+        "sidePanel"
+    ],
+    storage: [
+        "storage"
+    ],
+    tabGroups: [
+        "tabGroups"
+    ],
+    tabs: [
+        "tabs"
+    ],
+    topSites: [
+        "topSites"
+    ],
+    tts: [
+        "tts"
+    ],
+    webNavigation: [
+        "webNavigation"
+    ],
+    webRequest: [
+        "webRequest"
+    ]
+};
+const REMOTE_CODE_PATTERNS = [
+    [
+        "eval()",
+        /\beval\s*\(/
+    ],
+    [
+        "new Function()",
+        /\bnew\s+Function\s*\(/
+    ],
+    [
+        "importScripts from a URL",
+        /importScripts\(\s*["'`]https?:/
+    ],
+    [
+        "import() from a URL",
+        /\bimport\(\s*["'`]https?:/
+    ]
+];
+const REMOTE_SCRIPT_TAG = /<script[^>]+src\s*=\s*["']https?:/i;
+const MAX_SCAN_BYTES = 8388608;
+function strings(value) {
+    return Array.isArray(value) ? value.filter((v)=>"string" == typeof v) : [];
+}
+function hostPatterns(manifest) {
+    const found = new Set();
+    for (const pattern of strings(manifest.host_permissions))found.add(pattern);
+    for (const perm of strings(manifest.permissions))if (perm.includes("://") || "<all_urls>" === perm) found.add(perm);
+    const scripts = Array.isArray(manifest.content_scripts) ? manifest.content_scripts : [];
+    for (const entry of scripts)for (const match of strings(entry?.matches))found.add(match);
+    return [
+        ...found
+    ];
+}
+function readText(distPath, rel) {
+    try {
+        return node_fs.readFileSync(node_path.join(distPath, rel), "utf8");
+    } catch  {
+        return "";
+    }
+}
+function reviewRisks(input) {
+    const risks = [];
+    const development = input.development ?? isDevelopmentBuild(input.files);
+    const broad = hostPatterns(input.manifest).filter((p)=>BROAD_PATTERNS.has(p));
+    if (broad.length) risks.push({
+        code: "BROAD_HOST_ACCESS",
+        message: `The extension asks for access to every website (${broad.join(", ")}). Chrome Web Store and AMO reviewers ask why, and the review takes longer.`,
+        fix: "List only the sites the extension works on, or use activeTab so access is granted per click; if every site is the point, say why in the listing.",
+        permissions: broad
+    });
+    const scripts = input.files.filter((f)=>/\.(m?js|cjs)$/.test(f.path) && !f.path.endsWith(".map"));
+    const pages = input.files.filter((f)=>/\.html?$/.test(f.path));
+    const hits = new Map();
+    const note = (label, file)=>{
+        if (!hits.has(label)) hits.set(label, new Set());
+        hits.get(label).add(file);
+    };
+    let scanned = 0;
+    let source = "";
+    for (const file of scripts){
+        if (scanned >= MAX_SCAN_BYTES) break;
+        const text = readText(input.distPath, file.path);
+        scanned += text.length;
+        source += `\n${text}`;
+        for (const [label, pattern] of REMOTE_CODE_PATTERNS)if (pattern.test(text)) note(label, file.path);
+    }
+    for (const file of pages)if (REMOTE_SCRIPT_TAG.test(readText(input.distPath, file.path))) note("a <script> loaded from a URL", file.path);
+    if (hits.size && !development) {
+        const labels = [
+            ...hits.keys()
+        ];
+        risks.push({
+            code: "REMOTE_CODE",
+            message: `The package contains ${labels.join(", ")}. Manifest V3 stores reject extensions that run code they did not ship, and reviewers flag these patterns even inside a bundled library.`,
+            fix: "Remove the call, or confirm it only ever runs code that ships in the package and be ready to say so in review.",
+            files: [
+                ...new Set([
+                    ...hits.values()
+                ].flatMap((set)=>[
+                        ...set
+                    ]))
+            ].slice(0, 10)
+        });
+    }
+    if (isGeckoFamily(input.browser)) {
+        const gecko = input.manifest.browser_specific_settings?.gecko;
+        if (!gecko || !("data_collection_permissions" in gecko)) risks.push({
+            code: "FIREFOX_DATA_COLLECTION_MISSING",
+            message: "The Firefox manifest has no browser_specific_settings.gecko.data_collection_permissions. AMO requires it for new add-ons and for updates.",
+            fix: 'Add "browser_specific_settings": { "gecko": { "data_collection_permissions": { "required": ["none"] } } }, or list what the extension does collect.'
+        });
+    }
+    if (source && scanned < MAX_SCAN_BYTES && !development) {
+        const unused = strings(input.manifest.permissions).filter((perm)=>{
+            const apis = API_PERMISSIONS[perm];
+            if (!apis) return false;
+            return !apis.some((api)=>new RegExp(`\\.${api}\\b`).test(source));
+        });
+        if (unused.length) risks.push({
+            code: "UNUSED_PERMISSION",
+            message: `The manifest asks for ${unused.join(", ")}, but no shipped script uses ${1 === unused.length ? "that API" : "those APIs"}. Reviewers reject permissions an extension does not need.`,
+            fix: `Remove ${unused.join(", ")} from permissions, or keep ${1 === unused.length ? "it" : "them"} if the call happens in code this scan cannot see.`,
+            permissions: unused
+        });
+    }
+    return risks;
+}
+function isDevelopmentBuild(files) {
+    return files.some((f)=>f.path.endsWith(".map") || /hot-update\./.test(f.path));
+}
+function reviewRiskWarnings(risks) {
+    return risks.map((risk)=>`Store review: ${risk.message} ${risk.fix}`);
+}
+function listFiles(dir, base = "") {
+    let entries;
+    try {
+        entries = node_fs.readdirSync(dir, {
+            withFileTypes: true
+        });
+    } catch  {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries){
+        const rel = base ? `${base}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) out.push(...listFiles(node_path.join(dir, entry.name), rel));
+        else out.push({
+            path: rel
+        });
+    }
+    return out;
+}
+function reviewDist(distPath, browser) {
+    let manifest;
+    try {
+        manifest = JSON.parse(node_fs.readFileSync(node_path.join(distPath, "manifest.json"), "utf8"));
+    } catch  {
+        return [];
+    }
+    return reviewRisks({
+        distPath,
+        browser,
+        manifest,
+        files: listFiles(distPath)
+    });
+}
 const build_COMMAND = "extension_build";
 function readBuildSummary(projectPath, browser, since) {
     const file = session_paths_buildSummaryPath(projectPath, browser);
@@ -4198,6 +4433,7 @@ async function build_handler(args) {
         const buildWarningsTruncated = buildWarnings.length && "number" == typeof engineSummary?.warnings_count && engineSummary.warnings_count > buildWarnings.length ? engineSummary.warnings_count : void 0;
         const distDir = node_path.resolve(args.projectPath, "dist", browser);
         const entrypoints = builtEntrypoints(distDir);
+        const risks = reviewDist(distDir, browser);
         const contamination = carrierContamination(node_path.resolve(args.projectPath, "dist"));
         const uncheckedNote = contamination.unchecked.length ? `Could not read the entry table of ${contamination.unchecked.join(", ")}, so those archives were not checked for the live-preview carrier. Unpack and check them yourself before submitting.` : null;
         if (contamination.paths.length) return envelope_envelope({
@@ -4281,6 +4517,9 @@ async function build_handler(args) {
                 ...entrypoints.length ? {
                     entrypoints
                 } : {},
+                ...risks.length ? {
+                    reviewRisks: risks
+                } : {},
                 ...void 0 !== buildWarningsTruncated ? {
                     buildWarningsTruncated
                 } : {},
@@ -4301,6 +4540,7 @@ async function build_handler(args) {
                 ...warnings,
                 ...preflight?.warnings ?? [],
                 ...buildWarnings,
+                ...reviewRiskWarnings(risks),
                 ...zipNotes,
                 uncheckedNote,
                 derivedBundleIdNote,
@@ -7921,12 +8161,15 @@ async function openSidebarThroughGesture(projectPath, browser, refusal) {
     return actFrameJson(refusal);
 }
 function resolveToken(options = {}) {
-    const project = String(options.project ?? "").trim();
+    const named = String(options.project ?? "").trim();
+    const project = named || pinnedProject();
     if (project) {
         const creds = readValidCredentials(void 0, {
             project
         });
-        return creds?.token ? String(creds.token).trim() : "";
+        if (creds?.token) return String(creds.token).trim();
+        if (named) return "";
+        return String(process.env.EXTENSION_DEV_TOKEN || "").trim();
     }
     const fromEnv = String(process.env.EXTENSION_DEV_TOKEN || "").trim();
     if (fromEnv) return fromEnv;
@@ -13054,9 +13297,17 @@ async function analyze_handler(args) {
     }
     const note = "development" === buildType ? `This dist contains ${formatBytes(sourcemapSize)} of sourcemaps and looks like a dev build; run extension_build for production sizes. shippableSize excludes sourcemaps.` : void 0;
     const archiveNote = archiveSize > 0 ? `This dist contains ${formatBytes(archiveSize)} of .zip archive(s) (store packaging output, written into dist by zip builds). shippableSize excludes them so the packaged copy does not double-count the files it contains.` : void 0;
+    const risks = reviewRisks({
+        distPath,
+        browser,
+        manifest,
+        files,
+        development: "development" === buildType
+    });
     const result = {
         browser,
         distPath,
+        reviewRisks: risks,
         entrypoints,
         buildType,
         totalSize,
@@ -13105,6 +13356,7 @@ async function analyze_handler(args) {
         status: "analyzed",
         value: result,
         warnings: [
+            ...reviewRiskWarnings(risks),
             ...sizeWarnings,
             note,
             archiveNote
@@ -18058,30 +18310,41 @@ const truthy = (raw)=>{
     return "" !== value && "0" !== value && "false" !== value && "off" !== value;
 };
 function isServerFlag(arg) {
-    return "--no-ship" === arg || "--features" === arg || arg.startsWith("--features=");
+    return "--no-ship" === arg || "--features" === arg || arg.startsWith("--features=") || "--project" === arg || arg.startsWith("--project=");
 }
 function resolveServerOptions(argv, env) {
     let rawFeatures = env[FEATURES_ENV];
     let noShip = truthy(env[NO_SHIP_ENV]);
+    let project = String(env[PROJECT_PIN_ENV] || "").trim().toLowerCase();
     for(let i = 0; i < argv.length; i++){
         const arg = argv[i];
         if ("--no-ship" === arg) noShip = true;
         else if ("--features" === arg) rawFeatures = argv[++i] ?? "";
+        else if (arg.startsWith("--features=")) rawFeatures = arg.slice(11);
+        else if ("--project" === arg) project = String(argv[++i] ?? "").trim().toLowerCase();
         else {
-            if (!arg.startsWith("--features=")) return {
+            if (!arg.startsWith("--project=")) return {
                 ok: false,
                 message: `Unknown flag "${arg}".`
             };
-            rawFeatures = arg.slice(11);
+            project = arg.slice(10).trim().toLowerCase();
         }
     }
+    if (project && !isProjectRef(project)) return {
+        ok: false,
+        message: `--project takes "<workspace>/<project>", got "${project}".`
+    };
+    const pin = project ? {
+        project
+    } : {};
     if (void 0 === rawFeatures || "" === rawFeatures.trim()) return {
         ok: true,
         options: {
             features: [
                 ...FEATURE_GROUPS
             ],
-            noShip
+            noShip,
+            ...pin
         }
     };
     const names = rawFeatures.split(",").map((name)=>name.trim().toLowerCase()).filter(Boolean);
@@ -18095,7 +18358,8 @@ function resolveServerOptions(argv, env) {
         ok: true,
         options: {
             features,
-            noShip
+            noShip,
+            ...pin
         }
     };
 }
@@ -18138,6 +18402,40 @@ function disabledToolEnvelope(name, args, options) {
     });
     return null;
 }
+function pinProjectArgs(name, args, inputSchema, options) {
+    const pinned = options.project;
+    if (!pinned) return {
+        args
+    };
+    const named = "string" == typeof args.project ? args.project : "";
+    if (named && !sameProject(named, pinned)) return {
+        refused: envelope_envelope({
+            ok: false,
+            command: name,
+            status: "project-pinned",
+            error: {
+                code: "E_TOOL_DISABLED",
+                message: `This server is pinned to ${pinned} and was asked to act on ${named}.`
+            },
+            value: {
+                pinned,
+                named
+            },
+            hint: `Work on ${named} through an MCP server configured with --project ${named}, or change this server's --project (or ${PROJECT_PIN_ENV}).`
+        })
+    };
+    const properties = inputSchema.properties ?? {};
+    const statusOnly = "extension_auth" === name && "status" === args.action;
+    if (named || statusOnly || !("project" in properties)) return {
+        args
+    };
+    return {
+        args: {
+            ...args,
+            project: pinned
+        }
+    };
+}
 const tools = [
     create_namespaceObject,
     templates_namespaceObject,
@@ -18235,8 +18533,8 @@ function createServer(options = DEFAULT_SERVER_OPTIONS) {
             ],
             isError: true
         };
-        const normalizedArgs = normalizeArgAliases(tool.schema.inputSchema, args ?? {});
-        const disabled = disabledToolEnvelope(name, normalizedArgs, options);
+        const aliasedArgs = normalizeArgAliases(tool.schema.inputSchema, args ?? {});
+        const disabled = disabledToolEnvelope(name, aliasedArgs, options);
         if (disabled) return {
             content: [
                 {
@@ -18246,6 +18544,17 @@ function createServer(options = DEFAULT_SERVER_OPTIONS) {
             ],
             isError: true
         };
+        const pinned = pinProjectArgs(name, aliasedArgs, tool.schema.inputSchema, options);
+        if ("refused" in pinned) return {
+            content: [
+                {
+                    type: "text",
+                    text: pinned.refused
+                }
+            ],
+            isError: true
+        };
+        const normalizedArgs = pinned.args;
         const issues = validateToolInput(tool.schema.inputSchema, normalizedArgs);
         if (issues.length) return {
             content: [
@@ -18284,6 +18593,7 @@ function createServer(options = DEFAULT_SERVER_OPTIONS) {
 }
 async function startServer(options = DEFAULT_SERVER_OPTIONS) {
     installCarrierExitCleanup();
+    if (options.project) process.env.EXTENSION_DEV_PROJECT = options.project;
     const server = createServer(options);
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/src/clients/index.d.ts

@@ -0,0 +1,31 @@
+export type ClientId = "claude-code" | "cursor" | "vscode" | "codex" | "json";
+export type Reach = "everything" | "no-ship" | "local";
+export interface ClientInfo {
+    id: ClientId;
+    label: string;
+    subtitle?: string;
+}
+export declare const CLIENTS: readonly ClientInfo[];
+export interface Recipe {
+    client: ClientId;
+    command?: string;
+    config?: {
+        language: "json" | "toml";
+        path: string;
+        text: string;
+    };
+    deeplink?: string;
+    login: string;
+}
+export interface RecipeInput {
+    client: ClientId;
+    reach: Reach;
+    strictApproval: boolean;
+    project: string;
+}
+export declare const SERVER_NAME = "extension-dev";
+export declare const PACKAGE = "@extension.dev/mcp";
+export declare function serverArgs(input: Omit<RecipeInput, "client">): string[];
+export declare function serverEnv(input: Omit<RecipeInput, "client">): Record<string, string>;
+export declare function loginCommand(project: string): string;
+export declare function buildRecipe(input: RecipeInput): Recipe;

package/dist/src/clients/readme.d.ts

@@ -0,0 +1,4 @@
+export declare const README_SETUP_START = "<!-- setup:start (generated from src/clients, run pnpm readme:clients) -->";
+export declare const README_SETUP_END = "<!-- setup:end -->";
+export declare function renderReadmeSetup(): string;
+export declare function spliceReadmeSetup(readme: string): string;

package/dist/src/lib/credentials.d.ts

@@ -18,6 +18,10 @@ export interface CredentialSelector {
 }
 export declare function credentialKey(workspaceSlug: string, projectSlug: string): string;
 export declare function readCredentialStore(): CredentialStore | null;
+export declare const PROJECT_PIN_ENV = "EXTENSION_DEV_PROJECT";
+export declare function pinnedProject(): string;
+export declare function isProjectRef(value: string): boolean;
+export declare function sameProject(named: string, pinned: string): boolean;
 export declare function readCredentials(selector?: CredentialSelector): StoredCredentials | null;
 export declare function listCredentials(): Array<StoredCredentials & {
     key: string;

package/dist/src/lib/store-review.d.ts

@@ -0,0 +1,23 @@
+export type ReviewRiskCode = "BROAD_HOST_ACCESS" | "REMOTE_CODE" | "FIREFOX_DATA_COLLECTION_MISSING" | "UNUSED_PERMISSION";
+export interface ReviewRisk {
+    code: ReviewRiskCode;
+    message: string;
+    fix: string;
+    files?: string[];
+    permissions?: string[];
+}
+export declare function reviewRisks(input: {
+    distPath: string;
+    browser: string;
+    manifest: Record<string, unknown>;
+    files: Array<{
+        path: string;
+        type?: string;
+    }>;
+    development?: boolean;
+}): ReviewRisk[];
+export declare function isDevelopmentBuild(files: Array<{
+    path: string;
+}>): boolean;
+export declare function reviewRiskWarnings(risks: ReviewRisk[]): string[];
+export declare function reviewDist(distPath: string, browser: string): ReviewRisk[];

package/dist/src/lib/tool-policy.d.ts

@@ -18,6 +18,7 @@ export declare const TOOL_POLICY: Record<string, ToolPolicy>;
 export interface ServerOptions {
     features: FeatureGroup[];
     noShip: boolean;
+    project?: string;
 }
 export declare const DEFAULT_SERVER_OPTIONS: ServerOptions;
 export declare function isServerFlag(arg: string): boolean;
@@ -30,4 +31,9 @@ export declare function resolveServerOptions(argv: string[], env: Record<string,
 };
 export declare function isToolListed(name: string, options: ServerOptions): boolean;
 export declare function disabledToolEnvelope(name: string, args: Args, options: ServerOptions): string | null;
+export declare function pinProjectArgs(name: string, args: Args, inputSchema: Record<string, unknown>, options: ServerOptions): {
+    args: Args;
+} | {
+    refused: string;
+};
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@extension.dev/mcp",
   "type": "module",
-  "version": "10.10.3",
+  "version": "10.10.5",
   "description": "MCP server that lets AI agents (Claude Code, Claude Desktop, Cursor, Copilot, Codex) build, run, inspect, and publish browser extensions. 31 tools for scaffolding, live DOM inspection, log streaming, and store-ready builds across Chrome, Edge, Firefox, Safari, and every Chromium- or Gecko-based browser (Brave, Opera, Vivaldi, Yandex, Waterfox, LibreWolf). Powered by extension.dev and Extension.js.",
   "mcpName": "io.github.extensiondev/mcp",
   "license": "Apache-2.0",
@@ -26,6 +26,10 @@
     ".": {
       "types": "./dist/module.d.ts",
       "import": "./dist/module.js"
+    },
+    "./clients": {
+      "types": "./dist/src/clients/index.d.ts",
+      "import": "./dist/clients.js"
     }
   },
   "main": "./dist/module.js",
@@ -46,6 +50,7 @@
   ],
   "scripts": {
     "clean": "rm -rf dist",
+    "readme:clients": "UPDATE_README=1 vitest run src/__tests__/readme-clients.test.ts",
     "watch": "rslib build --watch",
     "compile": "rslib build",
     "build": "pnpm run compile",

package/server.json

@@ -7,13 +7,13 @@
     "source": "github"
   },
   "websiteUrl": "https://extension.dev",
-  "version": "10.10.3",
+  "version": "10.10.5",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@extension.dev/mcp",
-      "version": "10.10.3",
+      "version": "10.10.5",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"