xmux-bridge 1.0.39

package/README.md

@@ -0,0 +1,219 @@
+# XMux
+
+XMux is a Codex-led tmux teammate runtime. The single user-facing command is
+`xmux`; Codex is always the lead, and supported teammates are Claude, Gemini,
+and Copilot.
+
+<table>
+  <tr>
+    <th>Create</th>
+    <th>Shutdown</th>
+  </tr>
+  <tr>
+    <td><img src="docs/screenshots/team-create.png" alt="XMux team creation" width="100%"></td>
+    <td><img src="docs/screenshots/team-shutdown.png" alt="XMux team shutdown" width="100%"></td>
+  </tr>
+</table>
+
+## How to Use
+
+Install XMux with Homebrew:
+
+```bash
+brew tap DwvN-Lee/xmux
+brew install xmux
+```
+
+Homebrew owns the stable runtime under `$(brew --prefix)/opt/xmux/libexec`.
+The installed `xmux` command exports that path as `XMUX_INSTALL_DIR` and then
+execs the runtime wrapper in `libexec/bin/xmux`. Ad hoc local directories, npx
+caches, and zsh plugin directories are not part of the normal runtime path.
+
+Configure Codex integration explicitly:
+
+```bash
+xmux setup-codex
+xmux doctor-codex
+```
+
+Homebrew installs the XMux CLI/runtime only. `xmux setup-codex` is the command
+that mutates `~/.codex`: it registers the `xmux_lead` MCP server through the
+versioned npm package, points that MCP runtime back at Homebrew with
+`XMUX_INSTALL_DIR`, adds the installed `xmux` path to Codex shell policy,
+installs the scoped XMux command rule, and refreshes available XMux skills
+under `~/.codex/skills`. Runtime-only installs do not include skill source
+files, so pass an external skill source when refreshing skills:
+
+```bash
+xmux setup-codex --skills-dir /path/to/xmux-skills
+```
+
+`XMUX_CODEX_SKILLS_DIR` provides the same source path for automation. Without
+`--skills-dir` or `XMUX_CODEX_SKILLS_DIR`, `setup-codex` skips skill refresh
+and leaves existing user-owned skills untouched.
+
+Start the Codex lead from the target project directory:
+
+```bash
+xmux -n refactor
+```
+
+XMux displays short names with the project prefix, such as `XMux/refactor`.
+Raw `tmux ls` may show a slash-free internal session key; use `xmux sessions`
+and `xmux attach XMux/refactor` for user-facing runtime operations.
+
+This is the only command users normally need to run directly. After the lead is
+open, ask Codex for teammate work in natural language. For example:
+
+- "Use Gemini and Copilot to review this change."
+- "Ask Claude to look for edge cases before implementation."
+- "Ask Copilot for a repository-aware implementation check."
+
+Codex then manages the XMux lifecycle through hidden agent-facing commands such as:
+
+```bash
+xmux teamStatus
+xmux teammateAdd -t refactor claude gemini copilot
+xmux teammateShutdown -t refactor gemini-worker
+xmux teamShutdown -t refactor --reason manual-shutdown
+```
+
+Those commands are hidden from the default `xmux --help` output. Use
+`xmux help agent` when agent-facing lifecycle syntax is needed for automation
+or troubleshooting.
+
+To start a detached or scripted team outside an interactive lead session, Codex
+automation can use:
+
+```bash
+xmux teamCreate -t refactor-team -n refactor claude gemini copilot
+```
+
+XMux is agent friendly: when the user explicitly asks to use teammates, the
+Codex lead may create the scoped team, attach requested teammates, send mailbox
+requests, wait for responses, and perform bounded retries without asking the
+user to approve each XMux step. Runtime permission prompts are only for the
+tooling boundary, such as tmux access from a sandboxed process.
+
+Inspect and operate a team when debugging:
+
+```bash
+xmux teamStatus -t refactor
+xmux doctor -t refactor --log-lines 0
+xmux teammateStatus -t refactor
+xmux paneInfo gemini-worker -t refactor
+xmux teammateShutdown -t refactor gemini-worker
+xmux teamShutdown -t refactor --reason manual-shutdown
+```
+
+Lower-level diagnostics are also hidden from the default help. Use
+`xmux help debug` for the full troubleshooting surface.
+
+`xmux teammateShutdown` keeps the team live. `xmux teamShutdown` is team-wide
+and archives the team state while preserving inboxes, requests, request ids,
+and events. Lead `/exit` triggers shutdown/archive by default; start with
+`--keep-team-on-lead-exit` to leave teammates running for debugging.
+
+Unsupported legacy paths fail explicitly because Codex is the XMux lead, not a
+teammate:
+
+```bash
+xmux codex
+xmux start --codex
+xmux start -c
+```
+
+## Agent-Managed Internals
+
+This section describes the runtime work handled by Codex and XMux automation.
+Users normally do not run these steps directly.
+
+Runtime state is project-local:
+
+```text
+<project>/.codex/xmux/
+  teams/<team>/
+    team.json
+    inboxes/
+    requests/
+    events.jsonl
+  archive/<timestamp>-<team>/
+    archive.json
+    team.json
+    inboxes/
+    requests/
+    events.jsonl
+```
+
+Runtime path environment names are now split by responsibility:
+
+```text
+XMUX_INSTALL_DIR  # XMux source/install directory
+XMUX_PROJECT_DIR  # project root where Codex is working
+XMUX_STATE_DIR    # project-local runtime state, usually $XMUX_PROJECT_DIR/.codex/xmux
+```
+
+Codex uses the normal user runtime under `~/.codex`. XMux does not create an
+isolated Codex home for a team, and Codex teammate mode is unsupported.
+
+Agent automation uses `xmux` from the Codex shell policy PATH that
+`xmux setup-codex` writes to `~/.codex/config.toml`. If that wrapper is
+unavailable, it falls back to the explicit XMux executable. The user-facing
+bootstrap command remains `xmux -n <session>` after setup; ad hoc local paths
+and shell-loading details are not part of the agent contract.
+
+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
+`XMUX_PROJECT_DIR`/`XMUX_STATE_DIR`; those values come from the active
+`xmux -n <session>` lead runtime.
+
+Provider teammates write responses through `bridge-mcp-server.js`, using the
+team runtime environment prepared by XMux. The bridge and mailbox paths are
+implementation details behind Codex-led teammate orchestration.
+
+The explicit Codex setup installs available XMux skills under
+`~/.codex/skills` only from `--skills-dir` or `XMUX_CODEX_SKILLS_DIR`.
+Homebrew does not install Codex skills or repo-local plugin files; normal
+runtime operation depends on the installed `xmux` command and
+`XMUX_INSTALL_DIR`, not a checkout path.
+
+The plugin skill source of truth is `plugins/xmux/skills`; the top-level
+`skills/` directory is a mirrored distribution copy for explicit skill refresh
+workflows. Users explicitly invoke Codex skills with `$`, for example
+`$xmux-teams`. The official XMux skills cover agent-facing orchestration flows:
+
+```text
+$xmux-teams
+$xmux-claude
+$xmux-gemini
+$xmux-copilot
+$xmux-diagnosis
+$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).
+
+## Docs
+
+- [Documentation index](docs/README.md)
+- [Codex lead runtime](docs/runtime/codex-lead.md)
+- [Homebrew distribution](docs/operations/homebrew.md)
+- [Wrapper-first debugging](docs/operations/debugging.md)
+- [Claude teammate](docs/teammates/claude.md)
+- [Gemini teammate](docs/teammates/gemini.md)
+- [Copilot teammate](docs/teammates/copilot.md)

package/bin/xmux

@@ -0,0 +1,9 @@
+#!/usr/bin/env zsh
+set -euo pipefail
+
+script_path="${0:A}"
+script_dir="${script_path:h}"
+install_dir="${script_dir:h}"
+
+source "$install_dir/xmux.zsh"
+xmux "$@"

package/bridge-mcp-server.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+/**
+ * bridge-mcp-server.js
+ * Minimal MCP server for xmux.
+ * Exposes write_to_lead(text, summary?) so Claude, Gemini, and Copilot
+ * teammates can write directly to the XMux lead inbox.
+ *
+ * Modes:
+ *   stdio (default): JSON-RPC over stdin/stdout
+ *   HTTP/SSE:        --http <port>  →  GET /sse + POST /messages
+ *
+ * Config resolution order (first wins):
+ *   1. CLI args: --outbox <path> --agent <name> --team <name>
+ *   2. Env vars: XMUX_OUTBOX, XMUX_AGENT, XMUX_TEAM
+ *
+ * If neither is provided the server exits immediately. A previous
+ * `.bridge-<agent>.env` mtime-scan fallback was removed: it caused
+ * standalone CLI sessions (notably Gemini launched outside xmux-gemini)
+ * to silently adopt an unrelated active team's outbox + agent identity
+ * and forge write_to_lead entries into the wrong outbox. See
+ * docs/investigations/orphan-env-fallback-2026-04-20.md.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+// ── Parse ALL CLI args first (determines mode) ───────────────────────────────
+
+let AGENT_NAME = '';
+let OUTBOX = '';
+let HTTP_PORT = 0; // 0 = stdio mode
+let XMUX_TEAM = '';
+let XMUX_INSTALL_DIR = '';
+
+const cliArgs = process.argv.slice(2);
+for (let i = 0; i < cliArgs.length; i++) {
+  if (cliArgs[i] === '--outbox' && cliArgs[i + 1]) OUTBOX = cliArgs[++i];
+  if (cliArgs[i] === '--agent'  && cliArgs[i + 1]) AGENT_NAME = cliArgs[++i];
+  if (cliArgs[i] === '--team'   && cliArgs[i + 1]) XMUX_TEAM = cliArgs[++i];
+  if (cliArgs[i] === '--http'   && cliArgs[i + 1]) HTTP_PORT = parseInt(cliArgs[++i], 10);
+}
+
+// ── Env vars ─────────────────────────────────────────────────────────────────
+
+if (!OUTBOX)     OUTBOX     = process.env.XMUX_OUTBOX || '';
+if (!AGENT_NAME) AGENT_NAME = process.env.XMUX_AGENT  || '';
+if (!XMUX_TEAM)  XMUX_TEAM  = process.env.XMUX_TEAM || '';
+XMUX_INSTALL_DIR = process.env.XMUX_INSTALL_DIR
+  ? path.resolve(process.env.XMUX_INSTALL_DIR)
+  : '';
+
+// ── Fail fast: reject spawns that never got a team identity ─────────────────
+// A standalone CLI (e.g. user runs `gemini` in ~/Desktop) can spawn this
+// MCP server via a generic `xmux-bridge` entry in its settings. Without
+// explicit OUTBOX/AGENT we refuse to serve — previously a mtime-based
+// .bridge-<agent>.env fallback would pick the most-recently-active team
+// and the standalone CLI's write_to_lead calls ended up in that team's
+// outbox under the wrong `from` (the orphan-env bug, 2026-04-20).
+
+if (!OUTBOX || !AGENT_NAME) {
+  process.stderr.write(
+    '[xmux-bridge] fatal: no team identity configured.\n' +
+    '  Provide --outbox <path> --agent <name> OR env XMUX_OUTBOX/XMUX_AGENT.\n' +
+    '  Standalone CLI sessions not launched via xmux claude, xmux gemini, or xmux copilot must not\n' +
+    '  register xmux-bridge as an MCP server — remove the entry from that tool\'s\n' +
+    '  settings if you see this message.\n'
+  );
+  process.exit(1);
+}
+
+// ── Path validation ──────────────────────────────────────────────────────────
+
+function validateOutboxPath(p) {
+  const resolved = path.resolve(p);
+  const home = process.env.HOME || '';
+  const stateDir = process.env.XMUX_STATE_DIR || path.resolve(home, '.codex', 'xmux');
+  const allowedBases = [
+    path.resolve(stateDir),
+  ];
+  return allowedBases.some(base => resolved.startsWith(base + path.sep)) &&
+    resolved.endsWith('.json') && !p.includes('..');
+}
+
+// ── Outbox write ─────────────────────────────────────────────────────────────
+
+function nowTs() {
+  return new Date().toISOString().replace(/(\.\d{3})\d*Z/, '$1Z');
+}
+
+function atomicWrite(filePath, data) {
+  const dir = path.dirname(path.resolve(filePath));
+  const tmp = path.join(dir, `.tmp-${crypto.randomBytes(6).toString('hex')}.json`);
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+  fs.renameSync(tmp, filePath);
+}
+
+// mkdir-based cross-process file lock. Coordinates with the Node mailbox
+// runtime that uses the same `<path>.lock.d` mutex.
+// Prevents lost updates when mailbox writers concurrently read-modify-write
+// the same lead inbox JSON file.
+function withLock(targetPath, fn) {
+  const lockPath = targetPath + '.lock.d';
+  let acquired = false;
+  for (let i = 0; i < 200; i++) {
+    try {
+      fs.mkdirSync(lockPath);
+      acquired = true;
+      break;
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+      const start = Date.now();
+      while (Date.now() - start < 25) {} // busy-wait 25ms
+    }
+  }
+  if (!acquired) throw new Error(`could not acquire lock on ${targetPath}`);
+  try {
+    return fn();
+  } finally {
+    try { fs.rmdirSync(lockPath); } catch (_) {}
+  }
+}
+
+// Cap with read-message preference: when over cap, drop oldest READ
+// message first; only drop oldest unread as a last resort. Prevents
+// the double-push (response + idle_notification) from silently losing
+// unread messages at the 50-cap boundary.
+function trimToCap(msgs, cap) {
+  while (msgs.length > cap) {
+    const idx = msgs.findIndex(m => m.read);
+    if (idx >= 0) msgs.splice(idx, 1);
+    else msgs.shift();
+  }
+  return msgs;
+}
+
+function mailboxInstallBases() {
+  const seen = new Set();
+  const bases = [];
+  for (const candidate of [XMUX_INSTALL_DIR, __dirname]) {
+    if (!candidate) continue;
+    const resolved = path.resolve(candidate);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    bases.push(resolved);
+  }
+  return bases;
+}
+
+function resolveMailboxBackend() {
+  for (const base of mailboxInstallBases()) {
+    const nodeCli = path.join(base, 'dist', 'bin', 'xmux-mailbox.js');
+    if (fs.existsSync(nodeCli)) {
+      return {
+        kind: 'node',
+        command: process.execPath || 'node',
+        prefixArgs: [nodeCli],
+      };
+    }
+  }
+  return null;
+}
+
+function writeToXMuxMailbox(text, summary, requestId, status) {
+  const backend = resolveMailboxBackend();
+  if (!backend) return null;
+  if (!XMUX_TEAM) return null;
+
+  const args = [
+    ...backend.prefixArgs,
+    'write-response',
+    XMUX_TEAM,
+    '--from',
+    AGENT_NAME,
+    '--text',
+    text,
+    '--status',
+    status || 'done',
+  ];
+  if (summary) args.push('--summary', summary);
+  if (requestId) args.push('--request-id', requestId);
+
+  const result = spawnSync(backend.command, args, {
+    env: { ...process.env },
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024,
+  });
+  if (result.error) return `error: ${result.error.message || result.error}`;
+  if (result.status !== 0) {
+    const detail = String(result.stderr || result.stdout || '').trim();
+    return `error: xmux mailbox write failed${detail ? `: ${detail}` : ''}`;
+  }
+  return 'ok: response delivered to lead';
+}
+
+function writeToLeadImpl(text, summary, requestId, status) {
+  if (!OUTBOX)                    return 'error: XMUX_OUTBOX not set';
+  if (!validateOutboxPath(OUTBOX)) return 'error: XMUX_OUTBOX path is invalid or outside allowed directory';
+  if (!AGENT_NAME)                return 'error: AGENT_NAME not set (pass --agent or set XMUX_AGENT)';
+
+  const xmuxResult = writeToXMuxMailbox(text, summary, requestId, status);
+  if (xmuxResult !== null) return xmuxResult;
+
+  try {
+    return withLock(OUTBOX, () => {
+      let msgs = [];
+      try { msgs = JSON.parse(fs.readFileSync(OUTBOX, 'utf-8')); } catch (_) { msgs = []; }
+      const ts1 = nowTs();
+      const entry = { from: AGENT_NAME, text, timestamp: ts1, read: false };
+      if (summary) entry.summary = summary;
+      if (requestId) entry.request_id = requestId;
+      if (status) entry.status = status;
+      msgs.push(entry);
+      trimToCap(msgs, 50);
+      const ts2 = nowTs();
+      const idlePayload = JSON.stringify({
+        type: 'idle_notification', from: AGENT_NAME, idleReason: 'available', timestamp: ts2,
+      });
+      msgs.push({ from: AGENT_NAME, text: idlePayload, timestamp: ts2, read: false });
+      trimToCap(msgs, 50);
+      atomicWrite(OUTBOX, msgs);
+      return 'ok: response delivered to lead';
+    });
+  } catch (exc) {
+    return `error: ${exc}`;
+  }
+}
+
+// ── Tool schema ───────────────────────────────────────────────────────────────
+
+const TOOL_SCHEMA = {
+  name: 'write_to_lead',
+  description:
+    'Send your completed response to the Codex lead through the XMux mailbox.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      text:    { type: 'string', description: 'Your full response text.' },
+      summary: { type: 'string', description: 'Optional short summary (first sentence, < 60 chars).' },
+      request_id: { type: 'string', description: 'Optional XMux request id this response completes.' },
+      status: { type: 'string', description: 'Optional response status, defaults to done.' },
+    },
+    required: ['text'],
+  },
+};
+
+// ── MCP request handler (returns response object or null) ─────────────────────
+
+function buildResponse(msg) {
+  const method = msg.method || '';
+  const id = msg.id !== undefined ? msg.id : null;
+
+  if (method === 'initialize') {
+    const params = msg.params || {};
+    return {
+      jsonrpc: '2.0', id,
+      result: {
+        protocolVersion: params.protocolVersion || '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'xmux-bridge', version: '0.3.0' },
+      },
+    };
+  }
+
+  if (method === 'notifications/initialized' || method === 'initialized') {
+    return null;
+  }
+
+  if (method === 'tools/list') {
+    return { jsonrpc: '2.0', id, result: { tools: [TOOL_SCHEMA] } };
+  }
+
+  if (method === 'resources/list') {
+    return { jsonrpc: '2.0', id, result: { resources: [] } };
+  }
+
+  if (method === 'resources/templates/list') {
+    return { jsonrpc: '2.0', id, result: { resourceTemplates: [] } };
+  }
+
+  if (method === 'tools/call') {
+    const params = msg.params || {};
+    if (params.name === 'write_to_lead') {
+      const args = params.arguments || {};
+      const result = writeToLeadImpl(
+        args.text || '',
+        args.summary || '',
+        args.request_id || args.requestId || '',
+        args.status || 'done',
+      );
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: result }] } };
+    }
+    return { jsonrpc: '2.0', id, error: { code: -32601, message: 'Unknown tool' } };
+  }
+
+  if (id !== null) {
+    return { jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown method: ${method}` } };
+  }
+
+  return null;
+}
+
+// ── STDIO mode ────────────────────────────────────────────────────────────────
+// CRITICAL: register stdin listener FIRST to avoid race condition.
+// Provider CLIs send `initialize` immediately after spawn; if readline isn't
+// listening yet the message is lost and the CLI times out (Tools: none).
+
+function startStdio() {
+  const readline = require('readline');
+  const messageQueue = [];
+  let ready = false;
+
+  const rl = readline.createInterface({ input: process.stdin, terminal: false });
+  rl.on('line', (line) => {
+    if (!line.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);
+    }
+  });
+  // 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;
+}
+
+// ── HTTP/SSE mode ─────────────────────────────────────────────────────────────
+// Implements the MCP HTTP+SSE transport:
+//   GET  /sse            → SSE stream; first event is `endpoint` with POST URL
+//   POST /messages?sessionId=<id>  → JSON-RPC request; response via SSE `message` event
+
+function startHttpServer(port) {
+  const http = require('http');
+  const sessions = new Map(); // sessionId → SSE response
+
+  const server = http.createServer((req, res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    const reqUrl = new URL(req.url, `http://127.0.0.1:${port}`);
+
+    if (req.method === 'GET' && reqUrl.pathname === '/sse') {
+      const sessionId = crypto.randomBytes(8).toString('hex');
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+      });
+      sessions.set(sessionId, res);
+      res.write(`event: endpoint\ndata: /messages?sessionId=${sessionId}\n\n`);
+      req.on('close', () => sessions.delete(sessionId));
+      return;
+    }
+
+    if (req.method === 'POST' && reqUrl.pathname === '/messages') {
+      const sessionId = reqUrl.searchParams.get('sessionId');
+      const sseRes = sessions.get(sessionId);
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        res.writeHead(202);
+        res.end();
+        let msg;
+        try { msg = JSON.parse(body); } catch (_) { return; }
+        const resp = buildResponse(msg);
+        if (resp && sseRes) {
+          sseRes.write(`event: message\ndata: ${JSON.stringify(resp)}\n\n`);
+        }
+      });
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  });
+
+  server.listen(port, '127.0.0.1', () => {
+    process.stderr.write(`[xmux-bridge] HTTP MCP server on http://127.0.0.1:${port}/sse\n`);
+  });
+}
+
+// ── Start ─────────────────────────────────────────────────────────────────────
+
+if (HTTP_PORT > 0) {
+  startHttpServer(HTTP_PORT);
+} else {
+  startStdio();
+}

