codex-control-chrome-mcp 1.0.1 → 1.2.0

package/CHANGELOG.md

@@ -6,6 +6,31 @@ This project follows semantic versioning.
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-06-29
+
+### Added
+
+- Microsoft Edge support as a first-class browser alongside Chrome. `install-native-host`, `uninstall-native-host`, and `status` accept `--browser <chrome|edge|all>`.
+- Auto-detection: without `--browser`, `install-native-host` installs for every supported browser whose profile directory exists, `uninstall-native-host` targets every browser it previously installed for, and `status` reports both browsers.
+- The MCP stdio server's self-heal now re-asserts the manifest for every browser it manages, not just Chrome.
+
+### Changed
+
+- Native host install state is now stored per browser (`install-state.<browser>.json` / `config.<browser>.json`). Chrome keeps the original unsuffixed filenames, so existing installs remain valid; Edge no longer clobbers Chrome's restore and self-heal metadata.
+- `status` output now nests install state under each browser (`install.chrome`, `install.edge`). The `chrome_status` MCP tool additionally reports `manifestPaths` for every supported browser.
+
+## [1.1.0] - 2026-06-27
+
+### Added
+
+- Self-healing native host registration: the MCP stdio server re-asserts the manifest on startup when a Codex update reverts it (opt out with `CODEX_CONTROL_CHROME_NO_AUTO_REGISTER=1`).
+- Robust identification of OpenAI's genuine host via stable signals (manifest name + extension origin, bundle path, binary format, and the macOS OpenAI code signature) instead of the binary filename.
+- `status` now reports `registered` and a `classification` of the live manifest/host.
+
+### Fixed
+
+- Proxy target resolution preferred a stale recorded path over the live manifest, so a renamed/removed official host (e.g. `extension-host` → `Codex for Chrome`) could be recorded as the proxy target. It now prefers the live official manifest and skips paths that no longer exist.
+
 ## [1.0.1] - 2026-06-26
 
 ### Added

package/README.md

@@ -20,7 +20,7 @@ This is an independent community project. It is not affiliated with OpenAI, Code
 The current implementation provides:
 
 - official `@modelcontextprotocol/sdk` stdio server
-- Chrome Native Messaging host mode
+- Chrome and Microsoft Edge Native Messaging host mode
 - install/uninstall commands with manifest backup
 - JSON-RPC bridge socket under `/tmp/codex-browser-use`
 - Chrome tab, navigation, screenshot, CDP, and event MCP tools
@@ -36,16 +36,33 @@ The current implementation provides:
 
 Node.js 20 or newer is required. npm Trusted Publishing for releases uses Node.js 24 in GitHub Actions.
 
+## Browser Support
+
+Both Chromium browsers use the same Codex extension and the same `chrome-extension://` origin, so a single manifest works for either.
+
+| Browser | Status | Notes |
+| --- | --- | --- |
+| Google Chrome | Tested | Default target. |
+| Microsoft Edge | Supported | Same extension and native-messaging mechanism; installs to the Edge `NativeMessagingHosts` directory. |
+
+Commands accept `--browser <chrome\|edge\|all>`. Without the flag, `install-native-host` installs for every supported browser whose profile directory exists, `uninstall-native-host` targets every browser it previously installed for, and `status` reports both.
+
 ## Quick Start
 
