@makerbi/remodex 1.5.4 → 2.0.0

package/src/codex-transport.js

@@ -13,6 +13,7 @@ function createCodexTransport({
   endpoint = "",
   env = process.env,
   appPath = "",
+  platform = process.platform,
   spawnImpl = spawn,
   WebSocketImpl = WebSocket,
 } = {}) {
@@ -20,11 +21,11 @@ function createCodexTransport({
     return createWebSocketTransport({ endpoint, WebSocketImpl });
   }
 
-  return createSpawnTransport({ env, appPath, spawnImpl });
+  return createSpawnTransport({ env, appPath, platform, spawnImpl });
 }
 
-function createSpawnTransport({ env, appPath, spawnImpl = spawn }) {
-  const launchPlans = createCodexLaunchPlans({ env, appPath });
+function createSpawnTransport({ env, appPath, platform, spawnImpl = spawn }) {
+  const launchPlans = createCodexLaunchPlans({ env, appPath, platform });
   let launchIndex = -1;
   let activeLaunch = null;
   let codex = null;
@@ -154,13 +155,12 @@ function createSpawnTransport({ env, appPath, spawnImpl = spawn }) {
         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);
+      let newlineIndex;
+      while ((newlineIndex = stdoutBuffer.indexOf("\n")) !== -1) {
+        const line = stdoutBuffer.substring(0, newlineIndex).trim();
+        stdoutBuffer = stdoutBuffer.substring(newlineIndex + 1);
+        if (line) {
+          listeners.emitMessage(line);
         }
       }
     });

package/src/desktop-handler.js

@@ -1,5 +1,5 @@
 // FILE: desktop-handler.js
-// Purpose: Handles explicit desktop handoff, display wake, and bridge preference RPCs for Codex.app.
+// Purpose: Handles explicit desktop handoff, display wake, bridge update, and preference RPCs for Codex.app.
 // Layer: Bridge handler
 // Exports: handleDesktopRequest
 // Depends on: child_process, fs, os, path, ./rollout-watch
@@ -126,6 +126,8 @@ async function handleDesktopMethod(method, params, options = {}) {
       return readBridgePreferences(options);
     case "desktop/preferences/update":
       return updateBridgePreferences(params, options);
+    case "desktop/bridge/updateAndRestart":
+      return updateBridgePackageAndRestart(options);
     default:
       throw desktopError("unknown_method", `Unknown desktop method: ${method}`);
   }
@@ -360,6 +362,17 @@ async function updateBridgePreferences(params, options = {}) {
   });
 }
 
