xmux-bridge 1.0.39

package/src/runtime/errors.js

@@ -0,0 +1,12 @@
+'use strict';
+
+class MailboxError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'MailboxError';
+  }
+}
+
+module.exports = {
+  MailboxError,
+};

package/src/runtime/json.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const { MailboxError } = require('./errors');
+
+function isPlainObject(value) {
+  return Boolean(value) && Object.prototype.toString.call(value) === '[object Object]';
+}
+
+function sortKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeys);
+  }
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortKeys(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+function ensureAscii(text) {
+  return text.replace(/[^\x00-\x7f]/g, (ch) => {
+    const code = ch.charCodeAt(0);
+    return `\\u${code.toString(16).padStart(4, '0')}`;
+  });
+}
+
+function toJsonString(data, pretty = false) {
+  const normalized = sortKeys(data);
+  const json = JSON.stringify(normalized, null, pretty ? 2 : 0);
+  return ensureAscii(json);
+}
+
+function readJson(filePath, defaultValue) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      return defaultValue;
+    }
+    if (err instanceof SyntaxError) {
+      throw new MailboxError(`invalid JSON in ${filePath}: ${err.message}`);
+    }
+    throw err;
+  }
+}
+
+function atomicWriteJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmpPath = path.join(
+    path.dirname(filePath),
+    `.tmp-${crypto.randomBytes(6).toString('hex')}.json`,
+  );
+  fs.writeFileSync(tmpPath, `${toJsonString(data, true)}\n`, 'utf8');
+  fs.renameSync(tmpPath, filePath);
+}
+
+function printJson(data) {
+  process.stdout.write(`${toJsonString(data, false)}\n`);
+}
+
+module.exports = {
+  atomicWriteJson,
+  isPlainObject,
+  printJson,
+  readJson,
+  toJsonString,
+};

package/src/runtime/lock.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { sleepMs } = require('./time');
+
+function withFileLock(targetPath, fn, attempts = 200, sleepDelayMs = 25) {
+  const lockDir = `${targetPath}.lock.d`;
+  const parentDir = path.dirname(lockDir) || '.';
+
+  try {
+    fs.mkdirSync(parentDir, { recursive: true });
+  } catch (_) {
+    // Parent creation can fail for permission/race reasons; mkdir for lock
+    // will surface the actionable error.
+  }
+
+  let acquired = false;
+  for (let i = 0; i < attempts; i += 1) {
+    try {
+      fs.mkdirSync(lockDir);
+      acquired = true;
+      break;
+    } catch (err) {
+      if (err && err.code === 'EEXIST') {
+        sleepMs(sleepDelayMs);
+        continue;
+      }
+      if (err && err.code === 'ENOENT') {
+        break;
+      }
+      throw err;
+    }
+  }
+
+  if (!acquired) {
+    throw new Error(`could not acquire lock on ${targetPath}`);
+  }
+
+  try {
+    return fn();
+  } finally {
+    try {
+      fs.rmdirSync(lockDir);
+    } catch (err) {
+      if (!err || err.code !== 'ENOENT') {
+        // Ignore lock cleanup races; stale lock handling is best-effort.
+      }
+    }
+  }
+}
+
+module.exports = {
+  withFileLock,
+};

package/src/runtime/time.js

@@ -0,0 +1,27 @@
+'use strict';
+
+function nowTs() {
+  return new Date().toISOString();
+}
+
+function sleepMs(ms) {
+  const waitMs = Math.max(0, Number(ms) || 0);
+  if (waitMs <= 0) {
+    return;
+  }
+  try {
+    const buffer = new SharedArrayBuffer(4);
+    const view = new Int32Array(buffer);
+    Atomics.wait(view, 0, 0, waitMs);
+  } catch (_) {
+    const end = Date.now() + waitMs;
+    while (Date.now() < end) {
+      // busy wait fallback
+    }
+  }
+}
+
+module.exports = {
+  nowTs,
+  sleepMs,
+};

package/xmux-bridge.zsh

