@makerbi/remodex 1.3.8

package/src/codex-home.js

@@ -0,0 +1,21 @@
+// FILE: codex-home.js
+// Purpose: Resolves local Codex cache paths shared by bridge services.
+// Layer: CLI helper
+// Exports: resolveCodexHome, resolveCodexGeneratedImagesRoot
+// Depends on: os, path
+
+const os = require("os");
+const path = require("path");
+
+function resolveCodexHome() {
+  return process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+}
+
+function resolveCodexGeneratedImagesRoot() {
+  return path.join(resolveCodexHome(), "generated_images");
+}
+
+module.exports = {
+  resolveCodexGeneratedImagesRoot,
+  resolveCodexHome,
+};

package/src/codex-transport.js

@@ -0,0 +1,353 @@
+// 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, fs, path, ws
+
+const { spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const WebSocket = require("ws");
+
+function createCodexTransport({
+  endpoint = "",
+  env = process.env,
+  appPath = "",
+  spawnImpl = spawn,
+  WebSocketImpl = WebSocket,
+} = {}) {
+  if (endpoint) {
+    return createWebSocketTransport({ endpoint, WebSocketImpl });
+  }
+
+  return createSpawnTransport({ env, appPath, spawnImpl });
+}
+
+function createSpawnTransport({ env, appPath, spawnImpl = spawn }) {
+  const launchPlans = createCodexLaunchPlans({ env, appPath });
+  let launchIndex = -1;
+  let activeLaunch = null;
+  let codex = null;
+  let stdoutBuffer = "";
+  let stderrBuffer = "";
+  let didRequestShutdown = false;
+  let didReportError = false;
+  const listeners = createListenerBag();
+
+  spawnNextLaunch();
+
+  return {
+    mode: "spawn",
+    describe() {
+      return activeLaunch?.description || launchPlans[0]?.description || "`codex app-server`";
+    },
+    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;
+    },
+    onStarted(handler) {
+      listeners.onStarted = handler;
+    },
+    shutdown() {
+      didRequestShutdown = true;
+      shutdownCodexProcess(codex);
+    },
+  };
+
+  // Retries the launch once with the bundled desktop binary when the shell-visible
+  // `codex` command is unavailable in daemon environments like launchd.
+  function spawnNextLaunch() {
+    launchIndex += 1;
+    activeLaunch = launchPlans[launchIndex] || null;
+    if (!activeLaunch) {
+      return;
+    }
+
+    stdoutBuffer = "";
+    stderrBuffer = "";
+    codex = spawnImpl(activeLaunch.command, activeLaunch.args, activeLaunch.options);
+    attachChildListeners(codex, activeLaunch);
+  }
+
+  function attachChildListeners(child, launch) {
+    child.on("spawn", () => {
+      if (child !== codex) {
+        return;
+      }
+
+      listeners.emitStarted({
+        mode: "spawn",
+        launchDescription: launch.description,
+      });
+    });
+    child.on("error", (error) => {
+      if (child !== codex) {
+        return;
+      }
+
+      if (!didRequestShutdown && shouldRetryLaunchError(error, launchIndex, launchPlans)) {
+        spawnNextLaunch();
+        return;
+      }
+
+      didReportError = true;
+      listeners.emitError(error);
+    });
+    child.on("close", (code, signal) => {
+      if (child !== codex) {
+        return;
+      }
+
+      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.
+    child.stdin.on("error", (error) => {
+      if (child !== codex) {
+        return;
+      }
+
+      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.
+    child.stderr.on("data", (chunk) => {
+      if (child !== codex) {
+        return;
+      }
+      stderrBuffer = appendOutputBuffer(stderrBuffer, chunk.toString("utf8"));
+    });
+
+    child.stdout.on("data", (chunk) => {
+      if (child !== codex) {
+        return;
+      }
+      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);
+        }
+      }
+    });
+  }
+}
+
+// Builds a single, platform-aware launch path so the bridge never "guesses"
+// between multiple commands and accidentally starts duplicate runtimes.
+function createCodexLaunchPlans({
+  env,
+  appPath = "",
+  platform = process.platform,
+  fsImpl = fs,
+  pathImpl = path,
+} = {}) {
+  const sharedOptions = {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...env },
+  };
+
+  if (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`",
+    }];
+  }
+
+  const launches = [{
+    command: "codex",
+    args: ["app-server"],
+    options: sharedOptions,
+    description: "`codex app-server`",
+  }];
+
+  const bundledCommand = buildBundledCodexPath(appPath, { fsImpl, pathImpl });
+  if (bundledCommand) {
+    launches.push({
+      command: bundledCommand,
+      args: ["app-server"],
+      options: sharedOptions,
+      description: `\`${bundledCommand} app-server\``,
+    });
+  }
+
+  return launches;
+}
+
+function buildBundledCodexPath(appPath, { fsImpl = fs, pathImpl = path } = {}) {
+  if (typeof appPath !== "string" || !appPath.trim()) {
+    return "";
+  }
+
+  const candidate = pathImpl.join(appPath.trim(), "Contents", "Resources", "codex");
+  return isLaunchableFile(candidate, { fsImpl }) ? candidate : "";
+}
+
+function isLaunchableFile(candidatePath, { fsImpl = fs } = {}) {
+  try {
+    return fsImpl.statSync(candidatePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// 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 shouldRetryLaunchError(error, launchIndex, launchPlans) {
+  return error?.code === "ENOENT" && launchIndex < launchPlans.length - 1;
+}
+
+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("open", () => {
+    listeners.emitStarted({
+      mode: "websocket",
+      launchDescription: endpoint,
+    });
+  });
+
+  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;
+    },
+    onStarted(handler) {
+      listeners.onStarted = handler;
+    },
+    shutdown() {
+      if (socket.readyState === openState || socket.readyState === connectingState) {
+        socket.close();
+      }
+    },
+  };
+}
+
+function createListenerBag() {
+  return {
+    onMessage: null,
+    onClose: null,
+    onError: null,
+    onStarted: null,
+    emitMessage(message) {
+      this.onMessage?.(message);
+    },
+    emitClose(...args) {
+      this.onClose?.(...args);
+    },
+    emitError(error) {
+      this.onError?.(error);
+    },
+    emitStarted(info) {
+      this.onStarted?.(info);
+    },
+  };
+}
+
+module.exports = {
+  createCodexLaunchPlans,
+  createCodexTransport,
+};

