xmux-bridge 1.0.39 → 1.0.40

package/README.md

@@ -166,8 +166,9 @@ The Codex lead MCP server is `xmux_lead`. `xmux setup-codex` configures it so
 Codex can route requests, wait for teammate responses, read events, and inspect
 team status.
 The global MCP config is install-scoped: the MCP command is a versioned npm
-entrypoint, while `XMUX_INSTALL_DIR` points at the Homebrew runtime that owns
-wrapper scripts, state discovery, and lifecycle. It does not pin
+entrypoint launched with a project-neutral `npx --prefix`, while
+`XMUX_INSTALL_DIR` points at the Homebrew runtime that owns wrapper scripts,
+state discovery, and lifecycle. It does not pin
 `XMUX_PROJECT_DIR`/`XMUX_STATE_DIR`; those values come from the active
 `xmux -n <session>` lead runtime.
 
@@ -198,15 +199,13 @@ $xmux-send-pane
 Development verification for agent/runtime changes:
 
 ```bash
-pytest tests -q
 zsh -n xmux.zsh
 zsh -n xmux-bridge.zsh
 node --check scripts/setup_xmux_codex_mcp.js
 git diff --check
 ```
 
-Formula draft and distribution notes live in
-[Homebrew distribution](docs/operations/homebrew.md).
+Homebrew distribution notes live in [Homebrew distribution](docs/operations/homebrew.md).
 
 ## Docs
 

package/bridge-mcp-server.js

