@minhspark/codex-mcp-bridge 1.12.0 → 1.12.1

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 Follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and [SemVer](https://semver.org/).
 
+## [1.12.1] - 2026-09-05
+
+### Fixed
+
+- **Windows no longer loses the Codex Desktop native relay to a Unix-only transport.** The Claude peer endpoint
+  and the Codex Desktop companion now use local named pipes on Windows, while macOS and Linux keep their Unix
+  sockets. The same platform-aware endpoint detection is used by status checks and cleanup, so a live Windows
+  companion is not mistaken for a missing session or deleted as a stale file.
+- **Live Claude sessions no longer disappear intermittently while their registry file is being rewritten.** Session
+  metadata is read twice and retried until stable, and peer delivery retries the short startup window before the
+  named pipe is listening. A session that is alive but still bringing up its Windows pipe remains visible and
+  deliverable.
+- **A disconnected hand-off now releases the bridge app-server when release-after-turn is enabled.** This prevents
+  a dropped turn from leaving a writer lock behind and blocking Codex Desktop on the next open.
+- **Windows resolves the versioned Codex Desktop binary before older install locations.** The bridge and installers
+  therefore use the current desktop executable instead of silently attaching to an obsolete copy.
+
 ## [1.12.0] - 2026-09-04
 
 ### Added

package/README.md

@@ -6,7 +6,7 @@
 [![license](https://img.shields.io/npm/l/@minhspark/codex-mcp-bridge)](LICENSE)
 [![M8ven Verified](https://m8ven.ai/badge/mcp/buidangminh23-codex-mcp-bridge-1ke8t1?variant=verified)](https://m8ven.ai/mcp/buidangminh23-codex-mcp-bridge-1ke8t1)
 
-A **two-way** bridge between Claude and Codex: Claude pushes prompts into a **live Codex thread**, and Codex messages back into a **running Claude Code session**. Each side sees the other's sessions and follows the conversation inside its own app. Runs on **macOS, Windows and Linux** (the Codex → Claude direction needs unix sockets, so macOS/Linux only).
+A **two-way** bridge between Claude and Codex: Claude pushes prompts into a **live Codex thread**, and Codex messages back into a **running Claude Code session**. Each side sees the other's sessions and follows the conversation inside its own app. Runs on **macOS, Windows and Linux** (the Codex → Claude direction uses unix sockets on macOS/Linux and named pipes on Windows).
 
 This is not `codex exec`, which starts a fresh session every time. The bridge speaks JSON-RPC to the real Codex app-server, so the thread keeps its history, its `cwd`, its model and its rollout file — and a human can watch it run in the Codex desktop app instead of reading the transcript afterwards.
 
@@ -20,13 +20,13 @@ Claude Desktop ──────┤ stdio                                    We
                      └────────────────────────────────────────────────────────────────────┘
 
                      ┌──────────────── claude-bridge (runs inside Codex) ──────────────────┐
-Codex ───────────────┤ stdio                       unix socket /tmp/cc-socks/<pid>.sock    ├──> Claude Code session ──> message shows in Claude Desktop
+Codex ───────────────┤ stdio             unix socket / named pipe for the Claude session       ├──> Claude Code session ──> message shows in Claude Desktop
                      └────────────────────────────────────────────────────────────────────┘
 
 Codex TUI  ──codex --remote ws://127.0.0.1:8791──> same app-server, same live thread
 
-                     ┌──── codex-native-relay (launched by Codex Desktop, macOS) ──────────┐
-claude-bridge ───────┤ unix socket ~/.codex/native-relay.sock       native tools           ├──> the thread already open in Codex Desktop
+                     ┌── codex-native-relay (launched by Codex Desktop, Windows/macOS) ────┐
+claude-bridge ───────┤ named pipe / unix socket                         native tools       ├──> the thread already open in Codex Desktop
                      └────────────────────────────────────────────────────────────────────┘
 ```
 
@@ -34,7 +34,7 @@ claude-bridge ───────┤ unix socket ~/.codex/native-relay.sock
 - Every client pointed at the same URL shares **one app-server**, so `thread/resume` with a `threadId` rejoins the running thread instead of opening a new session.
 - The bridge keeps exactly one WebSocket, calls `initialize` once, and routes notifications by `threadId`, so parallel threads never bleed into each other.
 - `delegate_to_codex` is the one-call Claude → Codex hand-off: it starts the thread at the supplied `cwd`, names it, sends the prompt, stops the bridge app-server after a terminal turn, and opens `codex://threads/<id>` in Codex Desktop when enabled.
-- The **native relay** (macOS, optional) is the third line: a thread the human is watching in Codex Desktop belongs to the app, and a second app-server cannot write to it. Instead of taking the thread away, `claude-bridge` hands the message to a companion the app itself launched, and the app delivers it. See [Codex Desktop native relay](#codex-desktop-native-relay-macos).
+- The **native relay** (Windows/macOS, optional) is the third line: a thread the human is watching in Codex Desktop belongs to the app, and a second app-server cannot write to it. Instead of taking the thread away, `claude-bridge` hands the message to a companion the app itself launched, and the app delivers it. See [Codex Desktop native relay](#codex-desktop-native-relay).
 
 ## Requirements
 
@@ -227,9 +227,9 @@ launchctl kickstart -k gui/$UID/com.codex-mcp-bridge.app-server
 
 `CLAUDE_BRIDGE_PEER_NAME` sets the name Claude shows for this bridge in its agent list.
 
-### 5. macOS only: the Codex Desktop native relay
+### 5. Windows/macOS: the Codex Desktop native relay
 
-Optional, and only worth installing if you keep the bound thread **open in Codex Desktop** while Claude messages back. See [Codex Desktop native relay](#codex-desktop-native-relay-macos) for what it does and why.
+Optional, and only worth installing if you keep the bound thread **open in Codex Desktop** while Claude messages back. See [Codex Desktop native relay](#codex-desktop-native-relay) for what it does and why.
 
 ```bash
 node scripts/install-native-relay.mjs
@@ -240,7 +240,7 @@ This registers the companion with Codex (`codex mcp add codex-native-relay -- <n
 ```bash
 codex mcp get codex-native-relay
 node scripts/install-native-relay.mjs --no-bootstrap   # register only; supply CODEX_RELAY_ID yourself
-node scripts/install-native-relay.mjs --remove         # unregister, and delete the socket and the thread id
+node scripts/install-native-relay.mjs --remove         # unregister, and remove the relay config and thread id
 ```
 
 Restart Codex Desktop so it launches the companion, then call its `native_relay_status` tool — or `claude_bridge_status`, whose `delivery:` line names the backend in force. Until both the companion and the executor thread are in place, `claude-bridge` keeps using the app-server path exactly as before.
@@ -379,7 +379,7 @@ send_to_codex_thread { threadId: "01a0…", prompt: "…", openInApp: true }
 
 This is how a human watches Codex work in real time instead of reading the rollout at `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl` after the fact.
 
-### Codex Desktop native relay (macOS)
+### Codex Desktop native relay
 
 `bind_codex_thread` relays every message Claude sends into a Codex thread. That works — until the thread is one **you are watching in Codex Desktop**, which is the case it was built for. Codex takes a per-thread writer lock when the app loads a thread and holds it for as long as the thread is open, so the app-server path, which has to `thread/resume` before it can send, is refused:
 
@@ -394,7 +394,7 @@ The native relay removes the second writer rather than fighting it. A companion
 ```
 Claude
   → claude-bridge
-  → ~/.codex/native-relay.sock          (unix socket, mode 0600)
+  → Windows named pipe / macOS ~/.codex/native-relay.sock (unix socket, mode 0600)
   → codex-native-relay                  (launched by Codex Desktop's app-server)
   → codex_app.send_message_to_thread    (over that same connection)
   → the thread already open in Codex Desktop
@@ -412,25 +412,25 @@ Resolution order is `CODEX_RELAY_ID` → that file → an error naming both. Nev
 
 | Condition | Otherwise |
 |---|---|
-| macOS | the app-server path (`CODEX_BRIDGE_NATIVE_RELAY=1` forces the attempt anyway) |
+| Windows or macOS, companion endpoint exists | the app-server path (`CODEX_BRIDGE_NATIVE_RELAY=1` forces the attempt anyway) |
 | `CODEX_BRIDGE_NATIVE_RELAY` is not `0` | switched off by hand |
-| `~/.codex/native-relay.sock` exists and is a socket | the companion is not installed, or Codex Desktop is not running |
+| the Windows named pipe or macOS unix socket exists | the companion is not installed, or Codex Desktop is not running |
 
 A companion that cannot be reached falls back to the app-server path, because an absent relay says nothing about the target thread. A companion that **answered with a refusal** does not: Codex has already been asked, and a second app-server would only contend for the `~/.codex` state and then fail on the very writer lock this backend exists to avoid.
 
-> ⚠️ `codex_app.send_message_to_thread` and the native tools pipe are **Codex Desktop internals with no public documentation**, on the same footing as the Claude peer protocol above. That is why the relay is macOS-only, feature-detected, optional and fallback-safe. If Codex changes it, the two places to fix are `NATIVE_DISPATCH_METHOD` and `nativeDispatchParams()` in `src/native-relay.mjs`; `CODEX_NATIVE_RELAY_METHOD` overrides the method name without a release. The request the companion sends is:
+> ⚠️ `codex_app.send_message_to_thread` and the native tools pipe are **Codex Desktop internals with no public documentation**, on the same footing as the Claude peer protocol above. That is why the relay is Windows/macOS, feature-detected, optional and fallback-safe. If Codex changes it, the two places to fix are `NATIVE_DISPATCH_METHOD` and `nativeDispatchParams()` in `src/native-relay.mjs`; `CODEX_NATIVE_RELAY_METHOD` overrides the method name without a release. The request the companion sends is:
 >
 > ```json
 > {"jsonrpc":"2.0","id":1,"method":"codex_app.send_message_to_thread",
 >  "params":{"executorThreadId":"<relay thread>","threadId":"<destination>","message":"..."}}
 > ```
 
-**Security.** The socket is mode `0600` inside `~/.codex`, and that file mode is the entire boundary — the same one the Claude peer protocol relies on. Anything able to open it can put text into a Codex thread, so it is created private and swept on exit. The companion accepts exactly one shape, `{ targetThreadId, message }`, caps a frame at 128 KiB, and refuses a destination that is its own executor thread — otherwise a mistaken bind would deliver into the invisible relay thread and report success.
+**Security.** On macOS/Linux the relay socket is mode `0600` inside `~/.codex`; Windows uses the Claude-compatible local named-pipe namespace. Anything able to open the relay can put text into a Codex thread, so the endpoint is feature-detected and the companion accepts exactly one shape, `{ targetThreadId, message }`, caps a frame at 128 KiB, and refuses a destination that is its own executor thread — otherwise a mistaken bind would deliver into the invisible relay thread and report success.
 
 ### Caveats
 
-- The Codex desktop app runs its own app-server over stdio (`ChatGPT.app/Contents/Resources/codex … app-server`, **no** `--listen`), so nothing external can attach to it. `~/.codex/ipc/ipc.sock` is the Electron app's internal IPC, not an app-server. Threads opened there can still be driven through the bridge, but by resuming from the rollout `.jsonl` rather than attaching live. The [native relay](#codex-desktop-native-relay-macos) is not an exception to this: the companion never attaches to that app-server, it is *launched by* it as one of the app's own MCP servers.
-- **A thread currently open in the desktop app cannot be written to** through a second app-server — Codex holds a per-thread writer lock (`~/.codex/thread-writer-locks/`) and returns `thread <id> already has an active writer`. That error is the guard working, not data loss. Check `status` with `list_codex_threads` first and only send when it is `idle` or `notLoaded` and not open in the app. For the Claude → Codex relay specifically, the [native relay](#codex-desktop-native-relay-macos) removes the second writer instead of waiting for the lock.
+- The Codex desktop app runs its own app-server over stdio (`ChatGPT.app/Contents/Resources/codex … app-server`, **no** `--listen`), so nothing external can attach to it. `~/.codex/ipc/ipc.sock` is the Electron app's internal IPC, not an app-server. Threads opened there can still be driven through the bridge, but by resuming from the rollout `.jsonl` rather than attaching live. The [native relay](#codex-desktop-native-relay) is not an exception to this: the companion never attaches to that app-server, it is *launched by* it as one of the app's own MCP servers.
+- **A thread currently open in the desktop app cannot be written to** through a second app-server — Codex holds a per-thread writer lock (`~/.codex/thread-writer-locks/`) and returns `thread <id> already has an active writer`. That error is the guard working, not data loss. Check `status` with `list_codex_threads` first and only send when it is `idle` or `notLoaded` and not open in the app. For the Claude → Codex relay specifically, the [native relay](#codex-desktop-native-relay) removes the second writer instead of waiting for the lock.
 - **Bridge-created threads are named before they are opened.** The bridge calls the app-server's `thread/name/set` with the requested title, or derives `[project] first line of prompt`, then opens the exact `codex://threads/<id>` link. This gives Codex Desktop a visible session title and preserves the precise `cwd` in the thread metadata.
 - A repo living on the NTFS partition of a dual-boot machine (`/Volumes/<label>/...`) is **read-only** under macOS. Keep a separate checkout on an APFS volume to run and edit it.
 - `codex app-server daemon start` uses the `unix://` transport with a control socket at `~/.codex/app-server-control/app-server-control.sock`. The bridge does **not** use that path (different framing, no public API) — it always talks over `ws://`.
@@ -454,9 +454,9 @@ python3 -c "import json;[print(v['properties']['method'].get('const') or v['prop
 
 **The bridge disappears from Claude after sending into a busy thread.** Fixed in 1.6.0. A rejected `turn/start` — which is exactly what a thread locked by the desktop app produces — also rejected an internal promise nothing was awaiting. Node treats that as an unhandled rejection and, by default, exits the process, so the MCP server died while the tool handler was still formatting a tidy error message for a client that no longer had a server. Pinned by a test that runs the failure in a real child process and asserts it exits 0.
 
-**The Codex app says a thread is "open in another application".** That is the per-thread writer lock, and the other application is usually this bridge: the shared app-server takes the lock when it loads a thread and keeps it until it exits, so the desktop app cannot write to the same thread. `delegate_to_codex` releases the bridge server before opening the final desktop link when `releaseAfterTurn` is enabled. For an existing thread, pass `releaseAfterTurn: true` or call `stop_codex_app_server` once the hand-off is done — the bridge starts a new app-server the next time it needs one. A thread held by a *different* Codex window is the app's own lock; close it there. If what you want is for Codex Desktop to **keep** the thread while Claude messages into it, that is what the [native relay](#codex-desktop-native-relay-macos) is for — it never asks for the lock.
+**The Codex app says a thread is "open in another application".** That is the per-thread writer lock, and the other application is usually this bridge: the shared app-server takes the lock when it loads a thread and keeps it until it exits, so the desktop app cannot write to the same thread. `delegate_to_codex` releases the bridge server before opening the final desktop link when `releaseAfterTurn` is enabled. For an existing thread, pass `releaseAfterTurn: true` or call `stop_codex_app_server` once the hand-off is done — the bridge starts a new app-server the next time it needs one. A thread held by a *different* Codex window is the app's own lock; close it there. If what you want is for Codex Desktop to **keep** the thread while Claude messages into it, that is what the [native relay](#codex-desktop-native-relay) is for — it never asks for the lock.
 
-**`claude_bridge_status` says the delivery backend is `app-server` on a Mac with the relay installed.** The `delivery:` line carries the reason, and there are only three. *"no companion socket at …"* — Codex Desktop has not launched the companion: restart the app after `install-native-relay.mjs`, and check `codex mcp get codex-native-relay`. *"disabled by CODEX_BRIDGE_NATIVE_RELAY=0"* — it was switched off in the MCP server's `env`. *"macOS-only"* — the bridge is not running where the Codex Desktop app is; the app-server path is the correct answer there. A relay that is reachable but has no executor thread fails at send time instead, with `RELAY_THREAD_UNCONFIGURED` naming both `CODEX_RELAY_ID` and the file to bootstrap.
+**`claude_bridge_status` says the delivery backend is `app-server` on Windows or macOS with the relay installed.** The `delivery:` line carries the reason: *"no companion socket at …"* means Codex Desktop has not launched the companion, so restart the app after `install-native-relay.mjs` and check `codex mcp get codex-native-relay`; *"disabled by CODEX_BRIDGE_NATIVE_RELAY=0"* means it was switched off in the MCP server's `env`; *"unavailable on Linux"* means the native relay is not supported there. A relay that is reachable but has no executor thread fails at send time instead, with `RELAY_THREAD_UNCONFIGURED` naming both `CODEX_RELAY_ID` and the file to bootstrap.
 
 **A thread opens against the wrong directory.** The same project sits at a different absolute path on each machine: on the shared drive's letter under Windows, under its mount point when that drive is visible from macOS (**read-only** there), and in a native checkout otherwise. Since 1.4.0 the bridge picks the candidate that both **exists and is writable** on the current machine and prints a `note: cwd remapped …` line whenever it rewrites one. If nothing usable exists it fails immediately instead of opening a thread somewhere wrong. Handing Codex a read-only cwd is a reliable way to hit the freeze above: it runs a few reads, then asks for write permission and stalls.
 
@@ -493,10 +493,10 @@ The bridge reads these from the environment its MCP client hands it — there is
 | `CODEX_BRIDGE_EFFORT` | from `~/.codex/config.toml` | Default reasoning effort: `minimal` · `low` · `medium` · `high` · `xhigh` · `ultra`. |
 | `CODEX_BRIDGE_OPEN_IN_APP` | `1` on Windows, `0` elsewhere | Open delegated or sent threads through the `codex://threads/<id>` desktop link. |
 | `CODEX_BRIDGE_RELEASE_AFTER_TURN` | `1` on Windows, `0` elsewhere | Stop the shared bridge app-server after a terminal turn so Codex Desktop can write the handed-off thread. |
-| `CODEX_BRIDGE_NATIVE_RELAY` | `auto` | Delivery backend for relayed Claude messages. `auto` uses the Codex Desktop native relay on macOS when the companion socket exists; `0` never does; `1` attempts it on any platform. |
-| `CODEX_RELAY_ID` | from `~/.codex/native-relay.json` | Executor thread for `codex_app.send_message_to_thread`. Not the destination — see [Codex Desktop native relay](#codex-desktop-native-relay-macos). |
-| `CODEX_HOME` | `~/.codex` | Where the relay socket and `native-relay.json` live. |
-| `CODEX_NATIVE_RELAY_SOCKET` | `$CODEX_HOME/native-relay.sock` | Override the companion's socket path on both halves of the relay. |
+| `CODEX_BRIDGE_NATIVE_RELAY` | `auto` | Delivery backend for relayed Claude messages. `auto` uses the Codex Desktop native relay on Windows/macOS when its companion endpoint exists; `0` never does; `1` attempts it on any platform. |
+| `CODEX_RELAY_ID` | from `~/.codex/native-relay.json` | Executor thread for `codex_app.send_message_to_thread`. Not the destination — see [Codex Desktop native relay](#codex-desktop-native-relay). |
+| `CODEX_HOME` | `~/.codex` | Where `native-relay.json` lives; POSIX relay sockets also live here, while Windows uses a named pipe. |
+| `CODEX_NATIVE_RELAY_SOCKET` | Windows named pipe or `$CODEX_HOME/native-relay.sock` on macOS | Override the companion endpoint on both halves of the relay. |
 | `CODEX_NATIVE_RELAY_METHOD` | `codex_app.send_message_to_thread` | The undocumented Codex Desktop method the companion dispatches through; override it if Codex renames it. |
 | `CODEX_NATIVE_RELAY_NAME` | `codex-native-relay` | The MCP server name `scripts/install-native-relay.mjs` registers with Codex. |
 | `CLAUDE_BRIDGE_PEER_NAME` | `codex-<pid>` | The name Claude shows for this bridge in its agent list. |
@@ -542,10 +542,10 @@ Runs the whole suite with `node --test`. It needs no Codex install, no login and
 | `test/turn.test.mjs` | the turn state machine: buffered notifications, terminal statuses, timeout, disconnect, retryable vs fatal errors, and that a failed `turn/start` cannot kill the process |
 | `test/peer-protocol.test.mjs` | frame round-trips, the session registry, transcript scanning, and a live peer endpoint over a real unix socket |
 | `test/platform.test.mjs` | binary resolution, the PATH handed to child processes, per-OS config paths and cwd remapping |
-| `test/native-relay.test.mjs` | the Codex Desktop relay: executor thread resolution, feature detection, socket round trips over a real unix socket, reclaiming a socket a killed companion left behind, backend selection and when it may fall back, and the companion answering a real MCP client that plays Codex Desktop |
+| `test/native-relay.test.mjs` | the Codex Desktop relay: executor thread resolution, feature detection, Windows named-pipe and POSIX socket round trips, backend selection and fallback, and the companion answering a real MCP client that plays Codex Desktop |
 | `test/repo-hygiene.test.mjs` | no environment file or build output is ever tracked, versions do not drift, documentation stays in English |
 
-GitHub Actions runs the same command on every push and pull request, across Node 22 and 24 on Linux, macOS and Windows (`.github/workflows/ci.yml`). The Codex → Claude direction and the native relay both need unix sockets, so those tests skip on Windows; the rest of the suite runs there like anywhere else.
+GitHub Actions runs the same command on every push and pull request, across Node 22 and 24 on Linux, macOS and Windows (`.github/workflows/ci.yml`). The Codex → Claude direction uses unix sockets on macOS/Linux and named pipes on Windows; the native relay has matching platform-specific coverage.
 
 Two checks need a real Codex and are not part of `npm test`:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minhspark/codex-mcp-bridge",
-  "version": "1.12.0",
+  "version": "1.12.1",
   "description": "Two-way MCP bridge between Claude and Codex: prompts into a live Codex thread, messages into a running Claude Code session.",
   "keywords": [
     "mcp",

package/scripts/install-native-relay.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 
 import { CodexAppServerClient } from "../src/app-server-client.mjs";
 import { bootstrapRelayThread, readRelayConfig, relayConfigPath, relaySocketPath } from "../src/native-relay.mjs";
-import { IS_MACOS, PLATFORM_LABEL, homeDir, resolveCodexBin, spawnEnv } from "../src/platform.mjs";
+import { IS_MACOS, IS_WINDOWS, PLATFORM_LABEL, homeDir, resolveCodexBin, spawnEnv } from "../src/platform.mjs";
 
 /**
  * Installs the Codex Desktop native relay: registers the companion as an MCP
@@ -39,7 +39,7 @@ if (remove) {
   } catch (err) {
     console.log(`${serverName} was not registered (${err.message.trim().split("\n").at(-1)})`);
   }
-  for (const leftover of [relaySocketPath(), relayConfigPath()]) {
+  for (const leftover of [relayConfigPath(), ...(IS_WINDOWS ? [] : [relaySocketPath()])]) {
     if (fs.existsSync(leftover)) {
       fs.rmSync(leftover, { force: true });
       console.log(`removed ${leftover}`);
@@ -49,12 +49,12 @@ if (remove) {
 }
 
 /**
- * Not a hard failure: the companion is harmless on any platform - it simply
- * never gets a native tools connection to dispatch through - and refusing to
- * register it would make the install order depend on which machine runs it.
+ * Not a hard failure on an unsupported platform: the companion is harmless and
+ * refusing to register it would make the install order depend on which machine
+ * runs it.
  */
-if (!IS_MACOS) {
-  console.log(`note: the native relay only delivers on macOS; this is ${PLATFORM_LABEL}.`);
+if (!IS_MACOS && !IS_WINDOWS) {
+  console.log(`note: the native relay is unavailable on ${PLATFORM_LABEL}.`);
   console.log("claude-bridge will keep using the app-server path here.");
 }
 
@@ -76,7 +76,7 @@ if (existing) {
   console.log(`\nskipped the relay thread bootstrap; set CODEX_RELAY_ID or rerun without --no-bootstrap.`);
 } else {
   const client = new CodexAppServerClient({
-    clientInfo: { name: "native-relay-install", title: "Native Relay Install", version: "1.11.3" },
+    clientInfo: { name: "native-relay-install", title: "Native Relay Install", version: "1.12.1" },
     log: (msg) => console.log(`  ${msg}`),
   });
   console.log("\nbootstrapping the relay executor thread...");

package/src/claude-bridge.mjs

@@ -8,7 +8,7 @@ import { PLATFORM_LABEL } from "./platform.mjs";
 import { PeerEndpoint, findClaudeSession, listClaudeSessions, readTranscript } from "./peer-protocol.mjs";
 import { createThreadDelivery } from "./thread-delivery.mjs";
 
-const VERSION = "1.12.0";
+const VERSION = "1.12.1";
 const FORWARD_MIN_INTERVAL_MS = 5000;
 const FORWARD_MAX_PER_SESSION = 50;
 

package/src/index.mjs

@@ -21,7 +21,7 @@ import {
 import { runTurn } from "./turn.mjs";
 import { BridgeSecurityPolicy } from "./security-policy.mjs";
 
-const VERSION = "1.12.0";
+const VERSION = "1.12.1";
 const log = (msg) => process.stderr.write(`[codex-mcp-bridge] ${msg}\n`);
 
 /**
@@ -38,6 +38,7 @@ const DEFAULT_RELEASE_AFTER_TURN = process.env.CODEX_BRIDGE_RELEASE_AFTER_TURN
   ? process.env.CODEX_BRIDGE_RELEASE_AFTER_TURN === "1"
   : IS_WINDOWS;
 const TERMINAL_TURN_STATUSES = new Set(["completed", "interrupted", "failed"]);
+const RELEASE_TURN_STATUSES = new Set([...TERMINAL_TURN_STATUSES, "disconnected"]);
 const security = new BridgeSecurityPolicy();
 
 const client = new CodexAppServerClient({
@@ -133,8 +134,9 @@ async function finishDesktopHandoff({ threadId, result, openInApp, releaseAfterT
   const notes = [];
   let canOpenAfterRelease = true;
   const terminal = TERMINAL_TURN_STATUSES.has(result.status);
+  const releasable = RELEASE_TURN_STATUSES.has(result.status);
 
-  if (releaseAfterTurn && terminal) {
+  if (releaseAfterTurn && releasable) {
     try {
       const released = await client.stopServer();
       if (released.stopped) {

package/src/native-relay-companion.mjs

@@ -16,7 +16,7 @@ import {
   relaySocketPath,
   resolveRelayThreadId,
 } from "./native-relay.mjs";
-import { PLATFORM_LABEL } from "./platform.mjs";
+import { IS_WINDOWS, PLATFORM_LABEL } from "./platform.mjs";
 
 /**
  * The companion half of the Codex Desktop native relay.
@@ -31,7 +31,7 @@ import { PLATFORM_LABEL } from "./platform.mjs";
  * (`{ targetThreadId, message }`), one dispatch, one acknowledgement.
  */
 
-const VERSION = "1.12.0";
+const VERSION = "1.12.1";
 const log = (msg) => process.stderr.write(`[native-relay] ${msg}\n`);
 
 function errorResponse(code, message) {
@@ -91,20 +91,19 @@ export async function handleRelayRequest(
 }
 
 /**
- * Listens on a private unix socket and answers one NDJSON line per request.
- *
- * The socket is mode 0600 inside the Codex home directory, which is the same
- * boundary the Claude peer protocol already relies on: owning the user account
- * is what grants access, and nothing weaker does. Named separately here because
- * this socket can put text into a Codex thread, so the file mode is the
- * security control rather than a detail of the transport.
+ * Listens on a private local socket or Windows named pipe and answers one NDJSON line per request.
+*
+ * POSIX sockets are mode 0600 inside the Codex home directory. Windows uses the
+ * Claude-compatible local named-pipe namespace instead of a filesystem mode.
  */
 export class RelaySocketServer {
   constructor({
     socketPath,
     dispatch,
     resolveExecutor = resolveRelayThreadId,
-    restrictSocket = (target) => fs.chmodSync(target, 0o600),
+    restrictSocket = (target) => {
+      if (!IS_WINDOWS) fs.chmodSync(target, 0o600);
+    },
     log: logFn = () => {},
   } = {}) {
     this.socketPath = socketPath;
@@ -118,7 +117,7 @@ export class RelaySocketServer {
 
   async start() {
     if (this.started) return this.socketPath;
-    fs.mkdirSync(path.dirname(this.socketPath), { recursive: true });
+    if (!IS_WINDOWS) fs.mkdirSync(path.dirname(this.socketPath), { recursive: true });
 
     this.server = net.createServer((socket) => this.#handleConnection(socket));
     await this.#listen({ replaceStale: true });
@@ -171,6 +170,13 @@ export class RelaySocketServer {
       });
     } catch (err) {
       if (err.code !== "EADDRINUSE" || !replaceStale) throw err;
+      if (IS_WINDOWS) {
+        if (await this.#socketIsLive()) {
+          throw new Error(`another native relay companion already owns ${this.socketPath}`);
+        }
+        await new Promise((resolve) => globalThis.setTimeout(resolve, 100));
+        return this.#listen({ replaceStale: false });
+      }
       if (await this.#socketIsLive()) {
         throw new Error(`another native relay companion already owns ${this.socketPath}`);
       }
@@ -241,7 +247,7 @@ export class RelaySocketServer {
       this.server?.close();
     } catch {}
     try {
-      if (this.started) fs.rmSync(this.socketPath, { force: true });
+      if (this.started && !IS_WINDOWS) fs.rmSync(this.socketPath, { force: true });
     } catch {}
     this.started = false;
   }

package/src/native-relay.mjs

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
 
-import { IS_MACOS, PLATFORM_LABEL, homeDir } from "./platform.mjs";
+import { IS_MACOS, IS_WINDOWS, PLATFORM_LABEL, homeDir } from "./platform.mjs";
 
 /**
  * The Codex Desktop app owns the per-thread writer lock of every thread it has
@@ -43,6 +43,7 @@ export const MAX_FRAME_BYTES = 128 * 1024;
 
 const DEFAULT_TIMEOUT_MS = 30000;
 const RELAY_SOCKET_NAME = "native-relay.sock";
+const WINDOWS_RELAY_SOCKET = "\\\\.\\pipe\\LOCAL\\codex-native-relay";
 const RELAY_CONFIG_NAME = "native-relay.json";
 
 export class NativeRelayError extends Error {
@@ -66,7 +67,7 @@ export function codexHome(env = process.env) {
 }
 
 export function relaySocketPath(env = process.env) {
-  return env.CODEX_NATIVE_RELAY_SOCKET ?? path.join(codexHome(env), RELAY_SOCKET_NAME);
+  return env.CODEX_NATIVE_RELAY_SOCKET ?? (IS_WINDOWS ? WINDOWS_RELAY_SOCKET : path.join(codexHome(env), RELAY_SOCKET_NAME));
 }
 
 export function relayConfigPath(env = process.env) {
@@ -81,6 +82,13 @@ function isSocketFile(target) {
   }
 }
 
+function isRelayEndpoint(target) {
+  if (IS_WINDOWS) {
+    return typeof target === "string" && target.toLowerCase().startsWith("\\\\.\\pipe\\") && fs.existsSync(target);
+  }
+  return isSocketFile(target);
+}
+
 export function readRelayConfig(env = process.env) {
   const file = relayConfigPath(env);
   try {
@@ -145,15 +153,15 @@ export function nativeRelayStatus(env = process.env) {
     return { enabled: false, mode, socketPath, reason: "disabled by CODEX_BRIDGE_NATIVE_RELAY=0" };
   }
   const forced = mode === "1" || mode === "on";
-  if (!IS_MACOS && !forced) {
+  if (!IS_MACOS && !IS_WINDOWS && !forced) {
     return {
       enabled: false,
       mode,
       socketPath,
-      reason: `the Codex Desktop native relay is macOS-only (this is ${PLATFORM_LABEL})`,
+      reason: `the Codex Desktop native relay is unavailable on ${PLATFORM_LABEL}`,
     };
   }
-  if (!isSocketFile(socketPath)) {
+  if (!isRelayEndpoint(socketPath)) {
     return {
       enabled: false,
       mode,

package/src/peer-protocol.mjs

@@ -32,7 +32,7 @@ const projectsDir = () => path.join(homeDir(), ".claude", "projects");
 
 /**
  * A Claude Code session advertises itself in ~/.claude/sessions/<pid>.json and
- * listens for peer messages on a unix socket. Messages are newline-delimited
+ * listens for peer messages on a local socket or Windows named pipe. Messages are newline-delimited
  * JSON; the wrapper element is what Claude renders in its chat surface.
  */
 export function buildFrame({ text, fromSocket, priority = "next" }) {
@@ -84,6 +84,30 @@ function isProcessAlive(pid) {
   }
 }
 
+const SESSION_READ_ATTEMPTS = 3;
+const PEER_SEND_ATTEMPTS = 3;
+const PEER_CONNECT_TIMEOUT_MS = 2000;
+const PEER_RETRY_DELAY_MS = 75;
+const RETRYABLE_PEER_ERRORS = new Set(["ECONNREFUSED", "ECONNRESET", "ENOENT", "EPIPE", "ENOTFOUND", "ETIMEDOUT"]);
+
+function readSessionEntry(file) {
+  for (let attempt = 0; attempt < SESSION_READ_ATTEMPTS; attempt += 1) {
+    try {
+      const first = fs.readFileSync(file, "utf8");
+      const second = fs.readFileSync(file, "utf8");
+      if (first !== second) continue;
+      return JSON.parse(second);
+    } catch {}
+  }
+  return null;
+}
+
+function hasMessagingEndpoint(entry) {
+  const socket = entry?.messagingSocketPath;
+  if (IS_WINDOWS && typeof socket === "string" && socket.toLowerCase().startsWith("\\\\.\\pipe\\")) return true;
+  return Boolean(socket) && fs.existsSync(socket);
+}
+
 export const BRIDGE_ENTRYPOINT = "codex-bridge";
 
 export function listClaudeSessions({ includeDead = false, includeBridges = false } = {}) {
@@ -92,15 +116,11 @@ export function listClaudeSessions({ includeDead = false, includeBridges = false
   const rows = [];
   for (const file of fs.readdirSync(dir)) {
     if (!file.endsWith(".json")) continue;
-    let entry;
-    try {
-      entry = JSON.parse(fs.readFileSync(path.join(dir, file), "utf8"));
-    } catch {
-      continue;
-    }
+    const entry = readSessionEntry(path.join(dir, file));
+    if (!entry) continue;
     if (!entry?.pid || !entry?.messagingSocketPath) continue;
     if (entry.entrypoint === BRIDGE_ENTRYPOINT && !includeBridges) continue;
-    const alive = isProcessAlive(entry.pid) && fs.existsSync(entry.messagingSocketPath);
+    const alive = isProcessAlive(entry.pid) && hasMessagingEndpoint(entry);
     if (!alive && !includeDead) continue;
     rows.push({
       pid: entry.pid,
@@ -206,12 +226,8 @@ export class PeerEndpoint {
     for (const file of fs.readdirSync(dir)) {
       if (!file.endsWith(".json")) continue;
       const registry = path.join(dir, file);
-      let entry;
-      try {
-        entry = JSON.parse(fs.readFileSync(registry, "utf8"));
-      } catch {
-        continue;
-      }
+      const entry = readSessionEntry(registry);
+      if (!entry) continue;
       if (entry?.entrypoint !== BRIDGE_ENTRYPOINT) continue;
       if (!entry.pid || entry.pid === this.pid || isProcessAlive(entry.pid)) continue;
       for (const stale of [registry, entry.messagingSocketPath, ...fs.readdirSync(dir)
@@ -328,15 +344,53 @@ export class PeerEndpoint {
 
   async send(targetSocket, text, { priority = "next" } = {}) {
     const frame = buildFrame({ text, fromSocket: this.socketPath, priority });
-    await new Promise((resolve, reject) => {
-      const client = net.connect({ path: targetSocket }, () => {
-        client.write(`${JSON.stringify(frame)}\n`, () => {
-          client.end();
-          resolve();
+    const line = JSON.stringify(frame) + "\n";
+    for (let attempt = 1; attempt <= PEER_SEND_ATTEMPTS; attempt += 1) {
+      try {
+        await new Promise((resolve, reject) => {
+          const client = net.connect({ path: targetSocket });
+          let connected = false;
+          let writeStarted = false;
+          let settled = false;
+          const timer = globalThis.setTimeout(() => {
+            const error = new Error("timed out connecting to " + targetSocket);
+            error.code = "ETIMEDOUT";
+            finish(error);
+            client.destroy();
+          }, PEER_CONNECT_TIMEOUT_MS);
+          const finish = (error) => {
+            if (settled) return;
+            settled = true;
+            globalThis.clearTimeout(timer);
+            if (error) {
+              reject({ error, retryable: !connected && !writeStarted });
+            } else {
+              resolve();
+            }
+          };
+          client.once("connect", () => {
+            connected = true;
+            writeStarted = true;
+            client.write(line, (error) => {
+              if (error) {
+                finish(error);
+                return;
+              }
+              client.end();
+              finish();
+            });
+          });
+          client.once("error", finish);
         });
-      });
-      client.on("error", reject);
-    });
+        return frame.msg_id;
+      } catch (failure) {
+        const error = failure?.error ?? failure;
+        if (!failure?.retryable || attempt === PEER_SEND_ATTEMPTS || !RETRYABLE_PEER_ERRORS.has(error?.code)) {
+          throw error;
+        }
+        await new Promise((resolve) => globalThis.setTimeout(resolve, PEER_RETRY_DELAY_MS));
+      }
+    }
     return frame.msg_id;
   }
 

package/src/platform.mjs

@@ -1,5 +1,5 @@
 import { execFile, execFileSync } from "node:child_process";
-import { accessSync, constants, existsSync } from "node:fs";
+import { accessSync, constants, existsSync, readdirSync, statSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -94,7 +94,26 @@ function isRunnable(candidate) {
 function windowsCodexCandidates() {
   const roaming = process.env.APPDATA;
   const local = process.env.LOCALAPPDATA;
+  const versionedRoot = local && path.join(local, "OpenAI", "Codex", "bin");
+  let versioned = [];
+  if (versionedRoot) {
+    try {
+      versioned = readdirSync(versionedRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(versionedRoot, entry.name, "codex.exe"))
+        .filter((candidate) => isRunnable(candidate))
+        .sort((left, right) => {
+          try {
+            return statSync(path.dirname(right)).mtimeMs - statSync(path.dirname(left)).mtimeMs;
+          } catch {
+            return 0;
+          }
+        });
+    } catch {}
+  }
   return [
+    process.env.CODEX_CLI_PATH,
+    ...versioned,
     local && path.join(local, "Programs", "OpenAI", "Codex", "bin", "codex.exe"),
     roaming && path.join(roaming, "npm", "codex.cmd"),
     process.env.ProgramFiles && path.join(process.env.ProgramFiles, "nodejs", "codex.cmd"),

package/src/thread-delivery.mjs

@@ -17,12 +17,17 @@ import { runTurn } from "./turn.mjs";
  */
 export const NATIVE_BACKEND = "codex-desktop-native";
 export const APP_SERVER_BACKEND = "app-server";
+const RELEASE_STATUSES = new Set(["completed", "interrupted", "failed", "disconnected"]);
 
 export function createThreadDelivery({
   codex,
   relay = new NativeDesktopRelay(),
   log = () => {},
   timeoutMs = 240000,
+  releaseAfterTurn =
+    process.env.CODEX_BRIDGE_RELEASE_AFTER_TURN !== undefined
+      ? process.env.CODEX_BRIDGE_RELEASE_AFTER_TURN === "1"
+      : process.platform === "win32",
 } = {}) {
   let reportedUnavailable = null;
 
@@ -57,6 +62,15 @@ export function createThreadDelivery({
       input: [{ type: "text", text }],
       timeoutMs,
     });
+    if (releaseAfterTurn && RELEASE_STATUSES.has(turn.status) && typeof codex.stopServer === "function") {
+      try {
+        const released = await codex.stopServer();
+        if (released?.stillListening) log("app-server release requested but it is still listening");
+        if (released?.stopped === false) log("app-server release skipped: " + (released.reason ?? "unknown reason"));
+      } catch (err) {
+        log("app-server release failed: " + err.message);
+      }
+    }
     return { backend: APP_SERVER_BACKEND, threadId, turn };
   }