package/src/daemon-state.js

@@ -0,0 +1,153 @@
+// 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_NAME = ".remodex";
+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 Remodex state root so daemon mode keeps the same local-first storage model.
+function resolveRemodexStateDir({ env = process.env, osImpl = os } = {}) {
+  return normalizeNonEmptyString(env.REMODEX_DEVICE_STATE_DIR)
+    || path.join(osImpl.homedir(), DEFAULT_STATE_DIR_NAME);
+}
+
+function resolveDaemonConfigPath(options = {}) {
+  return path.join(resolveRemodexStateDir(options), DAEMON_CONFIG_FILE);
+}
+
+function resolvePairingSessionPath(options = {}) {
+  return path.join(resolveRemodexStateDir(options), PAIRING_SESSION_FILE);
+}
+
+function resolveBridgeStatusPath(options = {}) {
+  return path.join(resolveRemodexStateDir(options), BRIDGE_STATUS_FILE);
+}
+
+function resolveBridgeLogsDir(options = {}) {
+  return path.join(resolveRemodexStateDir(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 plus any short recovery code so foreground CLI commands can render pairing locally.
+function writePairingSession(pairingSessionOrPayload, { now = () => Date.now(), ...options } = {}) {
+  const pairingSession = pairingSessionOrPayload?.pairingPayload
+    ? pairingSessionOrPayload
+    : { pairingPayload: pairingSessionOrPayload };
+  writeJsonFile(resolvePairingSessionPath(options), {
+    createdAt: new Date(now()).toISOString(),
+    ...pairingSession,
+  }, 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 `remodex 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 ensureRemodexStateDir({ fsImpl = fs, ...options } = {}) {
+  fsImpl.mkdirSync(resolveRemodexStateDir(options), { recursive: true });
+}
+
+function ensureRemodexLogsDir({ 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() : "";
+}
+
+module.exports = {
+  clearBridgeStatus,
+  clearPairingSession,
+  ensureRemodexLogsDir,
+  ensureRemodexStateDir,
+  readBridgeStatus,
+  readDaemonConfig,
+  readPairingSession,
+  resolveBridgeLogsDir,
+  resolveBridgeStderrLogPath,
+  resolveBridgeStatusPath,
+  resolveBridgeStdoutLogPath,
+  resolveDaemonConfigPath,
+  resolvePairingSessionPath,
+  resolveRemodexStateDir,
+  writeBridgeStatus,
+  writeDaemonConfig,
+  writePairingSession,
+};