+async function updateBridgePackageAndRestart(options = {}) {
+  if (typeof options.updateBridgePackageAndRestart !== "function") {
+    throw desktopError(
+      "unsupported_bridge_update",
+      "This bridge does not support iPhone-triggered bridge updates yet."
+    );
+  }
+
+  return options.updateBridgePackageAndRestart();
+}
+
 function resolveThreadId(params) {
   if (!params || typeof params !== "object") {
     return "";

package/src/desktop-ipc-action-follower.js

@@ -11,6 +11,7 @@ const path = require("path");
 const FRAME_HEADER_BYTES = 4;
 const MAX_FRAME_BYTES = 256 * 1024 * 1024;
 const REQUEST_TIMEOUT_MS = 10_000;
+const DESKTOP_IPC_ACTION_SOURCE = "desktop-ipc-action-follower";
 const DESKTOP_RESUME_METHODS = new Set(["thread/read", "thread/resume"]);
 const ACTION_METHODS = new Set([
   "item/commandExecution/requestApproval",
@@ -54,6 +55,7 @@ function createDesktopIpcActionFollower({
     onDisconnect,
   });
   const rawStatesByThreadId = new Map();
+  const assistantMessageTextsByThreadId = new Map();
   const pendingRoutesByRequestId = new Map();
   const activeThreadIds = new Set();
   const recoveringThreadIds = new Set();
@@ -84,6 +86,7 @@ function createDesktopIpcActionFollower({
 
   function stopAll() {
     rawStatesByThreadId.clear();
+    assistantMessageTextsByThreadId.clear();
     pendingRoutesByRequestId.clear();
     activeThreadIds.clear();
     recoveringThreadIds.clear();
@@ -132,11 +135,13 @@ function createDesktopIpcActionFollower({
     }
 
     rawStatesByThreadId.set(threadId, nextState);
+    syncProjectedAssistantDeltas(threadId, previousState, nextState);
     syncProjectedActions(threadId, projectPendingDesktopActions(threadId, nextState));
   }
 
   function onDisconnect() {
     rawStatesByThreadId.clear();
+    assistantMessageTextsByThreadId.clear();
     pendingRoutesByRequestId.clear();
     recoveringThreadIds.clear();
     queuedChangesByThreadId.clear();
@@ -273,9 +278,34 @@ function createDesktopIpcActionFollower({
     }
 
     rawStatesByThreadId.set(threadId, nextState);
+    syncProjectedAssistantDeltas(threadId, baselineState, nextState);
     syncProjectedActions(threadId, projectPendingDesktopActions(threadId, nextState));
   }
 
+  function syncProjectedAssistantDeltas(threadId, previousState, nextState) {
+    const previousTexts = assistantMessageTextsByThreadId.get(threadId);
+    if (!previousTexts && !previousState) {
+      assistantMessageTextsByThreadId.set(threadId, snapshotAssistantMessageTexts(nextState));
+      return;
+    }
+
+    const notifications = projectDesktopAssistantDeltaNotifications(
+      threadId,
+      previousState,
+      nextState,
+      previousTexts || snapshotAssistantMessageTexts(previousState)
+    );
+    if (notifications.length === 0) {
+      assistantMessageTextsByThreadId.set(threadId, snapshotAssistantMessageTexts(nextState));
+      return;
+    }
+
+    for (const notification of notifications) {
+      sendApplicationResponse(JSON.stringify(notification));
+    }
+    assistantMessageTextsByThreadId.set(threadId, snapshotAssistantMessageTexts(nextState));
+  }
+
   return {
     observeInbound,
     stopAll,
@@ -550,6 +580,93 @@ function projectPendingDesktopActions(threadId, conversationState) {
     .filter(Boolean);
 }
 
+// Desktop IPC exposes full conversation snapshots/patches, not app-server assistant delta events.
+// Mirror only suffix growth for assistant rows so phones can render the same live text progression.
+function projectDesktopAssistantDeltaNotifications(
+  threadId,
+  previousState,
+  nextState,
+  previousTexts = snapshotAssistantMessageTexts(previousState)
+) {
+  const nextMessages = collectAssistantMessages(nextState);
+  const notifications = [];
+
+  for (const message of nextMessages) {
+    const previousText = previousTexts.get(message.key) || "";
+    if (!message.text || !message.text.startsWith(previousText) || message.text.length <= previousText.length) {
+      continue;
+    }
+
+    const delta = message.text.slice(previousText.length);
+    notifications.push({
+      method: "item/agentMessage/delta",
+      params: {
+        threadId,
+        turnId: message.turnId,
+        itemId: message.itemId,
+        delta,
+      },
+    });
+  }
+
+  return notifications;
+}
+
+function snapshotAssistantMessageTexts(conversationState) {
+  return new Map(collectAssistantMessages(conversationState).map((message) => [message.key, message.text]));
+}
+
+function collectAssistantMessages(conversationState) {
+  const turns = Array.isArray(conversationState?.turns) ? conversationState.turns : [];
+  const messages = [];
+  for (const turn of turns) {
+    const turnId = readString(turn?.id) || readString(turn?.turnId) || readString(turn?.turn_id);
+    const items = Array.isArray(turn?.items) ? turn.items : [];
+    for (const item of items) {
+      if (!isAssistantMessageItem(item)) {
+        continue;
+      }
+
+      const itemId = readString(item?.id) || readString(item?.itemId) || readString(item?.item_id);
+      const text = assistantMessageText(item);
+      if (!turnId || !itemId) {
+        continue;
+      }
+
+      messages.push({
+        key: `${turnId}:${itemId}`,
+        turnId,
+        itemId,
+        text,
+      });
+    }
+  }
+  return messages;
+}
+
+function isAssistantMessageItem(item) {
+  const type = normalizeToken(item?.type);
+  if (type === "agentmessage" || type === "assistantmessage") {
+    return true;
+  }
+  return type === "message" && normalizeToken(item?.role) === "assistant";
+}
+
+function assistantMessageText(item) {
+  const directText = readString(item?.text) || readString(item?.message);
+  if (directText) {
+    return directText;
+  }
+
+  const content = Array.isArray(item?.content) ? item.content : [];
+  return content
+    .map((entry) => entry && typeof entry === "object" ? entry : null)
+    .filter(Boolean)
+    .map((entry) => readString(entry.text) || readString(entry?.data?.text))
+    .filter(Boolean)
+    .join("");
+}
+
 function projectPendingDesktopAction(threadId, request) {
   const requestId = requestIdKey(request.id);
   const method = readString(request.method);
@@ -572,6 +689,7 @@ function projectPendingDesktopAction(threadId, request) {
     method,
     params: {
       ...params,
+      remodexActionSource: DESKTOP_IPC_ACTION_SOURCE,
       threadId: readString(params.threadId) || readString(params.thread_id) || threadId,
     },
   };
@@ -674,6 +792,10 @@ function writeFrame(socket, payload, callback) {
 }
 
 function resolveDefaultIpcSocketPath() {
+  if (process.platform === "win32") {
+    return "\\\\.\\pipe\\codex-ipc";
+  }
+
   const uid = typeof process.getuid === "function" ? process.getuid() : 0;
   return path.join(os.tmpdir(), "codex-ipc", `ipc-${uid}.sock`);
 }
@@ -699,6 +821,12 @@ function readString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
 
+function normalizeToken(value) {
+  return typeof value === "string"
+    ? value.toLowerCase().replace(/[_-\s]+/g, "")
+    : "";
+}
+
 function cloneJSON(value) {
   return JSON.parse(JSON.stringify(value));
 }
@@ -715,6 +843,7 @@ module.exports = {
   applyConversationStateChange,
   createDesktopIpcActionFollower,
   desktopFollowerPayloadForResponse,
+  projectDesktopAssistantDeltaNotifications,
   projectPendingDesktopActions,
   resolveDefaultIpcSocketPath,
   seedConversationStateFromThreadRead,

package/src/git-handler.js

@@ -20,9 +20,11 @@ const GITHUB_CLI_TIMEOUT_MS = 120_000;
 const GIT_DRAFT_PATCH_MAX_BYTES = 80_000;
 const EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 const DEFAULT_GIT_WRITER_MODEL = "gpt-5.4-mini";
+const STATUS_UPSTREAM_FETCH_TTL_MS = 15_000;
 
 let runStructuredCodexJsonImpl = runStructuredCodexJson;
 let runGitHubCliImpl = runGitHubCli;
+const statusUpstreamFetchCache = new Map();
 
 function resolveGitWriterModel(rawModel) {
   const trimmed = typeof rawModel === "string" ? rawModel.trim() : "";
@@ -172,9 +174,43 @@ async function gitStatus(cwd) {
     return nonRepositoryStatus(cwd);
   }
 
-  const [porcelain, branchInfo, repoRoot] = await Promise.all([
+  const snapshot = await readGitStatusSnapshot(cwd);
+  const { ahead, behind } = await freshBranchInfoForStatus(cwd, snapshot);
+  const dirty = snapshot.files.length > 0;
+  const noUpstream = snapshot.tracking === null && !snapshot.detached;
+  const hasHeadCommit = await refExists(cwd, "HEAD").catch(() => false);
+  const hasPushRemote = await pushRemoteAvailable(cwd, snapshot.tracking).catch(() => false);
+  const publishedToRemote = !snapshot.detached && !!snapshot.branch && await remoteBranchExists(cwd, snapshot.branch).catch(() => false);
+  const localOnlyCommitCount = await countLocalOnlyCommits(cwd, { detached: snapshot.detached }).catch(() => 0);
+  const state = computeState(dirty, ahead, behind, snapshot.detached, noUpstream);
+  const canPush = hasPushRemote && hasHeadCommit && (ahead > 0 || noUpstream) && !snapshot.detached;
+  const diff = await repoDiffTotals(cwd, {
+    tracking: snapshot.tracking,
+    fileLines: snapshot.fileLines,
+  }).catch(() => ({ additions: 0, deletions: 0, binaryFiles: 0 }));
+
+  return {
+    isRepo: true,
+    repoRoot: snapshot.repoRoot,
+    branch: snapshot.branch,
+    tracking: snapshot.tracking,
+    dirty,
+    hasHeadCommit,
+    hasPushRemote,
+    ahead,
+    behind,
+    localOnlyCommitCount,
+    state,
+    canPush,
+    publishedToRemote,
+    files: snapshot.files,
+    diff,
+  };
+}
+
+async function readGitStatusSnapshot(cwd) {
+  const [porcelain, repoRoot] = await Promise.all([
     git(cwd, "status", "--porcelain=v1", "-b"),
-    revListCounts(cwd).catch(() => ({ ahead: 0, behind: 0 })),
     resolveRepoRoot(cwd).catch(() => null),
   ]);
 
@@ -184,45 +220,27 @@ async function gitStatus(cwd) {
 
   const branch = parseBranchFromStatus(branchLine);
   const tracking = parseTrackingFromStatus(branchLine);
+  const detached = branchLine.includes("HEAD detached") || branchLine.includes("no branch");
   const files = fileLines.map((line) => ({
     path: line.substring(3).trim(),
     status: line.substring(0, 2).trim(),
   }));
 
-  const dirty = files.length > 0;
-  const { ahead, behind } = branchInfo;
-  const detached = branchLine.includes("HEAD detached") || branchLine.includes("no branch");
-  const noUpstream = tracking === null && !detached;
-  const hasHeadCommit = await refExists(cwd, "HEAD").catch(() => false);
-  const hasPushRemote = await pushRemoteAvailable(cwd, tracking).catch(() => false);
-  const publishedToRemote = !detached && !!branch && await remoteBranchExists(cwd, branch).catch(() => false);
-  const localOnlyCommitCount = await countLocalOnlyCommits(cwd, { detached }).catch(() => 0);
-  const state = computeState(dirty, ahead, behind, detached, noUpstream);
-  const canPush = hasPushRemote && hasHeadCommit && (ahead > 0 || noUpstream) && !detached;
-  const diff = await repoDiffTotals(cwd, {
-    tracking,
-    fileLines,
-  }).catch(() => ({ additions: 0, deletions: 0, binaryFiles: 0 }));
-
   return {
-    isRepo: true,
     repoRoot,
     branch,
     tracking,
-    dirty,
-    hasHeadCommit,
-    hasPushRemote,
-    ahead,
-    behind,
-    localOnlyCommitCount,
-    state,
-    canPush,
-    publishedToRemote,
+    detached,
+    fileLines,
     files,
-    diff,
   };
 }
 
+async function freshBranchInfoForStatus(cwd, snapshot) {
+  await refreshStatusUpstreamIfNeeded(cwd, snapshot.tracking, snapshot.repoRoot).catch(() => false);
+  return await revListCounts(cwd).catch(() => ({ ahead: 0, behind: 0 }));
+}
+
 async function gitInit(cwd) {
   if (await isInsideGitWorkTree(cwd)) {
     throw gitError("already_git_repository", "This folder is already inside a Git repository.");
@@ -2506,6 +2524,52 @@ async function revListCounts(cwd) {
   };
 }
 
+// Keeps Update eligibility based on the current upstream ref, not stale local fetch data.
+async function refreshStatusUpstreamIfNeeded(cwd, tracking, repoRoot) {
+  const parsedTracking = parseTrackingRef(tracking);
+  if (!parsedTracking) {
+    return false;
+  }
+
+  const cacheKey = `${repoRoot || cwd}\0${parsedTracking.remote}\0${parsedTracking.branch}`;
+  const now = Date.now();
+  const lastFetchAt = statusUpstreamFetchCache.get(cacheKey) || 0;
+  if (now - lastFetchAt < STATUS_UPSTREAM_FETCH_TTL_MS) {
+    return false;
+  }
+
+  statusUpstreamFetchCache.set(cacheKey, now);
+  if (statusUpstreamFetchCache.size > 200) {
+    statusUpstreamFetchCache.clear();
+    statusUpstreamFetchCache.set(cacheKey, now);
+  }
+
+  await git(
+    cwd,
+    "fetch",
+    "--quiet",
+    parsedTracking.remote,
+    `+refs/heads/${parsedTracking.branch}:refs/remotes/${parsedTracking.remote}/${parsedTracking.branch}`
+  );
+  return true;
+}
+
+function parseTrackingRef(tracking) {
+  if (typeof tracking !== "string") {
+    return null;
+  }
+
+  const separatorIndex = tracking.indexOf("/");
+  if (separatorIndex <= 0 || separatorIndex === tracking.length - 1) {
+    return null;
+  }
+
+  return {
+    remote: tracking.slice(0, separatorIndex),
+    branch: tracking.slice(separatorIndex + 1),
+  };
+}
+
 function parseBranchFromStatus(line) {
   // "## main...origin/main" or "## main" or "## HEAD (no branch)"
   const match = line.match(/^## (.+?)(?:\.{3}|$)/);

package/src/index.js

@@ -5,7 +5,7 @@
 // Depends on: ./bridge, ./secure-device-state, ./session-state, ./rollout-watch, ./macos-launch-agent
 
 const { startBridge } = require("./bridge");
-const { readBridgeDeviceState, resetBridgeDeviceState } = require("./secure-device-state");
+const { readBridgeDeviceState, resetBridgeTrustState } = require("./secure-device-state");
 const { openLastActiveThread } = require("./session-state");
 const { watchThreadRollout } = require("./rollout-watch");
 const { readBridgeConfig } = require("./codex-desktop-refresher");
@@ -14,6 +14,7 @@ const {
   printMacOSBridgePairingQr,
   printMacOSBridgeServiceStatus,
   resetMacOSBridgePairing,
+  restartMacOSBridgeService,
   runMacOSBridgeService,
   startMacOSBridgeService,
   stopMacOSBridgeService,
@@ -26,11 +27,12 @@ module.exports = {
   readBridgeConfig,
   readBridgeDeviceState,
   resetMacOSBridgePairing,
+  restartMacOSBridgeService,
   startBridge,
   runMacOSBridgeService,
   startMacOSBridgeService,
   stopMacOSBridgeService,
-  resetBridgePairing: resetBridgeDeviceState,
+  resetBridgePairing: resetBridgeTrustState,
   openLastActiveThread,
   watchThreadRollout,
 };

package/src/ios-app-compatibility.js

@@ -4,10 +4,10 @@
 // Exports: version comparison + bridge/iPhone compatibility helpers
 // Depends on: none
 
-const MINIMUM_SUPPORTED_IOS_APP_VERSION = "1.5";
-const IOS_APP_COMPATIBILITY_GATE_BRIDGE_VERSION = "1.3.9";
-const LEGACY_BRIDGE_VERSION_FOR_IOS_1_0 = "1.3.7";
-const LEGACY_BRIDGE_DOWNGRADE_COMMAND = `npm install -g remodex@${LEGACY_BRIDGE_VERSION_FOR_IOS_1_0}`;
+const MINIMUM_SUPPORTED_IOS_APP_VERSION = "2.0";
+const IOS_APP_COMPATIBILITY_GATE_BRIDGE_VERSION = "2.0.0";
+const LEGACY_BRIDGE_VERSION_FOR_IOS_1_X = "1.5.1";
+const LEGACY_BRIDGE_DOWNGRADE_COMMAND = `npm install -g @makerbi/remodex@${LEGACY_BRIDGE_VERSION_FOR_IOS_1_X}`;
 const NOTICE_BOX_WIDTH = 74;
 
 function buildIOSAppCompatibilitySnapshot({
@@ -80,7 +80,7 @@ function buildSnapshot({
     isCompatible,
     requiresAppUpdate,
     minimumSupportedIOSAppVersion: MINIMUM_SUPPORTED_IOS_APP_VERSION,
-    legacyBridgeVersion: LEGACY_BRIDGE_VERSION_FOR_IOS_1_0,
+    legacyBridgeVersion: LEGACY_BRIDGE_VERSION_FOR_IOS_1_X,
     downgradeCommand: LEGACY_BRIDGE_DOWNGRADE_COMMAND,
     message,
   };
@@ -108,7 +108,7 @@ function buildLegacyIOSAppCompatibilityMessage({
   return `Remodex bridge ${normalizedBridgeVersion} requires Remodex iPhone `
     + `${MINIMUM_SUPPORTED_IOS_APP_VERSION} or later. `
     + `Update the iPhone app from the App Store first, or install Remodex bridge `
-    + `${LEGACY_BRIDGE_VERSION_FOR_IOS_1_0} to keep using iPhone ${normalizedIOSAppVersion}.`;
+    + `${LEGACY_BRIDGE_VERSION_FOR_IOS_1_X} to keep using iPhone ${normalizedIOSAppVersion}.`;
 }
 
 function buildCachedIOSAppCompatibilityWarning({
@@ -232,7 +232,7 @@ function splitVersionParts(value) {
 
 module.exports = {
   LEGACY_BRIDGE_DOWNGRADE_COMMAND,
-  LEGACY_BRIDGE_VERSION_FOR_IOS_1_0,
+  LEGACY_BRIDGE_VERSION_FOR_IOS_1_X,
   IOS_APP_COMPATIBILITY_GATE_BRIDGE_VERSION,
   MINIMUM_SUPPORTED_IOS_APP_VERSION,
   buildCachedIOSAppCompatibilityWarning,