@btatum5/codex-bridge 0.1.0 → 1.3.3

package/src/codex-transport.js

@@ -0,0 +1,238 @@
+// FILE: codex-transport.js
+// Purpose: Abstracts the Codex-side transport so the bridge can talk to either a spawned app-server or an existing WebSocket endpoint.
+// Layer: CLI helper
+// Exports: createCodexTransport
+// Depends on: child_process, ws
+
+const { spawn } = require("child_process");
+const WebSocket = require("ws");
+
+function createCodexTransport({
+  endpoint = "",
+  env = process.env,
+  WebSocketImpl = WebSocket,
+} = {}) {
+  if (endpoint) {
+    return createWebSocketTransport({ endpoint, WebSocketImpl });
+  }
+
+  return createSpawnTransport({ env });
+}
+
+function createSpawnTransport({ env }) {
+  const launch = createCodexLaunchPlan({ env });
+  const codex = spawn(launch.command, launch.args, launch.options);
+
+  let stdoutBuffer = "";
+  let stderrBuffer = "";
+  let didRequestShutdown = false;
+  let didReportError = false;
+  const listeners = createListenerBag();
+
+  codex.on("error", (error) => {
+    didReportError = true;
+    listeners.emitError(error);
+  });
+  codex.on("close", (code, signal) => {
+    if (!didRequestShutdown && !didReportError && code !== 0) {
+      didReportError = true;
+      listeners.emitError(createCodexCloseError({
+        code,
+        signal,
+        stderrBuffer,
+        launchDescription: launch.description,
+      }));
+      return;
+    }
+
+    listeners.emitClose(code, signal);
+  });
+  // Ignore broken-pipe shutdown noise once the child is already going away.
+  codex.stdin.on("error", (error) => {
+    if (didRequestShutdown && isIgnorableStdinShutdownError(error)) {
+      return;
+    }
+
+    if (isIgnorableStdinShutdownError(error)) {
+      return;
+    }
+
+    didReportError = true;
+    listeners.emitError(error);
+  });
+  // Keep stderr muted during normal operation, but preserve enough output to
+  // explain launch failures when the child exits before the bridge can use it.
+  codex.stderr.on("data", (chunk) => {
+    stderrBuffer = appendOutputBuffer(stderrBuffer, chunk.toString("utf8"));
+  });
+
+  codex.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk.toString("utf8");
+    const lines = stdoutBuffer.split("\n");
+    stdoutBuffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine) {
+        listeners.emitMessage(trimmedLine);
+      }
+    }
+  });
+
+  return {
+    mode: "spawn",
+    describe() {
+      return launch.description;
+    },
+    send(message) {
+      if (!codex.stdin.writable || codex.stdin.destroyed || codex.stdin.writableEnded) {
+        return;
+      }
+
+      codex.stdin.write(message.endsWith("\n") ? message : `${message}\n`);
+    },
+    onMessage(handler) {
+      listeners.onMessage = handler;
+    },
+    onClose(handler) {
+      listeners.onClose = handler;
+    },
+    onError(handler) {
+      listeners.onError = handler;
+    },
+    shutdown() {
+      didRequestShutdown = true;
+      shutdownCodexProcess(codex);
+    },
+  };
+}
+
+// Builds a single, platform-aware launch path so the bridge never "guesses"
+// between multiple commands and accidentally starts duplicate runtimes.
+function createCodexLaunchPlan({ env }) {
+  const sharedOptions = {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...env },
+  };
+
+  if (process.platform === "win32") {
+    return {
+      command: env.ComSpec || "cmd.exe",
+      args: ["/d", "/c", "codex app-server"],
+      options: {
+        ...sharedOptions,
+        windowsHide: true,
+      },
+      description: "`cmd.exe /d /c codex app-server`",
+    };
+  }
+
+  return {
+    command: "codex",
+    args: ["app-server"],
+    options: sharedOptions,
+    description: "`codex app-server`",
+  };
+}
+
+// Stops the exact process tree we launched on Windows so the shell wrapper
+// does not leave a child Codex process running in the background.
+function shutdownCodexProcess(codex) {
+  if (codex.killed || codex.exitCode !== null) {
+    return;
+  }
+
+  if (process.platform === "win32" && codex.pid) {
+    const killer = spawn("taskkill", ["/pid", String(codex.pid), "/t", "/f"], {
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    killer.on("error", () => {
+      codex.kill();
+    });
+    return;
+  }
+
+  codex.kill("SIGTERM");
+}
+
+function createCodexCloseError({ code, signal, stderrBuffer, launchDescription }) {
+  const details = stderrBuffer.trim();
+  const reason = details || `Process exited with code ${code}${signal ? ` (signal: ${signal})` : ""}.`;
+  return new Error(`Codex launcher ${launchDescription} failed: ${reason}`);
+}
+
+function appendOutputBuffer(buffer, chunk) {
+  const next = `${buffer}${chunk}`;
+  return next.slice(-4_096);
+}
+
+function isIgnorableStdinShutdownError(error) {
+  return error?.code === "EPIPE" || error?.code === "ERR_STREAM_DESTROYED";
+}
+
+function createWebSocketTransport({ endpoint, WebSocketImpl = WebSocket }) {
+  const socket = new WebSocketImpl(endpoint);
+  const listeners = createListenerBag();
+  const openState = WebSocketImpl.OPEN ?? WebSocket.OPEN ?? 1;
+  const connectingState = WebSocketImpl.CONNECTING ?? WebSocket.CONNECTING ?? 0;
+
+  socket.on("message", (chunk) => {
+    const message = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    if (message.trim()) {
+      listeners.emitMessage(message);
+    }
+  });
+
+  socket.on("close", (code, reason) => {
+    const safeReason = reason ? reason.toString("utf8") : "no reason";
+    listeners.emitClose(code, safeReason);
+  });
+
+  socket.on("error", (error) => listeners.emitError(error));
+
+  return {
+    mode: "websocket",
+    describe() {
+      return endpoint;
+    },
+    send(message) {
+      if (socket.readyState === openState) {
+        socket.send(message);
+      }
+    },
+    onMessage(handler) {
+      listeners.onMessage = handler;
+    },
+    onClose(handler) {
+      listeners.onClose = handler;
+    },
+    onError(handler) {
+      listeners.onError = handler;
+    },
+    shutdown() {
+      if (socket.readyState === openState || socket.readyState === connectingState) {
+        socket.close();
+      }
+    },
+  };
+}
+
+function createListenerBag() {
+  return {
+    onMessage: null,
+    onClose: null,
+    onError: null,
+    emitMessage(message) {
+      this.onMessage?.(message);
+    },
+    emitClose(...args) {
+      this.onClose?.(...args);
+    },
+    emitError(error) {
+      this.onError?.(error);
+    },
+  };
+}
+
+module.exports = { createCodexTransport };

package/src/daemon-state.js

@@ -0,0 +1,170 @@
+// FILE: daemon-state.js
+// Purpose: Persists macOS service config/runtime state outside the repo for the launchd bridge flow.
+// Layer: CLI helper
+// Exports: path resolvers plus read/write helpers for daemon config, pairing payloads, and service status.
+// Depends on: fs, os, path
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const DEFAULT_STATE_DIR = path.join(os.homedir(), ".codex", "bridge");
+const DAEMON_CONFIG_FILE = "daemon-config.json";
+const PAIRING_SESSION_FILE = "pairing-session.json";
+const BRIDGE_STATUS_FILE = "bridge-status.json";
+const LOGS_DIR = "logs";
+const BRIDGE_STDOUT_LOG_FILE = "bridge.stdout.log";
+const BRIDGE_STDERR_LOG_FILE = "bridge.stderr.log";
+
+// Reuses the existing Codex state root so daemon mode keeps the same local-first storage model.
+function resolveCodexStateDir({ env = process.env, osImpl = os } = {}) {
+  return firstNonEmptyString([
+    env.CODEX_BRIDGE_DEVICE_STATE_DIR,
+    env.REMODEX_DEVICE_STATE_DIR,
+  ])
+    || resolveLegacyAwareDefaultStateDir(osImpl);
+}
+
+function resolveDaemonConfigPath(options = {}) {
+  return path.join(resolveCodexStateDir(options), DAEMON_CONFIG_FILE);
+}
+
+function resolvePairingSessionPath(options = {}) {
+  return path.join(resolveCodexStateDir(options), PAIRING_SESSION_FILE);
+}
+
+function resolveBridgeStatusPath(options = {}) {
+  return path.join(resolveCodexStateDir(options), BRIDGE_STATUS_FILE);
+}
+
+function resolveBridgeLogsDir(options = {}) {
+  return path.join(resolveCodexStateDir(options), LOGS_DIR);
+}
+
+function resolveBridgeStdoutLogPath(options = {}) {
+  return path.join(resolveBridgeLogsDir(options), BRIDGE_STDOUT_LOG_FILE);
+}
+
+function resolveBridgeStderrLogPath(options = {}) {
+  return path.join(resolveBridgeLogsDir(options), BRIDGE_STDERR_LOG_FILE);
+}
+
+function writeDaemonConfig(config, options = {}) {
+  writeJsonFile(resolveDaemonConfigPath(options), config, options);
+}
+
+function readDaemonConfig(options = {}) {
+  return readJsonFile(resolveDaemonConfigPath(options), options);
+}
+
+// Persists the pairing payload so foreground CLI commands can render the QR locally.
+function writePairingSession(pairingPayload, { now = () => Date.now(), ...options } = {}) {
+  writeJsonFile(resolvePairingSessionPath(options), {
+    createdAt: new Date(now()).toISOString(),
+    pairingPayload,
+  }, options);
+}
+
+function readPairingSession(options = {}) {
+  return readJsonFile(resolvePairingSessionPath(options), options);
+}
+
+function clearPairingSession({ fsImpl = fs, ...options } = {}) {
+  removeFile(resolvePairingSessionPath(options), fsImpl);
+}
+
+// Captures the last known service heartbeat so `codex-bridge status` does not depend on launchctl output alone.
+function writeBridgeStatus(status, { now = () => Date.now(), ...options } = {}) {
+  writeJsonFile(resolveBridgeStatusPath(options), {
+    ...status,
+    updatedAt: new Date(now()).toISOString(),
+  }, options);
+}
+
+function readBridgeStatus(options = {}) {
+  return readJsonFile(resolveBridgeStatusPath(options), options);
+}
+
+function clearBridgeStatus({ fsImpl = fs, ...options } = {}) {
+  removeFile(resolveBridgeStatusPath(options), fsImpl);
+}
+
+function ensureCodexStateDir({ fsImpl = fs, ...options } = {}) {
+  fsImpl.mkdirSync(resolveCodexStateDir(options), { recursive: true });
+}
+
+function ensureCodexLogsDir({ fsImpl = fs, ...options } = {}) {
+  fsImpl.mkdirSync(resolveBridgeLogsDir(options), { recursive: true });
+}
+
+function writeJsonFile(targetPath, value, { fsImpl = fs } = {}) {
+  fsImpl.mkdirSync(path.dirname(targetPath), { recursive: true });
+  const serialized = JSON.stringify(value, null, 2);
+  fsImpl.writeFileSync(targetPath, serialized, { mode: 0o600 });
+  try {
+    fsImpl.chmodSync(targetPath, 0o600);
+  } catch {
+    // Best-effort only on filesystems without POSIX mode support.
+  }
+}
+
+function readJsonFile(targetPath, { fsImpl = fs } = {}) {
+  if (!fsImpl.existsSync(targetPath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fsImpl.readFileSync(targetPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function removeFile(targetPath, fsImpl) {
+  try {
+    fsImpl.rmSync(targetPath, { force: true });
+  } catch {
+    // Missing runtime files should not block control-plane commands.
+  }
+}
+
+function normalizeNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+function firstNonEmptyString(values) {
+  for (const value of values) {
+    const normalized = normalizeNonEmptyString(value);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return "";
+}
+
+function resolveLegacyAwareDefaultStateDir(osImpl) {
+  const legacyStateDir = path.join(osImpl.homedir(), ".remodex");
+  return fs.existsSync(legacyStateDir)
+    ? legacyStateDir
+    : DEFAULT_STATE_DIR;
+}
+
+module.exports = {
+  clearBridgeStatus,
+  clearPairingSession,
+  ensureCodexLogsDir,
+  ensureCodexStateDir,
+  readBridgeStatus,
+  readDaemonConfig,
+  readPairingSession,
+  resolveBridgeLogsDir,
+  resolveBridgeStderrLogPath,
+  resolveBridgeStatusPath,
+  resolveBridgeStdoutLogPath,
+  resolveDaemonConfigPath,
+  resolvePairingSessionPath,
+  resolveCodexStateDir,
+  writeBridgeStatus,
+  writeDaemonConfig,
+  writePairingSession,
+};