codex-control-chrome-mcp 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -6,6 +6,19 @@ 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

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,7 +161,7 @@ node ./bin/codex-control-chrome-mcp.js --native-host
 
 ## Troubleshooting
 
-`status` reports 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 the 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.
+`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
 

package/docs/install.md

@@ -24,35 +24,47 @@ 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`.
+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
@@ -70,16 +82,18 @@ When choosing the proxy target it prefers the **live** manifest (most up to date
 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 path on macOS:
+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
@@ -120,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:
 
@@ -134,11 +148,13 @@ 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
 
@@ -167,8 +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 `registered`. If it is `false` and `classification.kind` is `official-openai`, a Codex update reclaimed the manifest. The stdio server re-asserts it on next startup; reload the extension or restart Chrome 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 your local launcher) and the extension just needs to connect.
+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.1.0",
+  "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/installer.js

@@ -1,11 +1,14 @@
 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 {
@@ -18,14 +21,20 @@ import {
 } from "./host-identity.js";
 import { PACKAGE_NAME, PACKAGE_VERSION } from "./package-meta.js";
 
-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
@@ -55,6 +64,7 @@ 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,
@@ -113,7 +123,10 @@ async function resolveOfficialHostPath({ existing, existingIsOurs, previousState
  * 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({ paths = defaultInstallPaths() } = {}) {
+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") {
@@ -144,7 +157,11 @@ export async function ensureNativeHostRegistered({ paths = defaultInstallPaths()
   };
 }
 
-export async function uninstallNativeHost({ force = false, paths = defaultInstallPaths() } = {}) {
+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);
@@ -168,8 +185,11 @@ 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);
   const classification = await classifyHost({ manifest, hostPath: manifest?.path });
@@ -178,15 +198,47 @@ export async function nativeHostInstallStatus() {
     typeof state?.hostPath === "string" &&
     typeof manifest?.path === "string" &&
     path.resolve(manifest.path) === path.resolve(state.hostPath);
-  return { manifestPath, manifest, state, registered, classification };
+  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;
 }
 
-function defaultInstallPaths() {
+/** 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(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),
   };
 }
 
@@ -200,29 +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;
 }
 
-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,8 +3,8 @@ 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 { ensureNativeHostRegistered } from "./installer.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() {
@@ -32,21 +32,34 @@ export async function runMcpServer() {
  */
 async function autoRegisterNativeHost() {
   if (process.env.CODEX_CONTROL_CHROME_NO_AUTO_REGISTER === "1") return;
+  let browsers = [];
   try {
-    const result = await ensureNativeHostRegistered();
-    if (result.action === "re-registered") {
+    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] native host manifest was ${result.reason}; re-registered it. ` +
-          "Reload the Codex Chrome extension (or restart Chrome) to reconnect the bridge.\n",
+        `[codex-control-chrome-mcp] auto-register (${browser}) skipped: ${error?.message ?? error}\n`,
       );
     }
-  } catch (error) {
-    process.stderr.write(
-      `[codex-control-chrome-mcp] auto-register skipped: ${error?.message ?? error}\n`,
-    );
   }
 }
 
+function browserLabel(browser) {
+  return browser === "edge" ? "Edge" : "Chrome";
+}
+
 class ChromeUseRuntime {
   constructor() {
     this.sessionId = `codex-control-chrome-mcp-${crypto.randomUUID()}`;
@@ -83,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;