@@ -0,0 +1,481 @@
+#!/usr/bin/env zsh
+# xmux-bridge.zsh
+# Provider-neutral XMux inbox relay. It polls a teammate inbox under
+# <project>/.codex/xmux/teams/<team>/inboxes/<agent>.json and pastes unread
+# messages into the target tmux pane.
+
+set -uo pipefail
+
+if [[ -n "${XMUX_BRIDGE_PATH:-}" ]]; then
+  PATH="$XMUX_BRIDGE_PATH"
+else
+  PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:$PATH"
+fi
+_XMUX_BRIDGE_SOURCED_DIR="${${(%):-%x}:A:h}"
+TMUX_BIN="${XMUX_TMUX_BIN:-tmux}"
+NODE_BIN="${XMUX_NODE_BIN:-node}"
+
+_xmux_tmux() {
+  command "$TMUX_BIN" "$@"
+}
+
+if [[ -n "${XMUX_INSTALL_DIR:-}" ]]; then
+  XMUX_INSTALL_DIR="${XMUX_INSTALL_DIR:A}"
+else
+  XMUX_INSTALL_DIR="$_XMUX_BRIDGE_SOURCED_DIR"
+fi
+export XMUX_INSTALL_DIR
+XMUX_MAILBOX_NODE_CLI="$XMUX_INSTALL_DIR/dist/bin/xmux-mailbox.js"
+
+_xmux_node() {
+  command "$NODE_BIN" "$@"
+}
+
+_xmux_mailbox_cli() {
+  [[ -f "$XMUX_MAILBOX_NODE_CLI" ]] || return 127
+  _xmux_node "$XMUX_MAILBOX_NODE_CLI" "$@"
+}
+
+_xmux_bridge_project_root() {
+  local dir="${1:-$PWD}"
+  dir="${dir:A}"
+  while [[ "$dir" != "/" && -n "$dir" ]]; do
+    if [[ -e "$dir/.git" ]]; then
+      print -r -- "$dir"
+      return
+    fi
+    dir="${dir:h}"
+  done
+  print -r -- "${1:-$PWD}"
+}
+
+if [[ -n "${XMUX_PROJECT_DIR:-}" ]]; then
+  XMUX_PROJECT_DIR="${XMUX_PROJECT_DIR:A}"
+else
+  XMUX_PROJECT_DIR="$(_xmux_bridge_project_root "$PWD")"
+fi
+export XMUX_PROJECT_DIR
+
+if [[ -n "${XMUX_STATE_DIR:-}" ]]; then
+  XMUX_STATE_DIR="${XMUX_STATE_DIR:A}"
+else
+  XMUX_STATE_DIR="$XMUX_PROJECT_DIR/.codex/xmux"
+fi
+export XMUX_STATE_DIR
+unset XMUX_DIR XMUX_HOME 2>/dev/null || true
+
+XMUX_LEAD_AGENT="${XMUX_LEAD_AGENT:-codex-lead}"
+
+PANE_ID=""
+TEAM_NAME=""
+AGENT_NAME=""
+PROVIDER=""
+INBOX=""
+TIMEOUT=60
+IDLE_PATTERN=""
+POLL_INTERVAL=0.5
+SUBMIT_DELAY="${XMUX_SUBMIT_DELAY:-0.2}"
+
+while getopts "p:T:a:i:x:w:d:P:" opt; do
+  case "$opt" in
+    p) PANE_ID="$OPTARG" ;;
+    T) TEAM_NAME="$OPTARG" ;;
+    a) AGENT_NAME="$OPTARG" ;;
+    P) PROVIDER="$OPTARG" ;;
+    i) INBOX="$OPTARG" ;;
+    x) TIMEOUT="$OPTARG" ;;
+    w) IDLE_PATTERN="$OPTARG" ;;
+    d) SUBMIT_DELAY="$OPTARG" ;;
+    *) echo "Usage: $0 -p <pane_id> -T <team> -a <agent> [-P <provider>] [-i <inbox>] [-x <timeout>] [-w <idle_pattern>] [-d <submit_delay>]" >&2; exit 1 ;;
+  esac
+done
+
+[[ -n "$PANE_ID" ]] || { echo "error: -p <pane_id> required" >&2; exit 1; }
+[[ -n "$TEAM_NAME" ]] || { echo "error: -T <team> required" >&2; exit 1; }
+[[ -n "$AGENT_NAME" ]] || { echo "error: -a <agent> required" >&2; exit 1; }
+
+TEAM_DIR="$XMUX_STATE_DIR/teams/$TEAM_NAME"
+INBOX_DIR="$TEAM_DIR/inboxes"
+BRIDGE_PID_FILE="$TEAM_DIR/.${AGENT_NAME}-bridge.pid"
+BRIDGE_ENV_FILE="$TEAM_DIR/.bridge-${AGENT_NAME}.env"
+[[ -n "$INBOX" ]] || INBOX="$INBOX_DIR/$AGENT_NAME.json"
+OUTBOX="$INBOX_DIR/$XMUX_LEAD_AGENT.json"
+
+mkdir -p "$INBOX_DIR"
+[[ -f "$INBOX" ]] || print -r -- '[]' > "$INBOX"
+[[ -f "$OUTBOX" ]] || print -r -- '[]' > "$OUTBOX"
+
+wait_for_idle() {
+  [[ -z "$IDLE_PATTERN" ]] && return 0
+  local elapsed=0
+  while (( elapsed < TIMEOUT )); do
+    if _xmux_tmux capture-pane -t "$PANE_ID" -p 2>/dev/null | grep -v '^[[:space:]]*$' | tail -8 | grep -qE "$IDLE_PATTERN"; then
+      return 0
+    fi
+    sleep 1
+    (( elapsed++ ))
+  done
+  echo "[xmux-bridge] warning: idle timeout after ${TIMEOUT}s for $AGENT_NAME" >&2
+  return 1
+}
+
+read_unread() {
+  _xmux_node - "$INBOX" <<'NODE'
+const fs = require('fs');
+
+const inboxPath = process.argv[2];
+let raw = '';
+try {
+  raw = fs.readFileSync(inboxPath, 'utf8');
+} catch (error) {
+  if (error && error.code === 'ENOENT') {
+    process.stdout.write('');
+    process.exit(0);
+  }
+  throw error;
+}
+
+let messages;
+try {
+  messages = JSON.parse(raw);
+} catch (error) {
+  const detail = error && error.message ? error.message : String(error);
+  console.error(`read_unread: JSON parse error in ${inboxPath}: ${detail}`);
+  process.exit(1);
+}
+
+if (!Array.isArray(messages)) {
+  process.stdout.write('');
+  process.exit(0);
+}
+
+for (const message of messages) {
+  if (message && typeof message === 'object' && !message.read) {
+    process.stdout.write(JSON.stringify(message));
+    break;
+  }
+}
+NODE
+}
+
+parse_message() {
+  _xmux_node - "$1" <<'NODE'
+const message = JSON.parse(process.argv[2] || '{}');
+
+const hasText = Object.prototype.hasOwnProperty.call(message, 'text');
+const hasMessage = Object.prototype.hasOwnProperty.call(message, 'message');
+const rawText = hasText ? message.text : (hasMessage ? message.message : '');
+let nested = null;
+let text = '';
+
+if (rawText && typeof rawText === 'object') {
+  text = JSON.stringify(rawText);
+  if (!Array.isArray(rawText)) nested = rawText;
+} else if (typeof rawText === 'string') {
+  text = rawText;
+  try {
+    const candidate = JSON.parse(rawText);
+    if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
+      nested = candidate;
+    }
+  } catch (_) {
+    nested = null;
+  }
+} else {
+  text = String(rawText ?? '');
+}
+
+const requestId =
+  message.request_id ||
+  message.requestId ||
+  ((nested || {}).request_id || (nested || {}).requestId) ||
+  '';
+const messageType = message.type || (nested || {}).type || '';
+const fields = [
+  Buffer.from(text, 'utf8').toString('base64'),
+  String(message.timestamp ?? ''),
+  String(message.from ?? 'lead'),
+  String(requestId),
+  String(messageType),
+];
+process.stdout.write(fields.join('\n'));
+NODE
+}
+
+decode_b64() {
+  _xmux_node - "$1" <<'NODE'
+const encoded = process.argv[2] || '';
+if (!encoded) process.exit(0);
+process.stdout.write(Buffer.from(encoded, 'base64').toString('utf8'));
+NODE
+}
+
+mark_read_inline() {
+  _xmux_node - "$INBOX" "$1" "$2" <<'NODE'
+const fs = require('fs');
+const path = require('path');
+
+const inboxPath = process.argv[2];
+const timestamp = process.argv[3] || '';
+const requestId = process.argv[4] || '';
+
+function entryRequestId(entry) {
+  const direct = entry.request_id || entry.requestId || '';
+  const rawText = Object.prototype.hasOwnProperty.call(entry, 'text')
+    ? entry.text
+    : (Object.prototype.hasOwnProperty.call(entry, 'message') ? entry.message : '');
+  if (direct || typeof rawText !== 'string') return direct;
+  try {
+    const nested = JSON.parse(rawText);
+    if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+      return nested.request_id || nested.requestId || '';
+    }
+  } catch (_) {
+    return '';
+  }
+  return '';
+}
+
+let messages;
+try {
+  messages = JSON.parse(fs.readFileSync(inboxPath, 'utf8'));
+} catch (error) {
+  if (error && error.code === 'ENOENT') process.exit(0);
+  throw error;
+}
+
+if (!Array.isArray(messages)) process.exit(0);
+
+for (const message of messages) {
+  if (!message || typeof message !== 'object' || message.read) continue;
+  if (timestamp && message.timestamp === timestamp) {
+    message.read = true;
+    break;
+  }
+  if (requestId && entryRequestId(message) === requestId) {
+    message.read = true;
+    break;
+  }
+  if (!timestamp && !requestId) {
+    message.read = true;
+    break;
+  }
+}
+
+const resolved = path.resolve(inboxPath);
+const dirName = path.dirname(resolved);
+fs.mkdirSync(dirName, { recursive: true });
+const tmpPath = path.join(
+  dirName,
+  `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.json`,
+);
+fs.writeFileSync(tmpPath, `${JSON.stringify(messages, null, 2)}\n`, 'utf8');
+fs.renameSync(tmpPath, resolved);
+NODE
+}
+
+mark_read() {
+  local timestamp="$1" request_id="$2"
+  _xmux_mailbox_cli mark-read "$TEAM_NAME" "$AGENT_NAME" --timestamp "$timestamp" --request-id "$request_id" >/dev/null 2>&1 && return 0
+  mark_read_inline "$timestamp" "$request_id"
+}
+
+append_to_lead_inline() {
+  _xmux_node - "$OUTBOX" "$AGENT_NAME" "$1" "$2" <<'NODE'
+const fs = require('fs');
+const path = require('path');
+
+const outboxPath = process.argv[2];
+const agent = process.argv[3];
+const text = process.argv[4];
+const requestId = process.argv[5];
+let messages = [];
+
+try {
+  messages = JSON.parse(fs.readFileSync(outboxPath, 'utf8'));
+} catch (_) {
+  messages = [];
+}
+if (!Array.isArray(messages)) messages = [];
+
+const entry = {
+  from: agent,
+  text,
+  timestamp: new Date().toISOString(),
+  read: false,
+};
+if (requestId) entry.request_id = requestId;
+messages.push(entry);
+
+const resolved = path.resolve(outboxPath);
+const dirName = path.dirname(resolved);
+fs.mkdirSync(dirName, { recursive: true });
+const tmpPath = path.join(
+  dirName,
+  `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.json`,
+);
+fs.writeFileSync(tmpPath, `${JSON.stringify(messages, null, 2)}\n`, 'utf8');
+fs.renameSync(tmpPath, resolved);
+NODE
+}
+
+append_to_lead() {
+  local text="$1" request_id="$2"
+  if [[ -n "$request_id" ]]; then
+    _xmux_mailbox_cli write-response "$TEAM_NAME" --from "$AGENT_NAME" --text "$text" --request-id "$request_id" >/dev/null 2>&1 && return 0
+  else
+    _xmux_mailbox_cli write-response "$TEAM_NAME" --from "$AGENT_NAME" --text "$text" >/dev/null 2>&1 && return 0
+  fi
+  append_to_lead_inline "$text" "$request_id"
+}
+
+focus_target_pane() {
+  [[ "$PROVIDER" == "copilot" ]] || return 0
+  _xmux_tmux send-keys -t "$PANE_ID" Escape '[' I 2>/dev/null || return 1
+  sleep 0.05
+}
+
+mark_member_inactive() {
+  _xmux_mailbox_cli update-member "$TEAM_NAME" "$AGENT_NAME" --active false >/dev/null 2>&1 && return 0
+  _xmux_node - "$TEAM_DIR/team.json" "$AGENT_NAME" <<'NODE'
+const fs = require('fs');
+
+const teamPath = process.argv[2];
+const agentName = process.argv[3];
+let config;
+try {
+  config = JSON.parse(fs.readFileSync(teamPath, 'utf8'));
+} catch (_) {
+  process.exit(0);
+}
+
+const members = config.members;
+if (!members || typeof members !== 'object' || !members[agentName] || typeof members[agentName] !== 'object') {
+  process.exit(0);
+}
+
+members[agentName].active = false;
+members[agentName].updated_at = new Date().toISOString();
+const tmpPath = `${teamPath}.tmp`;
+fs.writeFileSync(tmpPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+fs.renameSync(tmpPath, teamPath);
+NODE
+}
+
+paste_text() {
+  local text="$1"
+  local text_len=${#text}
+  local pos=0
+  local chunk_size=300
+  local chunk buf
+
+  focus_target_pane || return 1
+  _xmux_tmux send-keys -t "$PANE_ID" C-u 2>/dev/null || return 1
+  sleep 0.05
+
+  while (( pos < text_len )); do
+    chunk="${text:$pos:$chunk_size}"
+    buf="xmux-${$}-${RANDOM}"
+    if ! printf '%s' "$chunk" | _xmux_tmux load-buffer -b "$buf" - 2>/dev/null; then
+      echo "[xmux-bridge] error: load-buffer failed for $PANE_ID" >&2
+      return 1
+    fi
+    if ! _xmux_tmux paste-buffer -d -p -b "$buf" -t "$PANE_ID" 2>/dev/null; then
+      _xmux_tmux delete-buffer -b "$buf" 2>/dev/null
+      echo "[xmux-bridge] error: paste-buffer failed for $PANE_ID" >&2
+      return 1
+    fi
+    (( pos += chunk_size ))
+    sleep 0.05
+  done
+
+  sleep "$SUBMIT_DELAY"
+  focus_target_pane || return 1
+  buf="xmux-${$}-${RANDOM}"
+  if ! printf '\r' | _xmux_tmux load-buffer -b "$buf" - 2>/dev/null; then
+    echo "[xmux-bridge] error: load-buffer failed for submit on $PANE_ID" >&2
+    return 1
+  fi
+  if ! _xmux_tmux paste-buffer -d -b "$buf" -t "$PANE_ID" 2>/dev/null; then
+    _xmux_tmux delete-buffer -b "$buf" 2>/dev/null
+    echo "[xmux-bridge] error: paste-buffer submit failed for $PANE_ID" >&2
+    return 1
+  fi
+}
+
+cleanup() {
+  local recorded_pid=""
+  [[ -f "$BRIDGE_PID_FILE" ]] && recorded_pid="$(< "$BRIDGE_PID_FILE")"
+  if [[ "$recorded_pid" == "$$" ]]; then
+    rm -f "$BRIDGE_PID_FILE"
+    rm -f "$BRIDGE_ENV_FILE"
+    mark_member_inactive
+  fi
+}
+trap 'cleanup; exit 0' INT TERM EXIT
+
+echo "[xmux-bridge] started - pane:$PANE_ID agent:$AGENT_NAME team:$TEAM_NAME"
+
+defer_count=0
+while true; do
+  if ! _xmux_tmux list-panes -a -F '#{pane_id}' 2>/dev/null | grep -qx -- "$PANE_ID"; then
+    append_to_lead "$AGENT_NAME pane exited." ""
+    exit 0
+  fi
+
+  msg="$(read_unread || true)"
+  if [[ -n "$msg" ]]; then
+    parsed="$(parse_message "$msg" 2>/dev/null || true)"
+    if [[ -z "$parsed" ]]; then
+      echo "[xmux-bridge] warning: failed to parse unread message for $AGENT_NAME" >&2
+      sleep 2
+      continue
+    fi
+
+    fields=("${(@f)parsed}")
+    text="$(decode_b64 "${fields[1]:-}")"
+    timestamp="${fields[2]:-}"
+    from_agent="${fields[3]:-lead}"
+    request_id="${fields[4]:-}"
+    msg_type="${fields[5]:-}"
+
+    if [[ "$msg_type" == "shutdown_request" ]]; then
+      mark_read "$timestamp" "$request_id"
+      if [[ -n "$request_id" ]]; then
+        append_to_lead "{\"type\":\"shutdown_approved\",\"from\":\"$AGENT_NAME\",\"request_id\":\"$request_id\"}" "$request_id"
+      else
+        append_to_lead "{\"type\":\"shutdown_approved\",\"from\":\"$AGENT_NAME\"}" ""
+      fi
+      _xmux_tmux kill-pane -t "$PANE_ID" 2>/dev/null
+      exit 0
+    fi
+
+    if [[ -n "$request_id" ]]; then
+      text="[request_id: $request_id]
+$text"
+    fi
+
+    if (( ${#text} > 120 )); then
+      echo "[xmux-bridge] delivering from '$from_agent' to '$AGENT_NAME' (${#text} chars)"
+    else
+      echo "[xmux-bridge] delivering from '$from_agent' to '$AGENT_NAME': $text"
+    fi
+
+    if ! wait_for_idle; then
+      (( defer_count++ ))
+      echo "[xmux-bridge] warning: $AGENT_NAME not idle, deferring (${defer_count})" >&2
+      sleep 3
+      continue
+    fi
+    defer_count=0
+
+    if paste_text "$text"; then
+      mark_read "$timestamp" "$request_id"
+    else
+      sleep 2
+      continue
+    fi
+  fi
+
+  sleep "$POLL_INTERVAL"
+done