codex-control-chrome-mcp 1.3.0 → 1.3.1

package/CHANGELOG.md

@@ -6,7 +6,11 @@ This project follows semantic versioning.
 
 ## [Unreleased]
 
-## [1.3.0] - 2026-07-03
+## [1.3.1] - 2026-07-04
+
+### Fixed
+
+- `chrome_evaluate`, `chrome_navigate`, and `chrome_screenshot` now self-heal a stale debugger attachment instead of dead-ending on `Debugger is not attached`. Each tool already attaches before sending CDP commands, but the extension tracks attachments in memory: when Chrome tears an attachment down out-of-band (a competing debugger client, DevTools, or a renderer/process swap), that flag can go stale, so a fresh `attach` short-circuits and reports success without actually re-attaching and the next command fails with `Debugger is not attached`. The tab then stayed wedged — `attach` kept reporting `ok` while every command failed — and only a new tab recovered. These tools now retry once on that specific error by issuing a `detach` (which clears the stale flag; it may itself report "not attached", which is expected and ignored) followed by a real `attach`, so a previously wedged tab recovers automatically. The self-heal wrapper is covered by regression tests. This addresses recovery in the bridge only; the underlying churn comes from multiple debugger clients contending for the same tab, so reducing competing browser-control stacks still helps.
 
 ### Changed
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-control-chrome-mcp",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "MCP server and native host bridge for controlling Chrome through the Codex Chrome extension.",
   "license": "MIT",
   "type": "module",

package/src/mcp-server.js

@@ -229,15 +229,15 @@ function registerTools(server, runtime) {
         url: z.string().url(),
       },
     },
-    async ({ tabId, url }) => {
-      await runtime.request("attach", { tabId });
-      await executeCdp(runtime, { tabId, method: "Page.enable", params: {} });
-      return toolResult(await executeCdp(runtime, {
-        tabId,
-        method: "Page.navigate",
-        params: { url },
-      }));
-    },
+    async ({ tabId, url }) =>
+      toolResult(await withReattach(runtime, tabId, async () => {
+        await executeCdp(runtime, { tabId, method: "Page.enable", params: {} });
+        return await executeCdp(runtime, {
+          tabId,
+          method: "Page.navigate",
+          params: { url },
+        });
+      })),
   );
 
   server.registerTool(
@@ -250,19 +250,19 @@ function registerTools(server, runtime) {
         awaitPromise: z.boolean().default(true),
       },
     },
-    async ({ tabId, expression, awaitPromise }) => {
-      await runtime.request("attach", { tabId });
-      await executeCdp(runtime, { tabId, method: "Runtime.enable", params: {} });
-      return toolResult(await executeCdp(runtime, {
-        tabId,
-        method: "Runtime.evaluate",
-        params: {
-          expression,
-          awaitPromise,
-          returnByValue: true,
-        },
-      }));
-    },
+    async ({ tabId, expression, awaitPromise }) =>
+      toolResult(await withReattach(runtime, tabId, async () => {
+        await executeCdp(runtime, { tabId, method: "Runtime.enable", params: {} });
+        return await executeCdp(runtime, {
+          tabId,
+          method: "Runtime.evaluate",
+          params: {
+            expression,
+            awaitPromise,
+            returnByValue: true,
+          },
+        });
+      })),
   );
 
   server.registerTool(
@@ -274,16 +274,16 @@ function registerTools(server, runtime) {
         format: z.enum(["png", "jpeg", "webp"]).default("png"),
       },
     },
-    async ({ tabId, format }) => {
-      await runtime.request("attach", { tabId });
-      await executeCdp(runtime, { tabId, method: "Page.enable", params: {} });
-      return toolResult(await executeCdp(runtime, {
-        tabId,
-        method: "Page.captureScreenshot",
-        params: { format, captureBeyondViewport: true },
-        timeoutMs: 30_000,
-      }));
-    },
+    async ({ tabId, format }) =>
+      toolResult(await withReattach(runtime, tabId, async () => {
+        await executeCdp(runtime, { tabId, method: "Page.enable", params: {} });
+        return await executeCdp(runtime, {
+          tabId,
+          method: "Page.captureScreenshot",
+          params: { format, captureBeyondViewport: true },
+          timeoutMs: 30_000,
+        });
+      })),
   );
 
   server.registerTool(
@@ -319,6 +319,38 @@ function registerTools(server, runtime) {
   );
 }
 
+/**
+ * Attach the debugger, run a CDP sequence, and self-heal a stale-attach state.
+ *
+ * The Codex Chrome extension tracks debugger attachments in memory. When Chrome
+ * tears an attachment down out-of-band (a competing debugger client, DevTools, a
+ * renderer/process swap), that flag can go stale: a fresh `attach` short-circuits
+ * and reports success without actually re-attaching, so the next CDP command
+ * fails with "Debugger is not attached". A `detach` clears the stale flag (it may
+ * itself throw "not attached" — expected, and ignored), after which `attach`
+ * re-attaches for real. We retry the sequence once on that specific error.
+ */
+export async function withReattach(runtime, tabId, run) {
+  await runtime.request("attach", { tabId });
+  try {
+    return await run();
+  } catch (error) {
+    if (!isNotAttachedError(error)) throw error;
+    try {
+      await runtime.request("detach", { tabId });
+    } catch {
+      // Detach throws when the debugger is already gone; we only need its side
+      // effect of clearing the extension's stale attach flag.
+    }
+    await runtime.request("attach", { tabId });
+    return await run();
+  }
+}
+
+export function isNotAttachedError(error) {
+  return /not attached/i.test(error?.message ?? String(error ?? ""));
+}
+
 async function executeCdp(runtime, { tabId, method, params = {}, timeoutMs }) {
   return await runtime.request(
     "executeCdp",