codex-control-chrome-mcp 1.3.0 → 1.3.2

package/CHANGELOG.md

@@ -6,7 +6,17 @@ This project follows semantic versioning.
 
 ## [Unreleased]
 
-## [1.3.0] - 2026-07-03
+## [1.3.2] - 2026-07-04
+
+### Added
+
+- `codex-control-chrome-mcp --version` (also `-v` and `version`) prints the package name and version. Previously the CLI had no way to report its own version, so `-v`/`--version` fell through to `Unknown command`.
+
+## [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.2",
   "description": "MCP server and native host bridge for controlling Chrome through the Codex Chrome extension.",
   "license": "MIT",
   "type": "module",

package/src/cli.js

@@ -10,6 +10,7 @@ import {
 import { DEFAULT_BROWSER, SUPPORTED_BROWSERS } from "./constants.js";
 import { listBridgeSockets } from "./bridge-client.js";
 import { probeLengthPrefixedSocket } from "./probe.js";
+import { PACKAGE_NAME, PACKAGE_VERSION } from "./package-meta.js";
 
 export async function runCli(argv) {
   const args = argv.slice(2);
@@ -65,6 +66,11 @@ export async function runCli(argv) {
       printJson(await probeLengthPrefixedSocket(socketPath));
       return;
     }
+    case "version":
+    case "--version":
+    case "-v":
+      process.stdout.write(`${PACKAGE_NAME} ${PACKAGE_VERSION}\n`);
+      return;
     case "help":
     case "--help":
     case "-h":
@@ -157,6 +163,7 @@ Usage:
   codex-control-chrome-mcp uninstall-native-host [--force] [--browser <chrome|edge|all>]
   codex-control-chrome-mcp status [--browser <chrome|edge|all>]
   codex-control-chrome-mcp probe-socket <socket-path>
+  codex-control-chrome-mcp --version
 
 Notes:
   --stdio is the MCP server mode for Agent tools.

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",