codex-control-chrome-mcp 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -6,6 +6,25 @@ This project follows semantic versioning.
 
 ## [Unreleased]
 
+## [1.2.1] - 2026-07-03
+
+### Fixed
+
+- Native host failed to start on 1.2.0. The install launcher runs the host with `--browser <name>` before the extension origin that Chrome appends, so the origin was no longer `args[0]`. The CLI dispatcher only recognized native-host mode when the origin was `args[0]`, so the launcher's argv fell through to `Unknown command: --browser` and the host exited on every connect. The visible symptoms were the Codex extension connection flapping between connected/disconnected and `status` never listing a bridge socket (`sockets: []`). The dispatcher now detects the origin by shape anywhere in the args, and a regression test covers the launcher argv.
+
+## [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

@@ -15,17 +15,6 @@ This is an independent community project. It is not affiliated with OpenAI, Code
 - Chrome Extension: [Codex Chrome Extension](https://chromewebstore.google.com/detail/hehggadaopoacecdllhhajmbjkdcmajg)
 - Skill: [`skills/codex-control-chrome-mcp/SKILL.md`](./skills/codex-control-chrome-mcp/SKILL.md)
 
-## Status
-
-The current implementation provides:
-
-- official `@modelcontextprotocol/sdk` stdio server
-- Chrome 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
-- bundled skill documentation for Agent tool ordering
-
 ## Platform Support
 
 | Platform | Status | Notes |
@@ -36,16 +25,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,16 +150,12 @@ 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.
-
 ### 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:
 
 ```bash
@@ -162,6 +164,8 @@ npx -y codex-control-chrome-mcp@latest uninstall-native-host
 
 If tab or CDP tools fail, use the bundled skill workflow: list tabs again, claim only current tab IDs, attach before raw CDP calls, and read CDP events after enabling the relevant domain.
 
+See [Install And Uninstall](./docs/install.md#troubleshooting) for the full per-browser checklist (the `registered` flag and host `classification`).
+
 ## License
 
 MIT

package/docs/architecture.md

@@ -203,20 +203,16 @@ Agent-side MCP config should use:
 }
 ```
 
-Chrome Native Messaging manifests cannot store command arguments. Therefore `install-native-host` creates a stable launcher script:
-
-```sh
-npx -y codex-control-chrome-mcp@latest install-native-host
-```
+Chrome Native Messaging manifests cannot store command arguments. Therefore `install-native-host` writes a stable launcher script at:
 
 ```text
 ~/.codex-control-chrome-mcp/native-host-launcher
 ```
 
-That launcher runs:
+That launcher runs (the `--browser` flag tells the host which browser's proxy config to read):
 
 ```sh
-npx -y codex-control-chrome-mcp@1.0.0 --native-host "$@"
+npx -y codex-control-chrome-mcp@latest --native-host --browser chrome "$@"
 ```
 
 The native host manifest points to the launcher, not directly to `npx`.

package/docs/install.md

@@ -8,13 +8,6 @@ Package:
 
 ## Development Status
 
-The current implementation provides:
-
-- MCP stdio mode: `npx -y codex-control-chrome-mcp@latest --stdio`
-- manifest install: `npx -y codex-control-chrome-mcp@latest install-native-host`
-- manifest uninstall: `npx -y codex-control-chrome-mcp@latest uninstall-native-host`
-- bridge/socket status: `npx -y codex-control-chrome-mcp@latest status`
-
 Do not run install on a machine where Codex Chrome integration is important unless you are ready to test proxy mode or restore from backup.
 
 This is an independent community project. It is not affiliated with OpenAI, Codex, Google, or Chrome.
@@ -24,35 +17,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 +75,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 +127,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 +141,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 +176,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.1",
   "description": "MCP server and native host bridge for controlling Chrome through the Codex Chrome extension.",
   "license": "MIT",
   "type": "module",

package/src/cli.js

@@ -1,41 +1,60 @@
 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";
 
 export async function runCli(argv) {
   const args = argv.slice(2);
-  const command = args[0];
+  const invocation = classifyInvocation(args);
 
-  if (args.includes("--stdio") || command === "stdio") {
+  if (invocation.mode === "mcp") {
     await runMcpServer();
     return;
   }
 
-  if (args.includes("--native-host") || looksLikeChromeOrigin(command)) {
-    await runNativeHost({ origin: looksLikeChromeOrigin(command) ? command : argv[3] });
+  if (invocation.mode === "native-host") {
+    await runNativeHost({ origin: invocation.origin ?? argv[3], browser: invocation.browser });
     return;
   }
 
+  const command = invocation.command;
   switch (command) {
     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": {
@@ -57,6 +76,31 @@ export async function runCli(argv) {
   }
 }
 
+/**
+ * Decide how an invocation should be handled, purely from the CLI args.
+ *
+ * Chrome/Edge launch the native host by appending the extension origin as a
+ * positional arg, and the install launcher prepends `--browser <name>`. That
+ * prefix shifts the origin out of `args[0]`, so both the mode check and the
+ * origin lookup must scan by shape rather than position. (A 1.2.0 regression
+ * only checked `args[0]` here, so the launcher's `--browser`-prefixed argv fell
+ * through to `Unknown command: --browser` and the native host exited on every
+ * connect.)
+ */
+export function classifyInvocation(args) {
+  if (args.includes("--stdio") || args[0] === "stdio") {
+    return { mode: "mcp" };
+  }
+  if (args.includes("--native-host") || args.some(looksLikeChromeOrigin)) {
+    return {
+      mode: "native-host",
+      origin: args.find(looksLikeChromeOrigin),
+      browser: normalizeBrowser(readOption(args, "--browser")),
+    };
+  }
+  return { mode: "command", command: args[0] };
+}
+
 function looksLikeChromeOrigin(value) {
   return typeof value === "string" && value.startsWith("chrome-extension://");
 }
@@ -66,6 +110,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 +153,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;