chrome-extension-tester-mcp 2.2.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-extension-tester-mcp",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "MCP server for interactive Chrome extension testing via Playwright — load, interact, assert, inspect storage, network, badges, messaging, tabs, and more.",
   "type": "module",
   "main": "src/index.js",

package/src/state.js

@@ -77,6 +77,18 @@ export async function getServiceWorker() {
   const ctx = state.context || state.browser;
   if (!ctx) throw new Error("No browser connected. Call load_extension or connect_browser first.");
   const workers = ctx.serviceWorkers();
+
+  if (state.extensionId) {
+    const targetWorker = workers.find((w) => w.url().includes(state.extensionId));
+    if (targetWorker) return targetWorker;
+    const workerList = workers.map((w) => `  ${w.url()}`).join("\n") || "  (none)";
+    throw new Error(
+      `No service worker found for extension ${state.extensionId}.\n` +
+      `Active workers:\n${workerList}\n` +
+      `Re-run connect_browser with the correct extension_id to retarget.`
+    );
+  }
+
   if (!workers.length) throw new Error("No service worker found. Extension may not have a background service worker.");
   return workers[0];
 }

package/src/tools/connect-browser.js

@@ -14,19 +14,59 @@ const KNOWN_BROWSERS = [
     name: "Brave",
     executable: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
     userDataDir: `${os.homedir()}/Library/Application Support/BraveSoftware/Brave-Browser`,
+    extensionsDir: `${os.homedir()}/Library/Application Support/BraveSoftware/Brave-Browser/Default/Extensions`,
   },
   {
     name: "Chrome",
     executable: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
     userDataDir: `${os.homedir()}/Library/Application Support/Google/Chrome`,
+    extensionsDir: `${os.homedir()}/Library/Application Support/Google/Chrome/Default/Extensions`,
   },
   {
     name: "Chromium",
     executable: "/Applications/Chromium.app/Contents/MacOS/Chromium",
     userDataDir: `${os.homedir()}/Library/Application Support/Chromium`,
+    extensionsDir: `${os.homedir()}/Library/Application Support/Chromium/Default/Extensions`,
   },
 ];
 