-Install and enable the [Codex Chrome Extension](https://chromewebstore.google.com/detail/hehggadaopoacecdllhhajmbjkdcmajg) in the Chrome profile you want to automate.
+Install and enable the [Codex Chrome Extension](https://chromewebstore.google.com/detail/hehggadaopoacecdllhhajmbjkdcmajg) in the Chrome or Edge profile you want to automate.
 
-Install the Chrome native host:
+Install the native host (auto-detects the browsers present):
 
 ```bash
 npx -y codex-control-chrome-mcp@latest install-native-host
 ```
 
+To target one browser explicitly:
+
+```bash
+npx -y codex-control-chrome-mcp@latest install-native-host --browser edge
+```
+
 Configure your Agent to use the MCP stdio server:
 
 ```json
@@ -144,6 +161,14 @@ node ./bin/codex-control-chrome-mcp.js --native-host
 
 ## Troubleshooting
 
+`status` reports, per browser (under `install.chrome` / `install.edge`), a `registered` flag and a `classification` of the live manifest. When `registered` is `false` and `classification.kind` is `official-openai`, a Codex update has reclaimed that browser's manifest (see below). `classification` identifies OpenAI's genuine host by stable signals — the `com.openai.codexextension` name, the official extension origin, the bundle path, the binary format, and (on macOS) the OpenAI code signature — not by filename.
+
+### A Codex update stopped the bridge
+
+Codex App/extension updates re-register their own `com.openai.codexextension` native-messaging manifest, which overwrites this project's proxy registration (the bundled host binary has even been renamed across releases). The symptom is `status` showing `sockets: []`, `registered: false`, and a manifest `path` back inside the Codex bundle.
+
+The MCP stdio server now **self-heals**: on startup it re-asserts the manifest when it detects it was reverted, so you usually do not need to re-run `install-native-host`. Because Chrome only reads the manifest when the extension reconnects, **reload the Codex Chrome Extension (or restart Chrome) once** after a Codex update to bring the bridge back. Set `CODEX_CONTROL_CHROME_NO_AUTO_REGISTER=1` to disable the auto re-register.
+
 If `status` shows no bridge sockets, reload Chrome or the Codex Chrome Extension after installing the native host.
 
 If Codex App integration stops working, uninstall this native host to restore the backed-up manifest:

package/docs/install.md

@@ -24,47 +24,76 @@ This is an independent community project. It is not affiliated with OpenAI, Code
 | Platform | Status | Notes |
 | --- | --- | --- |
 | macOS | Tested | Primary supported platform. |
-| Linux | Experimental | Uses the Google Chrome user-level Native Messaging host directory. |
-| Windows | Unsupported | Chrome Native Messaging registration uses registry keys on Windows and is not implemented yet. |
+| Linux | Experimental | Uses the browser's user-level Native Messaging host directory. |
+| Windows | Unsupported | Native Messaging registration uses registry keys on Windows and is not implemented yet. |
+
+## Browser Support
+
+| Browser | Status | Notes |
+| --- | --- | --- |
+| Google Chrome | Tested | Default target. |
+| Microsoft Edge | Supported | Same Codex extension and `chrome-extension://` origin; installs to Edge's `NativeMessagingHosts` directory. |
+
+Commands accept `--browser <chrome|edge|all>`. Without it, `install-native-host` auto-detects the browsers present on the machine, `uninstall-native-host` targets every browser it previously installed for, and `status` reports both browsers.
 
 ## Install
 
-First install and enable the [Codex Chrome Extension](https://chromewebstore.google.com/detail/hehggadaopoacecdllhhajmbjkdcmajg) in the Chrome profile you want to automate.
+First install and enable the [Codex Chrome Extension](https://chromewebstore.google.com/detail/hehggadaopoacecdllhhajmbjkdcmajg) in the Chrome or Edge profile you want to automate.
 
 ```bash
 npx -y codex-control-chrome-mcp@latest install-native-host
 ```
 
-This writes a stable launcher:
+Without `--browser`, this installs for every supported browser whose profile directory exists. Pass `--browser <chrome|edge|all>` to target one explicitly.
+
+This writes a stable per-browser launcher (Edge uses the `-edge` suffix):
 
 ```text
 ~/.codex-control-chrome-mcp/native-host-launcher
+~/.codex-control-chrome-mcp/native-host-launcher-edge
 ```
 
-The launcher invokes:
+The launcher invokes (the `--browser` flag tells the host which browser's config to read for proxy mode):
 
 ```bash
-npx -y codex-control-chrome-mcp@1.0.0 --native-host "$@"
+npx -y codex-control-chrome-mcp@latest --native-host --browser chrome "$@"
 ```
 
-The installer:
+For each selected browser the installer:
 
-1. Reads the existing `com.openai.codexextension.json`.
+1. Reads the existing `com.openai.codexextension.json` in that browser's directory.
 2. Backs it up in the same directory with a timestamped suffix.
 3. Writes a new manifest pointing to this project's CLI.
-4. Records restore metadata in `~/.codex-control-chrome-mcp/install-state.json`.
-5. Records the previous host path for proxy mode when available.
+4. Records restore metadata in `~/.codex-control-chrome-mcp/install-state.json` (Chrome) or `install-state.<browser>.json` (other browsers), so browsers never clobber each other's state.
+5. Records the genuine OpenAI host path for proxy mode when available.
+
+### Identifying the official host
+
+The installer identifies OpenAI's genuine host with stable signals instead of the
+binary filename (OpenAI has renamed it across releases, e.g. `extension-host` →
+`Codex for Chrome`):
+
+- the manifest `name` (`com.openai.codexextension`) and the official extension origin,
+- the bundle directory structure (`.../openai-bundled/.../extension-host/...`),
+- the binary format (a compiled Mach-O/ELF executable, not a shell script),
+- on macOS, the OpenAI code signature (Developer ID Team `2DC432GLL2`).
 
-Example manifest path on macOS:
+When choosing the proxy target it prefers the **live** manifest (most up to date) and
+skips paths that no longer exist, so a renamed or removed host is never recorded as the
+official target. `status` reports these signals under `classification`.
+
+Example manifest paths on macOS:
 
 ```text
 ~/Library/Application Support/Google/Chrome/NativeMessagingHosts/com.openai.codexextension.json
+~/Library/Application Support/Microsoft Edge/NativeMessagingHosts/com.openai.codexextension.json
 ```
 
-Example manifest path on Linux:
+Example manifest paths on Linux:
 
 ```text
 ~/.config/google-chrome/NativeMessagingHosts/com.openai.codexextension.json
+~/.config/microsoft-edge/NativeMessagingHosts/com.openai.codexextension.json
 ```
 
 ## MCP Client Config
@@ -105,7 +134,7 @@ For local development:
 npx -y codex-control-chrome-mcp@latest uninstall-native-host
 ```
 
-This restores the backed-up official manifest if one was recorded.
+This restores the backed-up official manifest if one was recorded. Without `--browser` it uninstalls from every browser it previously installed for; pass `--browser <chrome|edge|all>` to scope it.
 
 Use `--force` only if the current manifest was manually edited and you still want to restore/remove it:
 
@@ -119,16 +148,28 @@ npx -y codex-control-chrome-mcp@latest uninstall-native-host --force
 npx -y codex-control-chrome-mcp@latest status
 ```
 
-This prints:
+This prints, per browser under `install.chrome` / `install.edge`:
 
 - active native host manifest
 - saved install state
-- discovered bridge sockets under `/tmp/codex-browser-use`
+- the `registered` flag and live-manifest `classification`
+
+and the discovered bridge sockets under `/tmp/codex-browser-use`. Pass `--browser` to scope it to one browser.
 
 ## Operational Notes
 
 Chrome launches the native host only when the extension connects. If no bridge socket is visible, reload Chrome or the Codex extension after installing the manifest.
 
+### Auto re-register after Codex updates
+
+A Codex App/extension update re-registers its own `com.openai.codexextension` manifest and reverts this project's proxy registration. To avoid a manual repair each time, the MCP stdio server re-asserts the manifest on startup when it detects it was reverted (only if it was installed before — it never bootstraps a fresh install silently). Logs go to stderr only.
+
+Re-asserting the manifest takes effect on the extension's **next** Native Messaging connection, so reload the Codex Chrome Extension or restart Chrome once after a Codex update. Disable this behavior with:
+
+```bash
+CODEX_CONTROL_CHROME_NO_AUTO_REGISTER=1
+```
+
 If the extension is missing, install the [Codex Chrome Extension](https://chromewebstore.google.com/detail/hehggadaopoacecdllhhajmbjkdcmajg) from Chrome Web Store and enable it in the target Chrome profile.
 
 Stopping the MCP stdio process does not uninstall the native host. Uninstall explicitly to restore the original manifest.
@@ -142,7 +183,8 @@ If `status` shows no sockets:
 1. Confirm Chrome is running with the profile where the extension is installed.
 2. Reload or disable/enable the Codex Chrome Extension.
 3. Run `npx -y codex-control-chrome-mcp@latest status`.
-4. Check that the active manifest path points to `~/.codex-control-chrome-mcp/native-host-launcher`.
+4. Check `install.<browser>.registered`. If it is `false` and `classification.kind` is `official-openai`, a Codex update reclaimed that browser's manifest. The stdio server re-asserts it on next startup; reload the extension or restart the browser to reconnect (or run `install-native-host` to repair immediately).
+5. When `registered` is `true`, the active manifest points to `~/.codex-control-chrome-mcp/native-host-launcher` (or the `-edge` variant, or your local launcher) and the extension just needs to connect.
 
 If Codex App integration is affected, uninstall this project:
 

package/package.json

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

package/src/cli.js

@@ -1,6 +1,13 @@
 import { runMcpServer } from "./mcp-server.js";
 import { runNativeHost } from "./native-host.js";
-import { installNativeHost, nativeHostInstallStatus, uninstallNativeHost } from "./installer.js";
+import {
+  detectInstalledBrowsers,
+  detectManagedBrowsers,
+  installNativeHost,
+  nativeHostInstallStatus,
+  uninstallNativeHost,
+} from "./installer.js";
+import { DEFAULT_BROWSER, SUPPORTED_BROWSERS } from "./constants.js";
 import { listBridgeSockets } from "./bridge-client.js";
 import { probeLengthPrefixedSocket } from "./probe.js";
 
@@ -14,7 +21,10 @@ export async function runCli(argv) {
   }
 
   if (args.includes("--native-host") || looksLikeChromeOrigin(command)) {
-    await runNativeHost({ origin: looksLikeChromeOrigin(command) ? command : argv[3] });
+    // Chrome/Edge append the extension origin as a positional arg, so find it
+    // by shape rather than position (the `--browser` flag shifts the indices).
+    const origin = args.find(looksLikeChromeOrigin) ?? argv[3];
+    await runNativeHost({ origin, browser: normalizeBrowser(readOption(args, "--browser")) });
     return;
   }
 
@@ -22,20 +32,31 @@ export async function runCli(argv) {
     case "install-native-host": {
       const binPath = readOption(args, "--bin");
       const noProxy = args.includes("--no-proxy");
-      const result = await installNativeHost({ binPath, proxy: !noProxy });
+      const browsers = await resolveBrowsers(readOption(args, "--browser"), "install");
+      const result = {};
+      for (const browser of browsers) {
+        result[browser] = await installNativeHost({ binPath, proxy: !noProxy, browser });
+      }
       printJson(result);
       return;
     }
     case "uninstall-native-host": {
-      const result = await uninstallNativeHost({ force: args.includes("--force") });
+      const force = args.includes("--force");
+      const browsers = await resolveBrowsers(readOption(args, "--browser"), "uninstall");
+      const result = {};
+      for (const browser of browsers) {
+        result[browser] = await uninstallNativeHost({ force, browser });
+      }
       printJson(result);
       return;
     }
     case "status": {
-      printJson({
-        install: await nativeHostInstallStatus(),
-        sockets: await listBridgeSockets(),
-      });
+      const browsers = await resolveBrowsers(readOption(args, "--browser"), "status");
+      const install = {};
+      for (const browser of browsers) {
+        install[browser] = await nativeHostInstallStatus({ browser });
+      }
+      printJson({ install, sockets: await listBridgeSockets() });
       return;
     }
     case "probe-socket": {
@@ -66,6 +87,39 @@ function readOption(args, name) {
   return index >= 0 ? args[index + 1] : undefined;
 }
 
+function normalizeBrowser(value) {
+  if (value == null) return DEFAULT_BROWSER;
+  const browser = String(value).toLowerCase();
+  if (!SUPPORTED_BROWSERS.includes(browser)) {
+    throw new Error(
+      `Unsupported browser: ${value}. Supported values: ${SUPPORTED_BROWSERS.join(", ")}, all.`,
+    );
+  }
+  return browser;
+}
+
+/**
+ * Map an optional `--browser` selector to the list of browsers a command acts
+ * on. With no selector each command auto-detects: install targets browsers
+ * present on the machine, uninstall targets browsers we previously installed,
+ * and status reports every supported browser.
+ */
+async function resolveBrowsers(selector, mode) {
+  if (selector && selector !== "all") {
+    return [normalizeBrowser(selector)];
+  }
+  if (selector === "all" || mode === "status") {
+    return [...SUPPORTED_BROWSERS];
+  }
+  if (mode === "install") {
+    const present = await detectInstalledBrowsers();
+    return present.length ? present : [DEFAULT_BROWSER];
+  }
+  // uninstall
+  const managed = await detectManagedBrowsers();
+  return managed.length ? managed : [DEFAULT_BROWSER];
+}
+
 function printJson(value) {
   process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
@@ -76,14 +130,16 @@ function printHelp() {
 Usage:
   codex-control-chrome-mcp --stdio
   codex-control-chrome-mcp --native-host
-  codex-control-chrome-mcp install-native-host [--bin /path/to/codex-control-chrome-mcp] [--no-proxy]
-  codex-control-chrome-mcp uninstall-native-host [--force]
-  codex-control-chrome-mcp status
+  codex-control-chrome-mcp install-native-host [--bin /path/to/codex-control-chrome-mcp] [--no-proxy] [--browser <chrome|edge|all>]
+  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>
 
 Notes:
   --stdio is the MCP server mode for Agent tools.
-  --native-host is normally launched by Chrome through Native Messaging.
+  --native-host is normally launched by Chrome/Edge through Native Messaging.
   install-native-host without --bin writes a stable launcher that runs npx.
+  --browser selects a browser. Without it, install/uninstall auto-detect the
+  browsers present (or previously installed) and status reports both.
 `);
 }

package/src/constants.js

@@ -10,38 +10,61 @@ export const APP_STATE_DIR = path.join(os.homedir(), ".codex-control-chrome-mcp"
 export const APP_CONFIG_PATH = path.join(APP_STATE_DIR, "config.json");
 export const INSTALL_STATE_PATH = path.join(APP_STATE_DIR, "install-state.json");
 
-export function nativeHostManifestPath() {
-  const home = os.homedir();
-  switch (process.platform) {
-    case "darwin":
-      return path.join(
-        home,
-        "Library",
-        "Application Support",
-        "Google",
-        "Chrome",
-        "NativeMessagingHosts",
-        `${CODEX_NATIVE_HOST_NAME}.json`,
-      );
-    case "linux":
-      return path.join(
-        home,
-        ".config",
-        "google-chrome",
-        "NativeMessagingHosts",
-        `${CODEX_NATIVE_HOST_NAME}.json`,
-      );
-    case "win32":
-      return path.join(
-        home,
-        "AppData",
-        "Local",
-        "Google",
-        "Chrome",
-        "NativeMessagingHosts",
-        `${CODEX_NATIVE_HOST_NAME}.json`,
-      );
-    default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
+// Chromium browsers that ship the Codex extension and use the same Native
+// Messaging mechanism. Edge installs Chrome Web Store extensions under the
+// same `chrome-extension://<id>` origin, so one manifest works for both.
+export const DEFAULT_BROWSER = "chrome";
+export const SUPPORTED_BROWSERS = ["chrome", "edge"];
+
+// Per-platform location of each browser's user profile directory. The Native
+// Messaging host manifest lives in a `NativeMessagingHosts` subdirectory, and
+// the profile directory's existence is our "is this browser installed" signal.
+// (On Windows native hosts are registered through the registry, not a file in
+// this directory, which is why Windows is unsupported for now.)
+const BROWSER_PROFILE_SEGMENTS = {
+  chrome: {
+    darwin: ["Library", "Application Support", "Google", "Chrome"],
+    linux: [".config", "google-chrome"],
+    win32: ["AppData", "Local", "Google", "Chrome"],
+  },
+  edge: {
+    darwin: ["Library", "Application Support", "Microsoft Edge"],
+    linux: [".config", "microsoft-edge"],
+    win32: ["AppData", "Local", "Microsoft", "Edge"],
+  },
+};
+
+export function browserProfileDir(browser = DEFAULT_BROWSER) {
+  const perPlatform = BROWSER_PROFILE_SEGMENTS[browser];
+  if (!perPlatform) {
+    throw new Error(`Unsupported browser: ${browser}`);
+  }
+  const segments = perPlatform[process.platform];
+  if (!segments) {
+    throw new Error(`Unsupported platform: ${process.platform}`);
   }
+  return path.join(os.homedir(), ...segments);
+}
+
+export function nativeHostManifestPath(browser = DEFAULT_BROWSER) {
+  return path.join(
+    browserProfileDir(browser),
+    "NativeMessagingHosts",
+    `${CODEX_NATIVE_HOST_NAME}.json`,
+  );
+}
+
+// Chrome keeps the original unsuffixed state filenames so installs from before
+// multi-browser support remain valid; other browsers get a per-browser suffix
+// so a second install never clobbers the first one's restore/self-heal metadata.
+export function configPathFor(browser = DEFAULT_BROWSER) {
+  return browser === DEFAULT_BROWSER
+    ? APP_CONFIG_PATH
+    : path.join(APP_STATE_DIR, `config.${browser}.json`);
+}
+
+export function installStatePathFor(browser = DEFAULT_BROWSER) {
+  return browser === DEFAULT_BROWSER
+    ? INSTALL_STATE_PATH
+    : path.join(APP_STATE_DIR, `install-state.${browser}.json`);
 }

package/src/host-identity.js

@@ -0,0 +1,126 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { APP_STATE_DIR, CODEX_EXTENSION_ID, CODEX_NATIVE_HOST_NAME } from "./constants.js";
+
+// Description we stamp on manifests we own. Used as one (not the only) signal.
+export const MANIFEST_DESCRIPTION = "Codex Control Chrome MCP native messaging host";
+
+/** A manifest this project wrote (description marker, or path inside our state dir). */
+export function isProjectManifest(manifest) {
+  if (!manifest || typeof manifest !== "object") return false;
+  if (manifest.description === MANIFEST_DESCRIPTION) return true;
+  return isOurLauncherPath(manifest.path);
+}
+
+/** True when a host path points at a launcher we generated under APP_STATE_DIR. */
+export function isOurLauncherPath(hostPath) {
+  if (typeof hostPath !== "string" || hostPath.length === 0) return false;
+  const resolved = path.resolve(hostPath);
+  const stateRoot = path.resolve(APP_STATE_DIR) + path.sep;
+  return resolved === path.resolve(APP_STATE_DIR) || resolved.startsWith(stateRoot);
+}
+
+/**
+ * Positive identification of OpenAI's genuine Codex native-host *manifest*,
+ * using stable identifiers (host name + the official extension id) rather than
+ * the binary filename (which OpenAI has renamed across releases).
+ */
+export function isOfficialCodexManifest(manifest) {
+  if (!manifest || typeof manifest !== "object") return false;
+  if (isProjectManifest(manifest)) return false;
+  if (manifest.name !== CODEX_NATIVE_HOST_NAME) return false;
+  const origins = Array.isArray(manifest.allowed_origins) ? manifest.allowed_origins : [];
+  return origins.some((origin) => originMatchesCodexExtension(origin));
+}
+
+function originMatchesCodexExtension(origin) {
+  return typeof origin === "string" && origin.includes(`chrome-extension://${CODEX_EXTENSION_ID}`);
+}
+
+/** Stable directory-structure signature of the bundled Codex host (filename-agnostic). */
+export function hostPathLooksOfficial(hostPath) {
+  if (typeof hostPath !== "string" || hostPath.length === 0) return false;
+  const normalized = path.resolve(hostPath).split(path.sep).join("/").toLowerCase();
+  return normalized.includes("/openai-bundled/") && normalized.includes("/extension-host/");
+}
+
+const MAGIC = {
+  "7f454c46": "elf", // ELF
+  feedface: "macho", // Mach-O 32 LE
+  feedfacf: "macho", // Mach-O 64 LE
+  cefaedfe: "macho", // Mach-O 32 BE
+  cffaedfe: "macho", // Mach-O 64 BE
+  cafebabe: "macho", // universal (fat) — also Java .class, acceptable for a host binary
+  bebafeca: "macho",
+};
+
+/** Inspect the host file: does it exist, is it a compiled binary or a shell script? */
+export async function inspectHostBinary(hostPath) {
+  if (typeof hostPath !== "string" || hostPath.length === 0) {
+    return { exists: false, kind: "missing", executable: false };
+  }
+  let handle;
+  try {
+    const stat = await fs.stat(hostPath);
+    if (!stat.isFile()) return { exists: true, kind: "unknown", executable: false };
+    handle = await fs.open(hostPath, "r");
+    const buf = Buffer.alloc(4);
+    const { bytesRead } = await handle.read(buf, 0, 4, 0);
+    const head = buf.subarray(0, bytesRead);
+    let kind = "unknown";
+    if (head.length >= 2 && head[0] === 0x23 && head[1] === 0x21) kind = "script"; // #!
+    else if (head.length === 4 && MAGIC[head.toString("hex")]) kind = MAGIC[head.toString("hex")];
+    else if (head.length >= 2 && head[0] === 0x4d && head[1] === 0x5a) kind = "pe"; // MZ
+    return { exists: true, kind, executable: (stat.mode & 0o111) !== 0 };
+  } catch {
+    return { exists: false, kind: "missing", executable: false };
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}
+
+/** Best-effort macOS code-signature check; the strongest OpenAI signal when available. */
+export function verifyOpenAiCodesign(hostPath) {
+  if (process.platform !== "darwin" || typeof hostPath !== "string" || !hostPath) {
+    return Promise.resolve({ available: false });
+  }
+  return new Promise((resolve) => {
+    execFile("codesign", ["-dvvv", hostPath], { timeout: 4000 }, (error, stdout, stderr) => {
+      const out = `${stdout || ""}${stderr || ""}`; // codesign -d writes to stderr
+      if (!out) return resolve({ available: false, error: error?.message });
+      const teamId = (out.match(/TeamIdentifier=(\S+)/) || [])[1] || null;
+      const authority = (out.match(/Authority=([^\r\n]+)/) || [])[1] || null;
+      const openai = /openai/i.test(out);
+      resolve({ available: true, signed: Boolean(authority), openai, teamId, authority });
+    });
+  });
+}
+
+/**
+ * Full classification of a (manifest, hostPath) pair against stable signals.
+ * `trustedOfficial` means: looks like OpenAI's real host and is safe to back up /
+ * proxy to. We require the manifest-level identity plus at least one host-level
+ * signal (bundle path, compiled binary, or an OpenAI code signature).
+ */
+export async function classifyHost({ manifest, hostPath } = {}) {
+  const resolvedPath = hostPath ?? manifest?.path ?? null;
+  const ours = isProjectManifest(manifest) || isOurLauncherPath(resolvedPath);
+  const officialManifest = isOfficialCodexManifest(manifest);
+  const pathOfficial = hostPathLooksOfficial(resolvedPath);
+  const binary = await inspectHostBinary(resolvedPath);
+  const codesign = await verifyOpenAiCodesign(resolvedPath);
+
+  const hostSignal = pathOfficial || codesign.openai === true || binary.kind === "macho" || binary.kind === "elf";
+  const trustedOfficial = !ours && officialManifest && hostSignal;
+
+  return {
+    ours,
+    officialManifest,
+    pathOfficial,
+    binary,
+    codesign,
+    trustedOfficial,
+    kind: ours ? "ours" : trustedOfficial ? "official-openai" : "unknown",
+  };
+}

package/src/installer.js

@@ -1,25 +1,40 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import {
-  APP_CONFIG_PATH,
   APP_STATE_DIR,
   CODEX_EXTENSION_ID,
   CODEX_NATIVE_HOST_NAME,
-  INSTALL_STATE_PATH,
+  DEFAULT_BROWSER,
+  SUPPORTED_BROWSERS,
+  browserProfileDir,
+  configPathFor,
+  installStatePathFor,
   nativeHostManifestPath,
 } from "./constants.js";
+import {
+  MANIFEST_DESCRIPTION,
+  classifyHost,
+  inspectHostBinary,
+  isOfficialCodexManifest,
+  isOurLauncherPath,
+  isProjectManifest,
+} from "./host-identity.js";
 import { PACKAGE_NAME, PACKAGE_VERSION } from "./package-meta.js";
 
-const MANIFEST_DESCRIPTION = "Codex Control Chrome MCP native messaging host";
-
-export async function installNativeHost({ binPath, proxy = true, paths = defaultInstallPaths() } = {}) {
+export async function installNativeHost({
+  binPath,
+  proxy = true,
+  browser = DEFAULT_BROWSER,
+  paths = defaultInstallPaths(browser),
+} = {}) {
   const { manifestPath, appStateDir, configPath, installStatePath } = paths;
+  const browserId = paths.browser ?? browser;
   await fs.mkdir(path.dirname(manifestPath), { recursive: true });
   await fs.mkdir(appStateDir, { recursive: true });
 
   const hostPath = binPath
-    ? await createLocalLauncher(path.resolve(binPath), appStateDir)
-    : await createNpxLauncher(appStateDir);
+    ? await createLocalLauncher(path.resolve(binPath), appStateDir, browserId)
+    : await createNpxLauncher(appStateDir, browserId);
   const existing = await readJsonIfExists(manifestPath);
   const previousState = await readJsonIfExists(installStatePath);
   const previousBackup = previousState?.backupPath
@@ -34,23 +49,9 @@ export async function installNativeHost({ binPath, proxy = true, paths = default
     backupPath = previousState.backupPath;
   }
 
-  let officialHostPath = null;
-  if (proxy && previousBackup?.path && !previousBackupIsOurs) {
-    officialHostPath = previousBackup.path;
-  } else if (
-    proxy &&
-    typeof previousState?.officialHostPath === "string" &&
-    path.resolve(previousState.officialHostPath) !== path.resolve(hostPath)
-  ) {
-    officialHostPath = previousState.officialHostPath;
-  } else if (
-    proxy &&
-    existing?.path &&
-    !existingIsOurs &&
-    path.resolve(existing.path) !== path.resolve(hostPath)
-  ) {
-    officialHostPath = existing.path;
-  }
+  const officialHostPath = proxy
+    ? await resolveOfficialHostPath({ existing, existingIsOurs, previousState, previousBackup, hostPath })
+    : null;
 
   const manifest = {
     allowed_origins: [`chrome-extension://${CODEX_EXTENSION_ID}/`],
@@ -63,8 +64,10 @@ export async function installNativeHost({ binPath, proxy = true, paths = default
 
   const config = {
     installedAt: new Date().toISOString(),
+    browser: browserId,
     manifestPath,
     hostPath,
+    binPath: binPath ? path.resolve(binPath) : null,
     launchMode: binPath ? "direct-bin" : "npx-launcher",
     backupPath,
     officialHostPath,
@@ -75,7 +78,90 @@ export async function installNativeHost({ binPath, proxy = true, paths = default
   return config;
 }
 
-export async function uninstallNativeHost({ force = false, paths = defaultInstallPaths() } = {}) {
+/**
+ * Resolve the genuine OpenAI host to proxy to. Authority order:
+ *   1. the live manifest, when it is verifiably OpenAI's (most up to date),
+ *   2. the previously recorded official host,
+ *   3. the backed-up manifest's path.
+ * Self-references and our own launcher are dropped, and a candidate whose file
+ * still exists is preferred so a renamed/removed host (e.g. after a Codex
+ * update) never gets recorded as the official target.
+ */
+async function resolveOfficialHostPath({ existing, existingIsOurs, previousState, previousBackup, hostPath }) {
+  const candidates = [];
+  if (existing?.path && !existingIsOurs && isOfficialCodexManifest(existing)) {
+    candidates.push(existing.path);
+  }
+  if (typeof previousState?.officialHostPath === "string") {
+    candidates.push(previousState.officialHostPath);
+  }
+  if (previousBackup?.path && !isProjectManifest(previousBackup)) {
+    candidates.push(previousBackup.path);
+  }
+
+  const seen = new Set();
+  const unique = [];
+  for (const candidate of candidates) {
+    const resolved = path.resolve(candidate);
+    if (resolved === path.resolve(hostPath) || isOurLauncherPath(candidate) || seen.has(resolved)) {
+      continue;
+    }
+    seen.add(resolved);
+    unique.push(candidate);
+  }
+
+  for (const candidate of unique) {
+    if ((await inspectHostBinary(candidate)).exists) return candidate;
+  }
+  // None of the candidates exist on disk; fall back to the most authoritative
+  // one (the live official manifest) for diagnostics rather than inventing null.
+  return unique[0] ?? null;
+}
+
+/**
+ * Idempotently re-assert a previously-established install. Used on stdio
+ * startup so a Codex update that reclaims the manifest self-heals without a
+ * manual `install-native-host`. Never bootstraps a fresh install silently.
+ */
+export async function ensureNativeHostRegistered({
+  browser = DEFAULT_BROWSER,
+  paths = defaultInstallPaths(browser),
+} = {}) {
+  const { manifestPath, installStatePath } = paths;
+  const state = await readJsonIfExists(installStatePath);
+  if (!state || typeof state.hostPath !== "string") {
+    return { action: "skip", reason: "not-installed" };
+  }
+
+  const manifest = await readJsonIfExists(manifestPath);
+  const pointsToUs =
+    isProjectManifest(manifest) &&
+    typeof manifest?.path === "string" &&
+    path.resolve(manifest.path) === path.resolve(state.hostPath);
+  const launcherExists = (await inspectHostBinary(state.hostPath)).exists;
+  if (pointsToUs && launcherExists) {
+    return { action: "ok", reason: "already-registered" };
+  }
+
+  const result = await installNativeHost({
+    binPath: state.launchMode === "direct-bin" ? state.binPath ?? undefined : undefined,
+    proxy: state.proxy !== false,
+    paths,
+  });
+  return {
+    action: "re-registered",
+    reason: launcherExists ? "manifest-reverted" : "launcher-missing",
+    manifestPath,
+    hostPath: result.hostPath,
+    officialHostPath: result.officialHostPath,
+  };
+}
+
+export async function uninstallNativeHost({
+  force = false,
+  browser = DEFAULT_BROWSER,
+  paths = defaultInstallPaths(browser),
+} = {}) {
   const { manifestPath, installStatePath } = paths;
   const state = await readJsonIfExists(installStatePath);
   const manifest = await readJsonIfExists(manifestPath);
@@ -99,19 +185,60 @@ export async function uninstallNativeHost({ force = false, paths = defaultInstal
   return { ok: true, action: "removed", manifestPath };
 }
 
-export async function nativeHostInstallStatus() {
-  const { manifestPath, installStatePath } = defaultInstallPaths();
+export async function nativeHostInstallStatus({
+  browser = DEFAULT_BROWSER,
+  paths = defaultInstallPaths(browser),
+} = {}) {
+  const { manifestPath, installStatePath } = paths;
   const manifest = await readJsonIfExists(manifestPath);
   const state = await readJsonIfExists(installStatePath);
-  return { manifestPath, manifest, state };
+  const classification = await classifyHost({ manifest, hostPath: manifest?.path });
+  const registered =
+    isProjectManifest(manifest) &&
+    typeof state?.hostPath === "string" &&
+    typeof manifest?.path === "string" &&
+    path.resolve(manifest.path) === path.resolve(state.hostPath);
+  return { browser: paths.browser ?? browser, manifestPath, manifest, state, registered, classification };
+}
+
+/** Browsers whose user profile directory exists on this machine (install targets). */
+export async function detectInstalledBrowsers() {
+  const present = [];
+  for (const browser of SUPPORTED_BROWSERS) {
+    let dir;
+    try {
+      dir = browserProfileDir(browser);
+    } catch {
+      continue; // unsupported platform for this browser
+    }
+    try {
+      await fs.access(dir);
+      present.push(browser);
+    } catch {
+      // profile directory absent -> browser not installed (or never launched)
+    }
+  }
+  return present;
+}
+
+/** Browsers we have previously installed for (an install-state file exists). */
+export async function detectManagedBrowsers() {
+  const managed = [];
+  for (const browser of SUPPORTED_BROWSERS) {
+    if (await readJsonIfExists(installStatePathFor(browser))) {
+      managed.push(browser);
+    }
+  }
+  return managed;
 }
 
-function defaultInstallPaths() {
+function defaultInstallPaths(browser = DEFAULT_BROWSER) {
   return {
-    manifestPath: nativeHostManifestPath(),
+    browser,
+    manifestPath: nativeHostManifestPath(browser),
     appStateDir: APP_STATE_DIR,
-    configPath: APP_CONFIG_PATH,
-    installStatePath: INSTALL_STATE_PATH,
+    configPath: configPathFor(browser),
+    installStatePath: installStatePathFor(browser),
   };
 }
 
@@ -125,33 +252,36 @@ async function backupManifest(manifestPath) {
   return backupPath;
 }
 
-async function createNpxLauncher(appStateDir) {
+// Each browser gets its own launcher so the native host knows which browser's
+// config to read for proxy mode. Chrome keeps the original unsuffixed filename
+// so manifests written before multi-browser support still resolve.
+function launcherFileName(base, browser) {
+  return browser === DEFAULT_BROWSER ? base : `${base}-${browser}`;
+}
+
+async function createNpxLauncher(appStateDir, browser = DEFAULT_BROWSER) {
   if (process.platform === "win32") {
     throw new Error("NPX native host launcher installation is not implemented for Windows yet.");
   }
-  const launcherPath = path.join(appStateDir, "native-host-launcher");
+  const launcherPath = path.join(appStateDir, launcherFileName("native-host-launcher", browser));
   const script = `#!/usr/bin/env sh
-exec npx -y ${PACKAGE_NAME}@${PACKAGE_VERSION} --native-host "$@"
+exec npx -y ${PACKAGE_NAME}@${PACKAGE_VERSION} --native-host --browser ${browser} "$@"
 `;
   await fs.writeFile(launcherPath, script, { encoding: "utf8", mode: 0o755 });
   await fs.chmod(launcherPath, 0o755);
   return launcherPath;
 }
 
-function isProjectManifest(manifest) {
-  return manifest?.description === MANIFEST_DESCRIPTION;
-}
-
-async function createLocalLauncher(binPath, appStateDir) {
+async function createLocalLauncher(binPath, appStateDir, browser = DEFAULT_BROWSER) {
   if (process.platform === "win32") {
     return binPath;
   }
   if (!binPath.endsWith(".js")) {
     return binPath;
   }
-  const launcherPath = path.join(appStateDir, "native-host-local-launcher");
+  const launcherPath = path.join(appStateDir, launcherFileName("native-host-local-launcher", browser));
   const script = `#!/usr/bin/env sh
-exec ${shellQuote(process.execPath)} ${shellQuote(binPath)} "$@"
+exec ${shellQuote(process.execPath)} ${shellQuote(binPath)} --browser ${browser} "$@"
 `;
   await fs.writeFile(launcherPath, script, { encoding: "utf8", mode: 0o755 });
   await fs.chmod(launcherPath, 0o755);

package/src/mcp-server.js

@@ -3,10 +3,12 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { connectBridge, listBridgeSockets } from "./bridge-client.js";
-import { nativeHostManifestPath } from "./constants.js";
+import { SUPPORTED_BROWSERS, nativeHostManifestPath } from "./constants.js";
+import { detectManagedBrowsers, ensureNativeHostRegistered } from "./installer.js";
 import { PACKAGE_NAME, PACKAGE_VERSION } from "./package-meta.js";
 
 export async function runMcpServer() {
+  await autoRegisterNativeHost();
   const runtime = new ChromeUseRuntime();
   const server = new McpServer({
     name: PACKAGE_NAME,
@@ -19,6 +21,45 @@ export async function runMcpServer() {
   await server.connect(transport);
 }
 
+/**
+ * On stdio startup, re-assert our native-host manifest if a Codex update (or
+ * anything else) reverted it. Best-effort and silent: it only logs to stderr
+ * (stdout is the MCP JSON-RPC channel) and never blocks server startup.
+ * Opt out with CODEX_CONTROL_CHROME_NO_AUTO_REGISTER=1.
+ *
+ * Note: re-asserting the manifest only takes effect on the Chrome extension's
+ * next Native Messaging connection (reload the extension or restart Chrome).
+ */
+async function autoRegisterNativeHost() {
+  if (process.env.CODEX_CONTROL_CHROME_NO_AUTO_REGISTER === "1") return;
+  let browsers = [];
+  try {
+    browsers = await detectManagedBrowsers();
+  } catch {
+    browsers = [];
+  }
+  for (const browser of browsers) {
+    try {
+      const result = await ensureNativeHostRegistered({ browser });
+      if (result.action === "re-registered") {
+        process.stderr.write(
+          `[codex-control-chrome-mcp] native host manifest for ${browser} was ${result.reason}; ` +
+            `re-registered it. Reload the Codex extension (or restart ${browserLabel(browser)}) ` +
+            "to reconnect the bridge.\n",
+        );
+      }
+    } catch (error) {
+      process.stderr.write(
+        `[codex-control-chrome-mcp] auto-register (${browser}) skipped: ${error?.message ?? error}\n`,
+      );
+    }
+  }
+}
+
+function browserLabel(browser) {
+  return browser === "edge" ? "Edge" : "Chrome";
+}
+
 class ChromeUseRuntime {
   constructor() {
     this.sessionId = `codex-control-chrome-mcp-${crypto.randomUUID()}`;
@@ -55,11 +96,14 @@ function registerTools(server, runtime) {
   server.registerTool(
     "chrome_status",
     {
-      description: "Show native host manifest path and discovered bridge sockets.",
+      description: "Show native host manifest paths and discovered bridge sockets.",
       inputSchema: {},
     },
     async () => toolResult({
       manifestPath: nativeHostManifestPath(),
+      manifestPaths: Object.fromEntries(
+        SUPPORTED_BROWSERS.map((browser) => [browser, nativeHostManifestPath(browser)]),
+      ),
       sockets: await listBridgeSockets(),
     }),
   );

package/src/native-host.js

@@ -3,12 +3,17 @@ import fs from "node:fs/promises";
 import net from "node:net";
 import path from "node:path";
 import { spawn } from "node:child_process";
-import { APP_CONFIG_PATH, BRIDGE_SOCKET_DIR, BRIDGE_SOCKET_PREFIX } from "./constants.js";
+import {
+  BRIDGE_SOCKET_DIR,
+  BRIDGE_SOCKET_PREFIX,
+  DEFAULT_BROWSER,
+  configPathFor,
+} from "./constants.js";
 import { LengthPrefixedJsonPeer } from "./framing.js";
 
 const LOCAL_ID_PREFIX = "codex-control-chrome-mcp:";
 
-export async function runNativeHost({ origin = process.argv[2] } = {}) {
+export async function runNativeHost({ origin = process.argv[2], browser = DEFAULT_BROWSER } = {}) {
   await fs.mkdir(BRIDGE_SOCKET_DIR, { recursive: true });
   const socketPath = path.join(
     BRIDGE_SOCKET_DIR,
@@ -21,7 +26,7 @@ export async function runNativeHost({ origin = process.argv[2] } = {}) {
     name: "chrome-extension",
   });
 
-  const proxyPeer = await maybeStartOfficialProxy(origin);
+  const proxyPeer = await maybeStartOfficialProxy(origin, browser);
   const bridge = new NativeHostBridge({ extensionPeer, proxyPeer });
   await bridge.listen(socketPath);
 
@@ -201,8 +206,8 @@ class NativeHostBridge {
   }
 }
 
-async function maybeStartOfficialProxy(origin) {
-  const config = await readJsonIfExists(APP_CONFIG_PATH);
+async function maybeStartOfficialProxy(origin, browser = DEFAULT_BROWSER) {
+  const config = await readJsonIfExists(configPathFor(browser));
   const officialHostPath = config?.officialHostPath;
   if (typeof officialHostPath !== "string" || officialHostPath.length === 0) {
     return null;