package/dist/bin/xmux-mailbox.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+'use strict';
+
+const { main } = require('../mailbox/cli');
+
+process.exit(main(process.argv.slice(2)));

package/dist/mailbox/cli.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../../src/mailbox/cli');

package/dist/mailbox/core.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../../src/mailbox/core');

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "xmux-bridge",
+  "version": "1.0.39",
+  "description": "MCP stdio server for XMux teammate responses",
+  "bin": {
+    "xmux-bridge": "./bridge-mcp-server.js",
+    "xmux-lead-mcp": "./xmux-lead-mcp-server.js",
+    "xmux-mailbox": "./dist/bin/xmux-mailbox.js",
+    "xmux": "./bin/xmux",
+    "xmux-bridge-relay": "./xmux-bridge.zsh"
+  },
+  "files": [
+    "bridge-mcp-server.js",
+    "xmux-lead-mcp-server.js",
+    "xmux-bridge.zsh",
+    "bin/xmux",
+    "xmux.zsh",
+    "scripts/*.js",
+    "dist/bin/xmux-mailbox.js",
+    "dist/mailbox",
+    "src/runtime",
+    "src/mailbox"
+  ],
+  "keywords": [
+    "mcp",
+    "claude",
+    "gemini",
+    "copilot",
+    "tmux",
+    "teammate"
+  ],
+  "author": "DwvN-Lee",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DwvN-Lee/XMux.git"
+  }
+}