+function readExtensionManifest(extensionsDir, extensionId) {
+  try {
+    const versionDirs = fs.readdirSync(`${extensionsDir}/${extensionId}`);
+    for (const version of versionDirs) {
+      const manifestPath = `${extensionsDir}/${extensionId}/${version}/manifest.json`;
+      if (fs.existsSync(manifestPath)) {
+        return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+      }
+    }
+  } catch {}
+  return null;
+}
+
+function listInstalledExtensions(extensionsDir) {
+  if (!fs.existsSync(extensionsDir)) return [];
+  const ids = fs.readdirSync(extensionsDir).filter((d) => /^[a-z]{32}$/.test(d));
+  return ids.map((id) => {
+    const manifest = readExtensionManifest(extensionsDir, id);
+    const name = manifest?.name || "(unknown)";
+    return { id, name };
+  });
+}
+
+// Accepts a 32-char extension ID or a name substring; returns the resolved ID or throws on ambiguity.
+function resolveExtensionId(nameOrId, extensionsDir) {
+  if (/^[a-z]{32}$/.test(nameOrId)) return nameOrId;
+  const extensions = listInstalledExtensions(extensionsDir);
+  const needle = nameOrId.toLowerCase();
+  const matches = extensions.filter((e) => e.name.toLowerCase().includes(needle));
+  if (matches.length === 0) return null;
+  if (matches.length > 1) {
+    const list = matches.map((e) => `  ${e.id}  ${e.name}`).join("\n");
+    throw new Error(`"${nameOrId}" matched ${matches.length} extensions — pass the full ID instead:\n${list}`);
+  }
+  return matches[0].id;
+}
+
 async function fetchCdpVersionInfo(port) {
   try {
     const controller = new AbortController();
@@ -86,17 +126,18 @@ async function findExtensionIdFromTargets(port) {
 }
 
 function attachSwLogListeners(context) {
-  const existingWorkers = context.serviceWorkers();
-  existingWorkers.forEach((sw) => {
-    sw.on("console", (msg) =>
-      state.swLogs.push(`[${new Date().toISOString()}] ${msg.type()}: ${msg.text()}`)
-    );
-  });
-  context.on("serviceworker", (sw) => {
-    sw.on("console", (msg) =>
-      state.swLogs.push(`[${new Date().toISOString()}] ${msg.type()}: ${msg.text()}`)
-    );
-  });
+  const attachToWorker = (sw) => {
+    sw.on("console", (msg) => {
+      // Check state.extensionId at capture time so retargeting takes effect immediately.
+      const workerExtId = extractExtensionIdFromUrl(sw.url());
+      if (!state.extensionId || workerExtId === state.extensionId) {
+        state.swLogs.push(`[${new Date().toISOString()}] ${msg.type()}: ${msg.text()}`);
+      }
+    });
+  };
+
+  context.serviceWorkers().forEach(attachToWorker);
+  context.on("serviceworker", attachToWorker);
 }
 
 export async function teardownExistingConnection() {
@@ -184,11 +225,12 @@ export const definition = {
     properties: {
       action: {
         type: "string",
-        enum: ["scan", "connect", "launch"],
+        enum: ["scan", "connect", "launch", "list_extensions"],
         description:
           "'scan' — list running debuggable browsers and installed browsers. " +
           "'connect' — attach to a browser already running with --remote-debugging-port. " +
-          "'launch' — start an installed browser with your real profile and remote debugging, then connect.",
+          "'launch' — start an installed browser with your real profile and remote debugging, then connect. " +
+          "'list_extensions' — list all installed extensions with their IDs and names.",
       },
       port: {
         type: "number",
@@ -203,14 +245,44 @@ export const definition = {
         type: "number",
         description: "Port to use for remote debugging when launching (for 'launch' action). Defaults to 9222.",
       },
+      extension_id: {
+        type: "string",
+        description: "Extension ID (32 lowercase chars) or name substring to target (for 'connect' and 'launch' actions). Overrides auto-detection — pass the name (e.g. 'AudiTex') or full ID to pick the right extension when multiple are installed.",
+      },
+      browser_name_for_extensions: {
+        type: "string",
+        enum: ["Brave", "Chrome", "Chromium"],
+        description: "Which browser's extensions directory to scan (for 'list_extensions' action). Defaults to 'Brave'.",
+      },
     },
     required: ["action"],
   },
 };
 
+function getExtensionsDirForBrowser(browserName) {
+  const name = browserName || "Brave";
+  const config = KNOWN_BROWSERS.find((b) => b.name === name);
+  return config?.extensionsDir || null;
+}
+
 export async function handler(args) {
   const { action } = args;
 
+  if (action === "list_extensions") {
+    const extensionsDir = getExtensionsDirForBrowser(args.browser_name_for_extensions);
+    if (!extensionsDir || !fs.existsSync(extensionsDir)) {
+      throw new Error(`Extensions directory not found: ${extensionsDir}`);
+    }
+    const extensions = listInstalledExtensions(extensionsDir);
+    const lines = extensions.map((e) => `  ${e.id}  ${e.name}`);
+    return {
+      content: [{
+        type: "text",
+        text: `Installed extensions (${extensions.length}):\n${lines.join("\n")}\n\nPass the ID or name substring as extension_id when connecting.`,
+      }],
+    };
+  }
+
   if (action === "scan") {
     const runningBrowsers = await scanRunningBrowsers();
     const installedBrowsers = detectInstalledBrowsers();
@@ -261,7 +333,14 @@ export async function handler(args) {
     }
 
     await teardownExistingConnection();
-    const extensionId = await connectToDebugPort(port);
+    await connectToDebugPort(port);
+
+    if (args.extension_id) {
+      const extensionsDir = getExtensionsDirForBrowser("Brave");
+      const resolved = extensionsDir ? resolveExtensionId(args.extension_id, extensionsDir) : null;
+      if (!resolved) throw new Error(`No installed extension found matching "${args.extension_id}". Run action:"list_extensions" to see available extensions.`);
+      state.extensionId = resolved;
+    }
 
     return {
       content: [
@@ -269,7 +348,7 @@ export async function handler(args) {
           type: "text",
           text: [
             `Connected to ${versionInfo.Browser} on port ${port}.`,
-            `Extension ID: ${extensionId || "not detected — open chrome://extensions to find it"}`,
+            `Extension ID: ${state.extensionId || "not detected — run list_extensions to find it"}`,
             "",
             "Your existing tabs and logged-in sessions are preserved.",
             "All other tools (interact_with_popup, inspect_dom, etc.) will now use this browser.",
@@ -292,18 +371,26 @@ export async function handler(args) {
       throw new Error(`${browserName} not found at: ${browserConfig.executable}`);
     }
 
+    const resolveTarget = (nameOrId) => {
+      if (!nameOrId) return null;
+      const resolved = resolveExtensionId(nameOrId, browserConfig.extensionsDir);
+      if (!resolved) throw new Error(`No installed extension found matching "${nameOrId}". Run action:"list_extensions" to see available extensions.`);
+      return resolved;
+    };
+
     // If a browser is already debugging on the target port, just connect to it.
     const alreadyRunning = await fetchCdpVersionInfo(port);
     if (alreadyRunning) {
       await teardownExistingConnection();
-      const extensionId = await connectToDebugPort(port);
+      await connectToDebugPort(port);
+      if (args.extension_id) state.extensionId = resolveTarget(args.extension_id);
       return {
         content: [
           {
             type: "text",
             text: [
               `Browser already running with debugging on port ${port}. Connected to ${alreadyRunning.Browser}.`,
-              `Extension ID: ${extensionId || "not detected"}`,
+              `Extension ID: ${state.extensionId || "not detected"}`,
             ].join("\n"),
           },
         ],
@@ -312,7 +399,8 @@ export async function handler(args) {
 
     await teardownExistingConnection();
     await launchBrowserProcess(browserConfig, port);
-    const extensionId = await connectToDebugPort(port);
+    await connectToDebugPort(port);
+    if (args.extension_id) state.extensionId = resolveTarget(args.extension_id);
 
     return {
       content: [
@@ -321,7 +409,7 @@ export async function handler(args) {
           text: [
             `Launched ${browserName} with remote debugging on port ${port}.`,
             `Profile: ${browserConfig.userDataDir}`,
-            `Extension ID: ${extensionId || "not detected — open chrome://extensions to find it"}`,
+            `Extension ID: ${state.extensionId || "not detected — run list_extensions to find it"}`,
             "",
             "All your existing logins are available.",
             "All other tools (interact_with_popup, inspect_dom, etc.) will now use this browser.",
@@ -331,5 +419,5 @@ export async function handler(args) {
     };
   }
 
-  throw new Error(`Unknown action "${action}". Valid actions: "scan", "connect", "launch".`);
+  throw new Error(`Unknown action "${action}". Valid actions: "scan", "connect", "launch", "list_extensions".`);
 }

package/src/tools/tabs.js

@@ -25,10 +25,11 @@ export const definition = {
 };
 
 export async function handler(args) {
-  if (!state.browser) throw new Error("Browser not started. Call load_extension first.");
+  const ctx = state.context || state.browser;
+  if (!ctx) throw new Error("No browser connected. Call load_extension or connect_browser first.");
 
   if (args.action === "list") {
-    const pages = state.browser.pages();
+    const pages = ctx.pages();
     const list = await Promise.all(
       pages.map(async (p, i) => {
         const title = await p.title().catch(() => "(no title)");
@@ -41,15 +42,15 @@ export async function handler(args) {
 
   if (args.action === "open") {
     const url = args.url || "about:blank";
-    const newPage = await state.browser.newPage();
+    const newPage = await ctx.newPage();
     if (args.url) await newPage.goto(url, { waitUntil: "domcontentloaded" });
     state.page = newPage;
-    const index = state.browser.pages().length - 1;
+    const index = ctx.pages().length - 1;
     return { content: [{ type: "text", text: `Opened new tab [${index}]: ${url}` }] };
   }
 
   if (args.action === "switch") {
-    const pages = state.browser.pages();
+    const pages = ctx.pages();
     if (args.tab_index === undefined || args.tab_index < 0 || args.tab_index >= pages.length) {
       return { content: [{ type: "text", text: `Invalid tab_index ${args.tab_index}. Run 'list' to see available tabs.` }], isError: true };
     }
@@ -59,7 +60,7 @@ export async function handler(args) {
   }
 
   if (args.action === "close") {
-    const pages = state.browser.pages();
+    const pages = ctx.pages();
     if (args.tab_index === undefined || args.tab_index < 0 || args.tab_index >= pages.length) {
       return { content: [{ type: "text", text: `Invalid tab_index ${args.tab_index}. Run 'list' to see available tabs.` }], isError: true };
     }
@@ -67,14 +68,14 @@ export async function handler(args) {
     const closedUrl = toClose.url();
     await toClose.close();
     if (state.page === toClose || state.page?.isClosed()) {
-      const remaining = state.browser.pages();
+      const remaining = ctx.pages();
       state.page = remaining.length ? remaining[remaining.length - 1] : null;
     }
     return { content: [{ type: "text", text: `Closed tab [${args.tab_index}]: ${closedUrl}` }] };
   }
 
   if (args.action === "close_all") {
-    const pages = state.browser.pages();
+    const pages = ctx.pages();
     const closed = [];
     for (const p of pages) {
       const url = p.url();