@@ -305,36 +305,99 @@ function buildResponse(msg) {
 
 // ── STDIO mode ────────────────────────────────────────────────────────────────
 // CRITICAL: register stdin listener FIRST to avoid race condition.
-// Provider CLIs send `initialize` immediately after spawn; if readline isn't
+// Provider CLIs send `initialize` immediately after spawn; if stdin isn't
 // listening yet the message is lost and the CLI times out (Tools: none).
 
+function writeMcpResponse(resp, framed) {
+  const body = JSON.stringify(resp);
+  if (framed) {
+    process.stdout.write(`Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`);
+  } else {
+    process.stdout.write(body + '\n');
+  }
+}
+
+function handleStdioMessage(msg, framed) {
+  const resp = buildResponse(msg);
+  if (resp) writeMcpResponse(resp, framed);
+}
+
 function startStdio() {
-  const readline = require('readline');
-  const messageQueue = [];
-  let ready = false;
+  let buffer = Buffer.alloc(0);
+
+  function parseContentLengthHeader(header) {
+    for (const line of header.split(/\r?\n/)) {
+      const match = line.match(/^Content-Length:\s*(\d+)\s*$/i);
+      if (match) return Number.parseInt(match[1], 10);
+    }
+    return null;
+  }
 
-  const rl = readline.createInterface({ input: process.stdin, terminal: false });
-  rl.on('line', (line) => {
-    if (!line.trim()) return;
+  function handleJsonPayload(payload, framed) {
+    if (!payload.trim()) return;
     let msg;
-    try { msg = JSON.parse(line); } catch (_) { return; }
-    if (ready) {
-      const resp = buildResponse(msg);
-      if (resp) process.stdout.write(JSON.stringify(resp) + '\n');
-    } else {
-      messageQueue.push(msg);
+    try {
+      msg = JSON.parse(payload);
+    } catch (_) {
+      return;
     }
+    handleStdioMessage(msg, framed);
+  }
+
+  function drain(flush = false) {
+    while (buffer.length) {
+      while (buffer[0] === 0x0a || buffer[0] === 0x0d) buffer = buffer.subarray(1);
+      if (!buffer.length) return;
+
+      const text = buffer.toString('utf8');
+      if (text.toLowerCase().startsWith('content-length:')) {
+        let headerEnd = text.indexOf('\r\n\r\n');
+        let separatorLength = 4;
+        if (headerEnd === -1) {
+          headerEnd = text.indexOf('\n\n');
+          separatorLength = 2;
+        }
+        if (headerEnd === -1) return;
+
+        const header = text.slice(0, headerEnd);
+        const contentLength = parseContentLengthHeader(header);
+        if (!Number.isFinite(contentLength) || contentLength < 0) {
+          buffer = Buffer.alloc(0);
+          return;
+        }
+
+        const bodyStart = Buffer.byteLength(text.slice(0, headerEnd + separatorLength), 'utf8');
+        if (buffer.length < bodyStart + contentLength) return;
+        const body = buffer.subarray(bodyStart, bodyStart + contentLength).toString('utf8');
+        buffer = buffer.subarray(bodyStart + contentLength);
+        handleJsonPayload(body, true);
+        continue;
+      }
+
+      const newline = buffer.indexOf(0x0a);
+      if (newline === -1) {
+        if (!flush) return;
+        const line = buffer.toString('utf8');
+        buffer = Buffer.alloc(0);
+        handleJsonPayload(line, false);
+        return;
+      }
+      const line = buffer.subarray(0, newline).toString('utf8');
+      buffer = buffer.subarray(newline + 1);
+      handleJsonPayload(line, false);
+    }
+  }
+
+  process.stdin.on('data', (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    drain(false);
   });
   // Parent CLI closed stdin → exit so MCP subprocess does not linger and
   // continue accepting writes after its intended session is over.
-  rl.on('close', () => process.exit(0));
-
-  ready = true;
-  for (const msg of messageQueue) {
-    const resp = buildResponse(msg);
-    if (resp) process.stdout.write(JSON.stringify(resp) + '\n');
-  }
-  messageQueue.length = 0;
+  process.stdin.on('end', () => {
+    drain(true);
+    process.exit(0);
+  });
 }
 
 // ── HTTP/SSE mode ─────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xmux-bridge",
-  "version": "1.0.39",
+  "version": "1.0.40",
   "description": "MCP stdio server for XMux teammate responses",
   "bin": {
     "xmux-bridge": "./bridge-mcp-server.js",

package/scripts/setup_xmux_codex_mcp.js

@@ -19,6 +19,7 @@ const LOCAL_PLUGIN_CACHE_VERSION = "local";
 const SKILL_MARKER = ".xmux-managed-skill";
 const DEFAULT_MCP_PACKAGE = "xmux-bridge";
 const DEFAULT_MCP_BIN = "xmux-lead-mcp";
+const DEFAULT_MCP_NPX_PREFIX = path.join(".cache", "xmux", "npm-prefix");
 
 function expandUser(value) {
   const text = String(value || "");
@@ -172,21 +173,33 @@ function node_mcp_config(serverPath) {
   };
 }
 
-function npx_mcp_config(packageSpec, binName = DEFAULT_MCP_BIN) {
+function default_mcp_npx_prefix(configPath = "") {
+  const fallback = path.join(os.homedir(), DEFAULT_MCP_NPX_PREFIX);
+  if (!configPath) return fallback;
+  const configDir = path.dirname(abs(configPath));
+  if (path.basename(configDir) === ".codex") {
+    return path.join(path.dirname(configDir), DEFAULT_MCP_NPX_PREFIX);
+  }
+  return path.join(configDir, DEFAULT_MCP_NPX_PREFIX);
+}
+
+function npx_mcp_config(packageSpec, binName = DEFAULT_MCP_BIN, npxPrefix = "") {
+  const prefix = abs(npxPrefix || process.env.XMUX_MCP_NPX_PREFIX || default_mcp_npx_prefix());
   return {
     mode: "npx",
     command: "npx",
-    args: ["-y", "-p", packageSpec, binName],
+    args: ["--prefix", prefix, "-y", "-p", packageSpec, binName],
     package_spec: packageSpec,
     bin: binName,
-    label: `npx -y -p ${packageSpec} ${binName}`,
+    npx_prefix: prefix,
+    label: `npx --prefix ${prefix} -y -p ${packageSpec} ${binName}`,
   };
 }
 
 function resolve_mcp_config(xmuxInstallDir, opts = {}) {
   if (opts.server_path) return node_mcp_config(opts.server_path);
   const packageSpec = default_mcp_package_spec(xmuxInstallDir, opts.mcp_package, opts.mcp_version);
-  return npx_mcp_config(packageSpec, opts.mcp_bin || DEFAULT_MCP_BIN);
+  return npx_mcp_config(packageSpec, opts.mcp_bin || DEFAULT_MCP_BIN, opts.mcp_npx_prefix || "");
 }
 
 function normalize_mcp_config(mcpConfigOrServerPath, xmuxInstallDir = "", opts = {}) {
@@ -198,6 +211,7 @@ function normalize_mcp_config(mcpConfigOrServerPath, xmuxInstallDir = "", opts =
       server_path: mcpConfigOrServerPath.server_path || "",
       package_spec: mcpConfigOrServerPath.package_spec || "",
       bin: mcpConfigOrServerPath.bin || "",
+      npx_prefix: mcpConfigOrServerPath.npx_prefix || "",
       label: mcpConfigOrServerPath.label || [
         mcpConfigOrServerPath.command,
         ...(mcpConfigOrServerPath.args || []),
@@ -212,6 +226,12 @@ function mcp_args_toml(mcpConfig) {
   return `args = [${mcpConfig.args.map(toml_quote).join(", ")}]`;
 }
 
+function ensure_mcp_runtime_dirs(mcpConfig) {
+  if (mcpConfig.mode === "npx" && mcpConfig.npx_prefix) {
+    fs.mkdirSync(mcpConfig.npx_prefix, { recursive: true });
+  }
+}
+
 function build_block(mcpConfigOrServerPath, xmuxInstallDir) {
   const mcpConfig = normalize_mcp_config(mcpConfigOrServerPath, xmuxInstallDir);
   const pathEnv = resolve_path_with_node();
@@ -665,6 +685,7 @@ function parse_args(argv) {
     mcp_package: "",
     mcp_version: "",
     mcp_bin: DEFAULT_MCP_BIN,
+    mcp_npx_prefix: "",
   };
   for (let i = 0; i < argv.length;) {
     const arg = argv[i];
@@ -687,6 +708,7 @@ function parse_args(argv) {
       "--mcp-package",
       "--mcp-version",
       "--mcp-bin",
+      "--mcp-npx-prefix",
     ].includes(arg) && i + 1 < argv.length) {
       const key = arg.slice(2).replace(/-/g, "_");
       opts[key] = expandUser(argv[i + 1]);
@@ -725,6 +747,7 @@ function resolve_config_path(opts) {
 function main(argv = process.argv.slice(2)) {
   const opts = parse_args(argv);
   const configPath = resolve_config_path(opts);
+  opts.mcp_npx_prefix = abs(opts.mcp_npx_prefix || process.env.XMUX_MCP_NPX_PREFIX || default_mcp_npx_prefix(configPath));
   const scriptInstallDir = path.dirname(path.dirname(abs(__filename)));
   const rawInstallDir = abs(opts.xmux_install_dir || scriptInstallDir);
   const xmuxInstallDir = stable_homebrew_xmux_install_dir(rawInstallDir);
@@ -736,6 +759,8 @@ function main(argv = process.argv.slice(2)) {
     return doctor_codex(configPath, xmuxInstallDir, mcpConfig, opts.skills_dir, opts.quiet);
   }
 
+  ensure_mcp_runtime_dirs(mcpConfig);
+
   let content = remove_xmux_blocks(read_text(configPath));
   if (opts.remove) {
     content = remove_codex_shell_environment(content, xmuxInstallDir);
@@ -788,6 +813,7 @@ module.exports = {
   remove_xmux_blocks,
   build_block,
   default_mcp_package_spec,
+  default_mcp_npx_prefix,
   resolve_mcp_config,
   path_with_xmux_bin,
   ensure_codex_shell_environment,

package/xmux-lead-mcp-server.js

@@ -451,36 +451,94 @@ function buildResponse(msg) {
   return null;
 }
 
+function writeMcpResponse(resp, framed) {
+  const body = JSON.stringify(resp);
+  if (framed) {
+    process.stdout.write(`Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`);
+  } else {
+    process.stdout.write(body + '\n');
+  }
+}
+
+function handleStdioMessage(msg, framed) {
+  const resp = buildResponse(msg);
+  if (resp) writeMcpResponse(resp, framed);
+}
+
 function startStdio() {
-  const readline = require('readline');
-  const messageQueue = [];
-  let ready = false;
+  let buffer = Buffer.alloc(0);
 
-  const rl = readline.createInterface({ input: process.stdin, terminal: false });
-  rl.on('line', (line) => {
-    if (!line.trim()) return;
+  function parseContentLengthHeader(header) {
+    for (const line of header.split(/\r?\n/)) {
+      const match = line.match(/^Content-Length:\s*(\d+)\s*$/i);
+      if (match) return Number.parseInt(match[1], 10);
+    }
+    return null;
+  }
+
+  function handleJsonPayload(payload, framed) {
+    if (!payload.trim()) return;
     let msg;
     try {
-      msg = JSON.parse(line);
+      msg = JSON.parse(payload);
     } catch (_) {
       return;
     }
+    handleStdioMessage(msg, framed);
+  }
 
-    if (ready) {
-      const resp = buildResponse(msg);
-      if (resp) process.stdout.write(JSON.stringify(resp) + '\n');
-    } else {
-      messageQueue.push(msg);
+  function drain(flush = false) {
+    while (buffer.length) {
+      while (buffer[0] === 0x0a || buffer[0] === 0x0d) buffer = buffer.subarray(1);
+      if (!buffer.length) return;
+
+      const text = buffer.toString('utf8');
+      if (text.toLowerCase().startsWith('content-length:')) {
+        let headerEnd = text.indexOf('\r\n\r\n');
+        let separatorLength = 4;
+        if (headerEnd === -1) {
+          headerEnd = text.indexOf('\n\n');
+          separatorLength = 2;
+        }
+        if (headerEnd === -1) return;
+
+        const header = text.slice(0, headerEnd);
+        const contentLength = parseContentLengthHeader(header);
+        if (!Number.isFinite(contentLength) || contentLength < 0) {
+          buffer = Buffer.alloc(0);
+          return;
+        }
+
+        const bodyStart = Buffer.byteLength(text.slice(0, headerEnd + separatorLength), 'utf8');
+        if (buffer.length < bodyStart + contentLength) return;
+        const body = buffer.subarray(bodyStart, bodyStart + contentLength).toString('utf8');
+        buffer = buffer.subarray(bodyStart + contentLength);
+        handleJsonPayload(body, true);
+        continue;
+      }
+
+      const newline = buffer.indexOf(0x0a);
+      if (newline === -1) {
+        if (!flush) return;
+        const line = buffer.toString('utf8');
+        buffer = Buffer.alloc(0);
+        handleJsonPayload(line, false);
+        return;
+      }
+      const line = buffer.subarray(0, newline).toString('utf8');
+      buffer = buffer.subarray(newline + 1);
+      handleJsonPayload(line, false);
     }
-  });
-  rl.on('close', () => process.exit(0));
-
-  ready = true;
-  for (const msg of messageQueue) {
-    const resp = buildResponse(msg);
-    if (resp) process.stdout.write(JSON.stringify(resp) + '\n');
   }
-  messageQueue.length = 0;
+
+  process.stdin.on('data', (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    drain(false);
+  });
+  process.stdin.on('end', () => {
+    drain(true);
+    process.exit(0);
+  });
 }
 
 startStdio();

package/xmux.zsh

@@ -71,7 +71,7 @@ _xmux_refresh_home() {
 
 _xmux_refresh_paths
 
-XMUX_VERSION="1.0.39"
+XMUX_VERSION="1.0.40"
 XMUX_LEAD_AGENT="${XMUX_LEAD_AGENT:-codex-lead}"
 
 _xmux_q() {
@@ -4208,8 +4208,8 @@ _xmux_run_codex_setup_script() {
 
 _xmux_setup_codex_usage() {
   cat >&2 <<'EOF'
-Usage: xmux setup-codex [--skills-dir <dir>] [--without-skills] [--mcp-package <package[@version]>] [--mcp-version <version>]
-       xmux doctor-codex [--mcp-package <package[@version]>] [--mcp-version <version>]
+Usage: xmux setup-codex [--skills-dir <dir>] [--without-skills] [--mcp-package <package[@version]>] [--mcp-version <version>] [--mcp-npx-prefix <dir>]
+       xmux doctor-codex [--mcp-package <package[@version]>] [--mcp-version <version>] [--mcp-npx-prefix <dir>]
        xmux remove-codex
 EOF
 }
@@ -4224,7 +4224,7 @@ _xmux_cmd_setup_codex() {
         setup_args+=("$arg")
         shift
         ;;
-      --home|--project|--skills-dir|--mcp-package|--mcp-version|--mcp-bin)
+      --home|--project|--skills-dir|--mcp-package|--mcp-version|--mcp-bin|--mcp-npx-prefix)
         [[ $# -ge 2 ]] || { echo "error: $arg requires a value." >&2; return 1; }
         setup_args+=("$arg" "$2")
         shift 2
@@ -4253,7 +4253,7 @@ _xmux_cmd_doctor_codex() {
         doctor_args+=("$arg")
         shift
         ;;
-      --home|--project|--skills-dir|--mcp-package|--mcp-version|--mcp-bin)
+      --home|--project|--skills-dir|--mcp-package|--mcp-version|--mcp-bin|--mcp-npx-prefix)
         [[ $# -ge 2 ]] || { echo "error: $arg requires a value." >&2; return 1; }
         doctor_args+=("$arg" "$2")
         shift 2