remodex-windows-fix 1.0.2

package/relay/relay.js

@@ -0,0 +1,199 @@
+// FILE: relay.js
+// Purpose: Thin WebSocket relay used by the default hosted Remodex pairing flow.
+// Layer: Standalone server module
+// Exports: setupRelay, getRelayStats
+
+const { WebSocket } = require("ws");
+
+const MAX_HISTORY = 500;
+const CLEANUP_DELAY_MS = 60_000;
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const CLOSE_CODE_SESSION_UNAVAILABLE = 4002;
+const CLOSE_CODE_IPHONE_REPLACED = 4003;
+
+// In-memory session registry for one Mac host and one live iPhone client per session.
+const sessions = new Map();
+
+// Attaches relay behavior to a ws WebSocketServer instance.
+function setupRelay(wss) {
+  const heartbeat = setInterval(() => {
+    for (const ws of wss.clients) {
+      if (ws._relayAlive === false) {
+        ws.terminate();
+        continue;
+      }
+      ws._relayAlive = false;
+      ws.ping();
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+
+  wss.on("close", () => clearInterval(heartbeat));
+
+  wss.on("connection", (ws, req) => {
+    const urlPath = req.url || "";
+    const match = urlPath.match(/^\/relay\/([^/?]+)/);
+    const sessionId = match?.[1];
+    const role = req.headers["x-role"];
+
+    if (!sessionId || (role !== "mac" && role !== "iphone")) {
+      ws.close(4000, "Missing sessionId or invalid x-role header");
+      return;
+    }
+
+    ws._relayAlive = true;
+    ws.on("pong", () => {
+      ws._relayAlive = true;
+    });
+
+    // Only the Mac host is allowed to create a fresh session room.
+    if (role === "iphone" && !sessions.has(sessionId)) {
+      ws.close(CLOSE_CODE_SESSION_UNAVAILABLE, "Mac session not available");
+      return;
+    }
+
+    if (!sessions.has(sessionId)) {
+      sessions.set(sessionId, {
+        mac: null,
+        clients: new Set(),
+        history: [],
+        cleanupTimer: null,
+      });
+    }
+
+    const session = sessions.get(sessionId);
+
+    if (role === "iphone" && session.mac?.readyState !== WebSocket.OPEN) {
+      ws.close(CLOSE_CODE_SESSION_UNAVAILABLE, "Mac session not available");
+      return;
+    }
+
+    if (session.cleanupTimer) {
+      clearTimeout(session.cleanupTimer);
+      session.cleanupTimer = null;
+    }
+
+    if (role === "mac") {
+      if (session.mac && session.mac.readyState === WebSocket.OPEN) {
+        session.mac.close(4001, "Replaced by new Mac connection");
+      }
+      session.mac = ws;
+      console.log(`[relay] Mac connected -> session ${sessionId}`);
+    } else {
+      // Keep one live iPhone RPC client per session to avoid competing sockets.
+      for (const existingClient of session.clients) {
+        if (existingClient === ws) {
+          continue;
+        }
+        if (
+          existingClient.readyState === WebSocket.OPEN
+          || existingClient.readyState === WebSocket.CONNECTING
+        ) {
+          existingClient.close(
+            CLOSE_CODE_IPHONE_REPLACED,
+            "Replaced by newer iPhone connection"
+          );
+        }
+        session.clients.delete(existingClient);
+      }
+
+      session.clients.add(ws);
+      console.log(
+        `[relay] iPhone connected -> session ${sessionId} (${session.clients.size} client(s))`
+      );
+
+      // Replay recent host output so a reconnecting client can catch up.
+      for (const msg of session.history) {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(msg);
+        }
+      }
+    }
+
+    ws.on("message", (data) => {
+      const msg = typeof data === "string" ? data : data.toString("utf-8");
+
+      if (role === "mac") {
+        session.history.push(msg);
+        if (session.history.length > MAX_HISTORY) {
+          session.history.shift();
+        }
+        for (const client of session.clients) {
+          if (client.readyState === WebSocket.OPEN) {
+            client.send(msg);
+          }
+        }
+      } else if (session.mac?.readyState === WebSocket.OPEN) {
+        session.mac.send(msg);
+      }
+    });
+
+    ws.on("close", () => {
+      if (role === "mac") {
+        if (session.mac === ws) {
+          session.mac = null;
+          console.log(`[relay] Mac disconnected -> session ${sessionId}`);
+          for (const client of session.clients) {
+            if (client.readyState === WebSocket.OPEN || client.readyState === WebSocket.CONNECTING) {
+              client.close(CLOSE_CODE_SESSION_UNAVAILABLE, "Mac disconnected");
+            }
+          }
+        }
+      } else {
+        session.clients.delete(ws);
+        console.log(
+          `[relay] iPhone disconnected -> session ${sessionId} (${session.clients.size} remaining)`
+        );
+      }
+      scheduleCleanup(sessionId);
+    });
+
+    ws.on("error", (err) => {
+      console.error(
+        `[relay] WebSocket error (${role}, session ${sessionId}):`,
+        err.message
+      );
+    });
+  });
+}
+
+function scheduleCleanup(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    return;
+  }
+  if (session.mac || session.clients.size > 0 || session.cleanupTimer) {
+    return;
+  }
+
+  session.cleanupTimer = setTimeout(() => {
+    const activeSession = sessions.get(sessionId);
+    if (activeSession && !activeSession.mac && activeSession.clients.size === 0) {
+      sessions.delete(sessionId);
+      console.log(`[relay] Session ${sessionId} cleaned up`);
+    }
+  }, CLEANUP_DELAY_MS);
+}
+
+// Exposes lightweight runtime stats for health/status endpoints.
+function getRelayStats() {
+  let totalClients = 0;
+  let sessionsWithMac = 0;
+
+  for (const session of sessions.values()) {
+    totalClients += session.clients.size;
+    if (session.mac) {
+      sessionsWithMac += 1;
+    }
+  }
+
+  return {
+    activeSessions: sessions.size,
+    sessionsWithMac,
+    totalClients,
+  };
+}
+
+module.exports = {
+  setupRelay,
+  getRelayStats,
+};

package/render.yaml

@@ -0,0 +1,10 @@
+services:
+  - type: web
+    runtime: node
+    name: remodex-relay
+    buildCommand: npm install
+    startCommand: npm run relay
+    healthCheckPath: /health
+    envVars:
+      - key: REMODEX_RELAY_HOST
+        value: 0.0.0.0

package/src/bridge.js

@@ -0,0 +1,330 @@
+// FILE: bridge.js
+// Purpose: Runs Codex locally, bridges relay traffic, and coordinates desktop refreshes for Codex.app.
+// Layer: CLI service
+// Exports: startBridge
+// Depends on: ws, uuid, ./qr, ./codex-desktop-refresher, ./codex-transport
+
+const WebSocket = require("ws");
+const { v4: uuidv4 } = require("uuid");
+const {
+  CodexDesktopRefresher,
+  readBridgeConfig,
+} = require("./codex-desktop-refresher");
+const { createCodexTransport } = require("./codex-transport");
+const {
+  registerWorkspacePath,
+  registerWorkspacePathsFromMessage,
+  restoreWorkspacePathsFromDisplay,
+  rewriteWorkspacePathsForDisplay,
+} = require("./workspace-paths");
+const { printQR } = require("./qr");
+const { rememberActiveThread } = require("./session-state");
+const { handleGitRequest } = require("./git-handler");
+
+function startBridge() {
+  const config = readBridgeConfig();
+  registerWorkspacePath(process.cwd());
+  const sessionId = uuidv4();
+  const relayBaseUrl = config.relayUrl.replace(/\/+$/, "");
+  const relaySessionUrl = `${relayBaseUrl}/${sessionId}`;
+  const desktopRefresher = new CodexDesktopRefresher({
+    enabled: config.refreshEnabled,
+    debounceMs: config.refreshDebounceMs,
+    refreshCommand: config.refreshCommand,
+    bundleId: config.codexBundleId,
+    appPath: config.codexAppPath,
+  });
+
+  // Keep the local Codex runtime alive across transient relay disconnects.
+  let socket = null;
+  let isShuttingDown = false;
+  let reconnectAttempt = 0;
+  let reconnectTimer = null;
+  let lastConnectionStatus = null;
+  let codexHandshakeState = config.codexEndpoint ? "warm" : "cold";
+  const forwardedInitializeRequestIds = new Set();
+  const pendingCodexMessages = [];
+
+  const codex = createCodexTransport({
+    endpoint: config.codexEndpoint,
+    env: process.env,
+    logPrefix: "[remodex]",
+  });
+
+  codex.onError((error) => {
+    if (config.codexEndpoint) {
+      console.error(`[remodex] Failed to connect to Codex endpoint: ${config.codexEndpoint}`);
+    } else {
+      console.error("[remodex] Failed to start `codex app-server`.");
+      console.error("[remodex] Make sure the `codex` CLI is installed and available in PATH.");
+    }
+    console.error(error.message);
+    process.exit(1);
+  });
+
+  function clearReconnectTimer() {
+    if (!reconnectTimer) {
+      return;
+    }
+
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+
+  // Keeps npm start output compact by emitting only high-signal connection states.
+  function logConnectionStatus(status) {
+    if (lastConnectionStatus === status) {
+      return;
+    }
+
+    lastConnectionStatus = status;
+    console.log(`[remodex] ${status}`);
+  }
+
+  // Retries the relay socket while preserving the active Codex process and session id.
+  function scheduleRelayReconnect(closeCode) {
+    if (isShuttingDown) {
+      return;
+    }
+
+    if (closeCode === 4000 || closeCode === 4001) {
+      logConnectionStatus("disconnected");
+      shutdown(codex, () => socket, () => {
+        isShuttingDown = true;
+        clearReconnectTimer();
+      });
+      return;
+    }
+
+    if (reconnectTimer) {
+      return;
+    }
+
+    reconnectAttempt += 1;
+    const delayMs = Math.min(1_000 * reconnectAttempt, 5_000);
+    logConnectionStatus("connecting");
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      connectRelay();
+    }, delayMs);
+  }
+
+  function connectRelay() {
+    if (isShuttingDown) {
+      return;
+    }
+
+    logConnectionStatus("connecting");
+    const nextSocket = new WebSocket(relaySessionUrl, {
+      headers: { "x-role": "mac" },
+    });
+    socket = nextSocket;
+
+    nextSocket.on("open", () => {
+      clearReconnectTimer();
+      reconnectAttempt = 0;
+      logConnectionStatus("connected");
+      while (pendingCodexMessages.length > 0) {
+        const buffered = pendingCodexMessages.shift();
+        nextSocket.send(buffered);
+      }
+    });
+
+    nextSocket.on("message", (data) => {
+      const message = typeof data === "string" ? data : data.toString("utf8");
+      const normalizedMessage = restoreWorkspacePathsFromDisplay(message);
+      if (handleBridgeManagedHandshakeMessage(normalizedMessage, nextSocket)) {
+        return;
+      }
+      if (handleGitRequest(normalizedMessage, (response) => nextSocket.send(response))) {
+        return;
+      }
+      desktopRefresher.handleInbound(normalizedMessage);
+      rememberThreadFromMessage("phone", normalizedMessage);
+      codex.send(normalizedMessage);
+    });
+
+    nextSocket.on("close", (code) => {
+      logConnectionStatus("disconnected");
+      if (socket === nextSocket) {
+        socket = null;
+      }
+      scheduleRelayReconnect(code);
+    });
+
+    nextSocket.on("error", () => {
+      logConnectionStatus("disconnected");
+    });
+  }
+
+  printQR(sessionId, relayBaseUrl);
+  connectRelay();
+
+  codex.onMessage((message) => {
+    trackCodexHandshakeState(message);
+    desktopRefresher.handleOutbound(message);
+    rememberThreadFromMessage("codex", message);
+    registerWorkspacePathsFromMessage(message);
+    const forwardedMessage = rewriteWorkspacePathsForDisplay(message);
+    if (socket?.readyState === WebSocket.OPEN) {
+      socket.send(forwardedMessage);
+    } else {
+      pendingCodexMessages.push(forwardedMessage);
+    }
+  });
+
+  codex.onClose(() => {
+    logConnectionStatus("disconnected");
+    isShuttingDown = true;
+    clearReconnectTimer();
+    if (socket?.readyState === WebSocket.OPEN || socket?.readyState === WebSocket.CONNECTING) {
+      socket.close();
+    }
+  });
+
+  process.on("SIGINT", () => shutdown(codex, () => socket, () => {
+    isShuttingDown = true;
+    clearReconnectTimer();
+  }));
+  process.on("SIGTERM", () => shutdown(codex, () => socket, () => {
+    isShuttingDown = true;
+    clearReconnectTimer();
+  }));
+
+  function rememberThreadFromMessage(source, rawMessage) {
+    const threadId = extractThreadId(rawMessage);
+    if (!threadId) {
+      return;
+    }
+
+    rememberActiveThread(threadId, source);
+  }
+
+  // The spawned/shared Codex app-server stays warm across phone reconnects.
+  // When iPhone reconnects it sends initialize again, but forwarding that to the
+  // already-initialized Codex transport only produces "Already initialized".
+  function handleBridgeManagedHandshakeMessage(rawMessage, relaySocket) {
+    let parsed = null;
+    try {
+      parsed = JSON.parse(rawMessage);
+    } catch {
+      return false;
+    }
+
+    const method = typeof parsed?.method === "string" ? parsed.method.trim() : "";
+    if (!method) {
+      return false;
+    }
+
+    if (method === "initialize" && parsed.id != null) {
+      if (codexHandshakeState !== "warm") {
+        forwardedInitializeRequestIds.add(String(parsed.id));
+        return false;
+      }
+
+      relaySocket.send(JSON.stringify({
+        id: parsed.id,
+        result: {
+          bridgeManaged: true,
+        },
+      }));
+      return true;
+    }
+
+    if (method === "initialized") {
+      return codexHandshakeState === "warm";
+    }
+
+    return false;
+  }
+
+  // Learns whether the underlying Codex transport has already completed its own MCP handshake.
+  function trackCodexHandshakeState(rawMessage) {
+    let parsed = null;
+    try {
+      parsed = JSON.parse(rawMessage);
+    } catch {
+      return;
+    }
+
+    const responseId = parsed?.id;
+    if (responseId == null) {
+      return;
+    }
+
+    const responseKey = String(responseId);
+    if (!forwardedInitializeRequestIds.has(responseKey)) {
+      return;
+    }
+
+    forwardedInitializeRequestIds.delete(responseKey);
+
+    if (parsed?.result != null) {
+      codexHandshakeState = "warm";
+      return;
+    }
+
+    const errorMessage = typeof parsed?.error?.message === "string"
+      ? parsed.error.message.toLowerCase()
+      : "";
+    if (errorMessage.includes("already initialized")) {
+      codexHandshakeState = "warm";
+    }
+  }
+}
+
+function shutdown(codex, getSocket, beforeExit = () => {}) {
+  beforeExit();
+
+  const socket = getSocket();
+  if (socket?.readyState === WebSocket.OPEN || socket?.readyState === WebSocket.CONNECTING) {
+    socket.close();
+  }
+
+  codex.shutdown();
+
+  setTimeout(() => process.exit(0), 100);
+}
+
+function extractThreadId(rawMessage) {
+  let parsed = null;
+  try {
+    parsed = JSON.parse(rawMessage);
+  } catch {
+    return null;
+  }
+
+  const method = parsed?.method;
+  const params = parsed?.params;
+
+  if (method === "turn/start") {
+    return readString(params?.threadId) || readString(params?.thread_id);
+  }
+
+  if (method === "thread/start" || method === "thread/started") {
+    return (
+      readString(params?.threadId)
+      || readString(params?.thread_id)
+      || readString(params?.thread?.id)
+      || readString(params?.thread?.threadId)
+      || readString(params?.thread?.thread_id)
+    );
+  }
+
+  if (method === "turn/completed") {
+    return (
+      readString(params?.threadId)
+      || readString(params?.thread_id)
+      || readString(params?.turn?.threadId)
+      || readString(params?.turn?.thread_id)
+    );
+  }
+
+  return null;
+}
+
+function readString(value) {
+  return typeof value === "string" && value ? value : null;
+}
+
+module.exports = { startBridge };