@makerbi/remodex 1.5.3 → 1.5.8

package/bin/remodex.js

@@ -11,6 +11,7 @@ const {
   printMacOSBridgeServiceStatus,
   readBridgeConfig,
   resetMacOSBridgePairing,
+  restartMacOSBridgeService,
   runMacOSBridgeService,
   startBridge,
   startMacOSBridgeService,
@@ -27,6 +28,7 @@ const defaultDeps = {
   printMacOSBridgeServiceStatus,
   readBridgeConfig,
   resetMacOSBridgePairing,
+  restartMacOSBridgeService,
   runMacOSBridgeService,
   startBridge,
   startMacOSBridgeService,
@@ -37,11 +39,29 @@ const defaultDeps = {
 };
 
 if (require.main === module) {
-  void main();
+  void runCli();
 }
 
 // ─── ENTRY POINT ─────────────────────────────────────────────
 
+// Runs the CLI process and turns expected configuration failures into readable terminal output.
+async function runCli({
+  mainImpl = main,
+  consoleImpl = console,
+  exitImpl = process.exit,
+} = {}) {
+  try {
+    await mainImpl();
+  } catch (error) {
+    const rawMessage = error && typeof error.message === "string"
+      ? error.message.trim()
+      : String(error || "Command failed");
+    const message = rawMessage || "Command failed";
+    consoleImpl.error(message.startsWith("[remodex]") ? message : `[remodex] ${message}`);
+    exitImpl(1);
+  }
+}
+
 async function main({
   argv = process.argv,
   platform = process.platform,
@@ -94,10 +114,7 @@ async function main({
       consoleImpl,
       exitImpl,
     });
-    deps.readBridgeConfig();
-    const result = await deps.startMacOSBridgeService({
-      waitForPairing: false,
-    });
+    const result = await deps.startMacOSBridgeService();
     emitResult({
       payload: {
         ok: true,
@@ -118,10 +135,7 @@ async function main({
       consoleImpl,
       exitImpl,
     });
-    deps.readBridgeConfig();
-    const result = await deps.startMacOSBridgeService({
-      waitForPairing: false,
-    });
+    const result = await deps.restartMacOSBridgeService();
     emitResult({
       payload: {
         ok: true,
@@ -136,6 +150,22 @@ async function main({
     return;
   }
 
+  if (command === "qr" || command === "pair") {
+    assertMacOSCommand(command, {
+      platform,
+      consoleImpl,
+      exitImpl,
+    });
+    consoleImpl.log("[remodex] Refreshing bridge pairing QR...");
+    const result = await deps.startMacOSBridgeService({
+      waitForPairing: true,
+    });
+    deps.printMacOSBridgePairingQr({
+      pairingSession: result.pairingSession,
+    });
+    return;
+  }
+
   if (command === "stop") {
     assertMacOSCommand(command, {
       platform,
@@ -239,7 +269,8 @@ async function main({
 
   consoleImpl.error(`Unknown command: ${command}`);
   consoleImpl.error(
-    "Usage: remodex up | remodex run [--extra-device|--extra-devices=N] | remodex start | remodex restart | remodex stop | remodex status | "
+    "Usage: remodex up | remodex run [--extra-device|--extra-devices=N] | remodex start | remodex restart | "
+    + "remodex qr | remodex pair | remodex stop | remodex status | "
     + "remodex reset-pairing | remodex resume | remodex watch [threadId] | remodex --version | "
     + "append --json to start/restart/stop/status/reset-pairing/resume for machine-readable output"
   );
@@ -351,4 +382,5 @@ module.exports = {
   isVersionCommand,
   main,
   parseCliArgs,
+  runCli,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makerbi/remodex",
-  "version": "1.5.3",
+  "version": "1.5.8",
   "description": "Local bridge between Codex and the Remodex mobile app. Run `remodex up` to start.",
   "repository": {
     "type": "git",

package/src/account-status.js

@@ -26,7 +26,8 @@ function composeAccountStatus({
   const tokenReady = Boolean(authToken);
   const requiresOpenaiAuth = Boolean(accountRead?.requiresOpenaiAuth || authStatus?.requiresOpenaiAuth);
   const hasPriorLoginContext = hasAccountLogin || Boolean(authMethod);
-  const needsReauth = !loginInFlight && requiresOpenaiAuth && hasPriorLoginContext;
+  const hasUsableChatGPTToken = tokenReady && isChatGPTAuthMethod(authMethod);
+  const needsReauth = !loginInFlight && requiresOpenaiAuth && hasPriorLoginContext && !hasUsableChatGPTToken;
   const isAuthenticated = !needsReauth && (tokenReady || hasAccountLogin);
   const status = isAuthenticated
     ? "authenticated"
@@ -53,6 +54,10 @@ function composeAccountStatus({
   };
 }
 
+function isChatGPTAuthMethod(authMethod) {
+  return authMethod === "chatgpt" || authMethod === "chatgptAuthTokens";
+}
+
 // Removes any token-bearing fields before the bridge sends auth state to the phone.
 function redactAuthStatus(authStatus = null, extras = {}) {
   const composed = composeAccountStatus({
@@ -165,6 +170,7 @@ function deriveHostCapabilities(platform) {
     displayWake: isMacOS,
     keepAwake: isMacOS,
     hostBrowserLogin: isMacOS,
+    bridgeUpdate: isMacOS,
   };
 }
 

package/src/apply-patch-changes.js

@@ -0,0 +1,185 @@
+// FILE: apply-patch-changes.js
+// Purpose: Converts Codex apply_patch transcript payloads into fileChange-compatible records.
+// Layer: Bridge util
+// Exports: parseApplyPatchChanges, buildApplyPatchFileChangeItem
+// Depends on: path
+
+const path = require("path");
+
+function buildApplyPatchFileChangeItem({
+  callId = "",
+  patch = "",
+  status = "completed",
+  idFallback = "apply-patch-file-change",
+  cwd = "",
+} = {}) {
+  const changes = parseApplyPatchChanges(patch, { cwd });
+  if (changes.length === 0) {
+    return null;
+  }
+
+  return {
+    id: readString(callId) || idFallback,
+    type: "fileChange",
+    status: readString(status) || "completed",
+    changes,
+  };
+}
+
+// Parses the custom apply_patch DSL saved in desktop rollouts into the same
+// change-array shape that iOS already decodes from app-server fileChange items.
+function parseApplyPatchChanges(patchText, { cwd = "" } = {}) {
+  const lines = String(patchText || "").split(/\r?\n/);
+  const changes = [];
+  let current = null;
+
+  function startChange(kind, rawPath) {
+    flushCurrentChange();
+    const filePath = normalizePatchPath(rawPath, cwd);
+    if (!filePath) {
+      current = null;
+      return;
+    }
+
+    current = {
+      path: filePath,
+      originalPath: filePath,
+      kind,
+      additions: 0,
+      deletions: 0,
+      bodyLines: [],
+    };
+  }
+
+  function flushCurrentChange() {
+    if (!current || !current.path) {
+      current = null;
+      return;
+    }
+
+    changes.push({
+      path: current.path,
+      kind: current.kind,
+      additions: current.additions,
+      deletions: current.deletions,
+      diff: buildUnifiedDiffForApplyPatchChange(current),
+    });
+    current = null;
+  }
+
+  for (const line of lines) {
+    if (line.startsWith("*** Add File: ")) {
+      startChange("add", line.slice("*** Add File: ".length));
+      continue;
+    }
+
+    if (line.startsWith("*** Update File: ")) {
+      startChange("update", line.slice("*** Update File: ".length));
+      continue;
+    }
+
+    if (line.startsWith("*** Delete File: ")) {
+      startChange("delete", line.slice("*** Delete File: ".length));
+      flushCurrentChange();
+      continue;
+    }
+
+    if (line.startsWith("*** Move to: ")) {
+      if (current) {
+        current.path = normalizePatchPath(line.slice("*** Move to: ".length), cwd) || current.path;
+        current.kind = "rename";
+      }
+      continue;
+    }
+
+    if (line === "*** End Patch") {
+      flushCurrentChange();
+      break;
+    }
+
+    if (line.startsWith("***")) {
+      continue;
+    }
+
+    if (!current) {
+      continue;
+    }
+
+    current.bodyLines.push(line);
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      current.additions += 1;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      current.deletions += 1;
+    }
+  }
+
+  flushCurrentChange();
+  return changes.filter((change) => (
+    change.additions > 0
+    || change.deletions > 0
+    || change.kind === "rename"
+    || change.kind === "delete"
+  ));
+}
+
+function buildUnifiedDiffForApplyPatchChange(change) {
+  const oldPath = change.originalPath || change.path;
+  const newPath = change.path || oldPath;
+  const diffLines = [`diff --git ${gitPatchPath("a", oldPath)} ${gitPatchPath("b", newPath)}`];
+
+  if (change.kind === "add") {
+    diffLines.push("new file mode 100644", "--- /dev/null", `+++ ${gitPatchPath("b", newPath)}`);
+  } else if (change.kind === "delete") {
+    diffLines.push("deleted file mode 100644", `--- ${gitPatchPath("a", oldPath)}`, "+++ /dev/null");
+  } else if (change.kind === "rename") {
+    diffLines.push(`rename from ${oldPath}`, `rename to ${newPath}`);
+    if (change.bodyLines.length > 0) {
+      diffLines.push(`--- ${gitPatchPath("a", oldPath)}`, `+++ ${gitPatchPath("b", newPath)}`);
+    }
+  } else {
+    diffLines.push(`--- ${gitPatchPath("a", oldPath)}`, `+++ ${gitPatchPath("b", newPath)}`);
+  }
+
+  const bodyLines = change.bodyLines || [];
+  if (bodyLines.length > 0) {
+    if (!bodyLines.some((line) => line.startsWith("@@"))) {
+      diffLines.push("@@");
+    }
+    diffLines.push(...bodyLines);
+  }
+
+  return diffLines.join("\n").trim();
+}
+
+function gitPatchPath(prefix, filePath) {
+  const trimmed = readString(filePath).replace(/^\/+/, "");
+  return `${prefix}/${trimmed || filePath || "unknown"}`;
+}
+
+function normalizePatchPath(rawPath, cwd) {
+  const filePath = readString(rawPath);
+  if (!filePath) {
+    return "";
+  }
+
+  const root = readString(cwd);
+  if (!root || !path.isAbsolute(filePath)) {
+    return filePath;
+  }
+
+  const relativePath = path.relative(root, filePath);
+  if (!relativePath || relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    return filePath;
+  }
+
+  return relativePath;
+}
+
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+module.exports = {
+  buildApplyPatchFileChangeItem,
+  parseApplyPatchChanges,
+};

package/src/bootstrap-codex-cli.js

@@ -32,7 +32,7 @@ if (!isGlobalInstall) {
 ensureCodexCLI({
   env: process.env,
   logger: console,
-  shouldUpdate: true,
+  shouldUpdate: false,
 });
 
 logCachedIOSAppCompatibilityWarning();

package/src/bridge-status.js

@@ -0,0 +1,122 @@
+// FILE: bridge-status.js
+// Purpose: Owns bridge status publishing and stale-relay heartbeat downgrades.
+// Layer: CLI service helper
+// Exports: createBridgeStatusPublisher, buildHeartbeatBridgeStatus, hasRelayConnectionGoneStale
+// Depends on: timers
+
+const BRIDGE_STATUS_HEARTBEAT_INTERVAL_MS = 5_000;
+// Keep this above the 25s iOS foreground keepalive cadence so normal jitter
+// does not kill a healthy Mac relay socket, while still recovering quickly.
+const RELAY_WATCHDOG_STALE_AFTER_MS = 45_000;
+const STALE_RELAY_STATUS_MESSAGE = "Relay heartbeat stalled; reconnect pending.";
+
+// Wraps daemon status publication so bridge.js does not own heartbeat bookkeeping.
+function createBridgeStatusPublisher({
+  onBridgeStatus = null,
+  getCodexLaunchState = () => undefined,
+  heartbeatIntervalMs = BRIDGE_STATUS_HEARTBEAT_INTERVAL_MS,
+  now = () => Date.now(),
+} = {}) {
+  let lastPublishedBridgeStatus = null;
+  let heartbeatTimer = null;
+
+  function publish(status) {
+    const nextStatus = {
+      ...status,
+      codexLaunchState: getCodexLaunchState(),
+    };
+    lastPublishedBridgeStatus = nextStatus;
+    onBridgeStatus?.(nextStatus);
+  }
+
+  function startHeartbeat({
+    shouldPublish = () => true,
+    getLastRelayActivityAt = () => 0,
+  } = {}) {
+    if (heartbeatTimer) {
+      return;
+    }
+
+    heartbeatTimer = setInterval(() => {
+      if (!lastPublishedBridgeStatus || !shouldPublish()) {
+        return;
+      }
+
+      onBridgeStatus?.(buildHeartbeatBridgeStatus(
+        lastPublishedBridgeStatus,
+        getLastRelayActivityAt(),
+        { now: now() }
+      ));
+    }, heartbeatIntervalMs);
+    heartbeatTimer.unref?.();
+  }
+
+  function stopHeartbeat() {
+    if (!heartbeatTimer) {
+      return;
+    }
+
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+
+  return {
+    latest() {
+      return lastPublishedBridgeStatus;
+    },
+    publish,
+    startHeartbeat,
+    stopHeartbeat,
+  };
+}
+
+// Treats silent relay sockets as stale so the daemon can self-heal after sleep/wake.
+function hasRelayConnectionGoneStale(
+  lastActivityAt,
+  {
+    now = Date.now(),
+    staleAfterMs = RELAY_WATCHDOG_STALE_AFTER_MS,
+  } = {}
+) {
+  return Number.isFinite(lastActivityAt)
+    && Number.isFinite(now)
+    && now - lastActivityAt >= staleAfterMs;
+}
+
+// Keeps persisted daemon status honest by downgrading stale "connected" snapshots.
+function buildHeartbeatBridgeStatus(
+  status,
+  lastActivityAt,
+  {
+    now = Date.now(),
+    staleAfterMs = RELAY_WATCHDOG_STALE_AFTER_MS,
+    staleMessage = STALE_RELAY_STATUS_MESSAGE,
+  } = {}
+) {
+  if (!status || typeof status !== "object") {
+    return status;
+  }
+
+  if (status.connectionStatus !== "connected") {
+    return status;
+  }
+
+  if (!hasRelayConnectionGoneStale(lastActivityAt, { now, staleAfterMs })) {
+    return status;
+  }
+
+  return {
+    ...status,
+    connectionStatus: "disconnected",
+    lastError: staleMessage,
+  };
+}
+
+module.exports = {
+  BRIDGE_STATUS_HEARTBEAT_INTERVAL_MS,
+  RELAY_WATCHDOG_STALE_AFTER_MS,
+  STALE_RELAY_STATUS_MESSAGE,
+  buildHeartbeatBridgeStatus,
+  createBridgeStatusPublisher,
+  hasRelayConnectionGoneStale,
+};