@makerbi/remodex 1.5.4 → 2.0.0

package/src/rollout-live-mirror.js

@@ -12,10 +12,12 @@ const {
   resolveSessionsRoot,
 } = require("./rollout-watch");
 const { resolveCodexGeneratedImagesRoot } = require("./codex-home");
+const { buildApplyPatchFileChangeItem } = require("./apply-patch-changes");
 
 const DEFAULT_POLL_INTERVAL_MS = 700;
 const DEFAULT_LOOKUP_TIMEOUT_MS = 5_000;
 const DEFAULT_IDLE_TIMEOUT_MS = 60_000;
+const DEFAULT_ACTIVITY_HEARTBEAT_MS = 5_000;
 const DESKTOP_RESUME_METHODS = new Set(["thread/read", "thread/resume"]);
 
 // Observes desktop-authored rollout files and replays the currently active run as
@@ -30,6 +32,7 @@ function createRolloutLiveMirrorController({
   pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
   lookupTimeoutMs = DEFAULT_LOOKUP_TIMEOUT_MS,
   idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS,
+  activityHeartbeatMs = DEFAULT_ACTIVITY_HEARTBEAT_MS,
 } = {}) {
   const mirrorsByThreadId = new Map();
 
@@ -63,6 +66,7 @@ function createRolloutLiveMirrorController({
       pollIntervalMs,
       lookupTimeoutMs,
       idleTimeoutMs,
+      activityHeartbeatMs,
       onStop() {
         if (mirrorsByThreadId.get(threadId) === mirror) {
           mirrorsByThreadId.delete(threadId);
@@ -98,6 +102,7 @@ function createThreadRolloutLiveMirror({
   pollIntervalMs,
   lookupTimeoutMs,
   idleTimeoutMs,
+  activityHeartbeatMs,
   onStop = () => {},
 }) {
   const startedAt = now();
@@ -108,6 +113,7 @@ function createThreadRolloutLiveMirror({
   let lastSize = 0;
   let partialLine = "";
   let lastActivityAt = startedAt;
+  let lastHeartbeatAt = 0;
   let didBootstrap = false;
 
   const intervalId = setIntervalFn(tick, pollIntervalMs);
@@ -148,6 +154,7 @@ function createThreadRolloutLiveMirror({
         });
         lastSize = fileSize;
         lastActivityAt = currentTime;
+        lastHeartbeatAt = currentTime;
         if (state.isDesktopOrigin === false) {
           stop();
         }
@@ -158,17 +165,37 @@ function createThreadRolloutLiveMirror({
         const chunk = readFileSlice(rolloutPath, lastSize, fileSize, fsModule);
         lastSize = fileSize;
         lastActivityAt = currentTime;
+        lastHeartbeatAt = currentTime;
         if (!chunk) {
           return;
         }
 
-        const combined = `${partialLine}${chunk}`;
-        const lines = combined.split("\n");
-        partialLine = lines.pop() || "";
+        const combined = partialLine ? `${partialLine}${chunk}` : chunk;
+        let searchStart = 0;
+        let nlIndex;
+        const lines = [];
+        while ((nlIndex = combined.indexOf("\n", searchStart)) !== -1) {
+          lines.push(combined.substring(searchStart, nlIndex));
+          searchStart = nlIndex + 1;
+        }
+        partialLine = searchStart < combined.length ? combined.substring(searchStart) : "";
         processRolloutLines(lines, state, sendApplicationResponse);
         return;
       }
 
+      if (
+        state.isDesktopOrigin !== false
+        && state.activeTurnId
+        && currentTime - lastHeartbeatAt >= activityHeartbeatMs
+      ) {
+        lastHeartbeatAt = currentTime;
+        sendApplicationResponse(JSON.stringify(createNotification("turn/activity", {
+          threadId: state.threadId,
+          turnId: state.activeTurnId,
+          id: state.activeTurnId,
+        })));
+      }
+
       if (currentTime - lastActivityAt >= idleTimeoutMs) {
         stop();
       }
@@ -269,9 +296,6 @@ function bootstrapFromExistingRollout({
   }
 
   state.isDesktopOrigin = true;
-  if (activeTurnId) {
-    state.activeTurnId = activeTurnId;
-  }
   processRolloutLines(activeRunLines, state, sendApplicationResponse);
 }
 
@@ -320,21 +344,25 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
     const eventType = readString(payload.type);
 
     if (eventType === "task_started") {
-      const turnId = readString(payload.turn_id) || readString(payload.turnId);
-      if (!turnId) {
-        return [];
-      }
-
+      const explicitTurnId = readString(payload.turn_id) || readString(payload.turnId);
+      const turnId = explicitTurnId || buildSyntheticTurnId(state, entry);
       state.activeTurnId = turnId;
+      state.activeTurnIdIsSynthetic = !explicitTurnId;
       state.reasoningItemId = buildSyntheticItemId("thinking", state.threadId, turnId);
       state.hasThinking = false;
       state.commandCalls.clear();
+      state.applyPatchCalls.clear();
+      state.emittedPatchApplyEndCalls.clear();
 
-      notifications.push(createNotification("turn/started", {
+      const startedParams = {
         threadId: state.threadId,
-        turnId,
-        id: turnId,
-      }));
+        remodexDesktopMirror: true,
+        remodexRolloutLiveMirror: true,
+      };
+      startedParams.turnId = turnId;
+      startedParams.id = turnId;
+      notifications.push(createNotification("turn/started", startedParams));
+      notifications.push(...flushPendingUserMessageNotifications(state, turnId));
       notifications.push(...ensureThinkingNotifications(state));
       return notifications;
     }
@@ -345,20 +373,32 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
         return [];
       }
 
+      const turnId = resolveRolloutEventTurnId(state, payload);
+      if (!turnId) {
+        state.pendingUserMessages.push({
+          id: readString(payload.id),
+          message,
+          timestamp: readUserMessageTimestamp(entry, payload),
+        });
+        return [];
+      }
+
       notifications.push(createNotification("codex/event/user_message", {
         threadId: state.threadId,
-        turnId: readString(payload.turn_id) || readString(payload.turnId) || state.activeTurnId || "",
+        turnId,
         message,
+        ...timestampParams(readUserMessageTimestamp(entry, payload)),
       }));
       return notifications;
     }
 
     if (eventType === "task_complete") {
-      const turnId = readString(payload.turn_id) || readString(payload.turnId) || state.activeTurnId;
+      const turnId = resolveRolloutEventTurnId(state, payload);
       if (!turnId) {
         return [];
       }
 
+      notifications.push(...turnFileChangeSnapshotNotifications(state, turnId));
       notifications.push(createNotification("turn/completed", {
         threadId: state.threadId,
         turnId,
@@ -368,6 +408,11 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
       return notifications;
     }
 
+    if (eventType === "item_completed") {
+      notifications.push(...itemCompletedNotifications(state, payload));
+      return notifications;
+    }
+
     if (eventType === "agent_reasoning") {
       notifications.push(...reasoningNotifications(state, firstNonEmptyString([
         readString(payload.message),
@@ -382,7 +427,7 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
       if (!message || !shouldMirrorAgentMessage(payload)) {
         return [];
       }
-      const turnId = readString(payload.turn_id) || readString(payload.turnId) || state.activeTurnId || "";
+      const turnId = resolveRolloutEventTurnId(state, payload);
 
       notifications.push(createNotification("codex/event/agent_message", {
         threadId: state.threadId,
@@ -400,6 +445,11 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
       return notifications;
     }
 
+    if (eventType === "patch_apply_end") {
+      notifications.push(...patchApplyEndNotifications(state, payload));
+      return notifications;
+    }
+
     return [];
   }
 
@@ -420,6 +470,11 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
     return notifications;
   }
 
+  if (itemType === "customtoolcall") {
+    notifications.push(...customToolStartNotifications(state, payload));
+    return notifications;
+  }
+
   if (itemType === "functioncalloutput") {
     notifications.push(...toolOutputNotifications(state, payload));
     return notifications;
@@ -466,6 +521,13 @@ function toolStartNotifications(state, payload) {
   }
 
   const argumentsObject = parseToolArguments(payload.arguments);
+  if (isInternalProgressPlanToolName(toolName)) {
+    return [
+      ...ensureThinkingNotifications(state),
+      ...planUpdateNotifications(state, argumentsObject),
+    ];
+  }
+
   state.commandCalls.set(callId, {
     toolName,
     command: resolveToolCommand(toolName, argumentsObject),
@@ -503,6 +565,114 @@ function toolStartNotifications(state, payload) {
   ];
 }
 
+function customToolStartNotifications(state, payload) {
+  if (!state.activeTurnId) {
+    return [];
+  }
+
+  const callId = readString(payload.call_id) || readString(payload.callId);
+  const toolName = readString(payload.name);
+  if (!callId || !toolName) {
+    return [];
+  }
+
+  const notifications = [...ensureThinkingNotifications(state)];
+  if (toolName === "apply_patch") {
+    const item = buildApplyPatchFileChangeItem({
+      callId,
+      patch: readString(payload.input),
+      status: readString(payload.status) || "completed",
+      idFallback: buildSyntheticItemId("file-change", state.threadId, state.activeTurnId, callId),
+    });
+    if (item) {
+      state.applyPatchCalls.set(callId, item);
+      notifications.push(createNotification("codex/event/patch_apply_begin", {
+        threadId: state.threadId,
+        turnId: state.activeTurnId,
+        id: state.activeTurnId,
+        call_id: callId,
+        itemId: item.id,
+        status: "inProgress",
+        changes: item.changes,
+      }));
+    }
+  }
+
+  const activityMessage = genericToolActivityMessage(toolName);
+  if (!activityMessage) {
+    return notifications;
+  }
+
+  return [
+    ...notifications,
+    createNotification("codex/event/background_event", {
+      threadId: state.threadId,
+      turnId: state.activeTurnId,
+      call_id: callId,
+      message: activityMessage,
+    }),
+  ];
+}
+
+function patchApplyEndNotifications(state, payload) {
+  const turnId = resolveRolloutEventTurnId(state, payload);
+  const callId = readString(payload.call_id) || readString(payload.callId);
+  if (!turnId || !callId || state.emittedPatchApplyEndCalls.has(callId)) {
+    return [];
+  }
+
+  const fileChangeItem = state.applyPatchCalls.get(callId);
+  const changes = Array.isArray(payload.changes)
+    ? payload.changes
+    : fileChangeItem?.changes || [];
+  if (changes.length === 0) {
+    return [];
+  }
+
+  state.emittedPatchApplyEndCalls.add(callId);
+  return [
+    ...ensureThinkingNotifications(state),
+    createNotification("codex/event/patch_apply_end", {
+      threadId: state.threadId,
+      turnId,
+      id: turnId,
+      call_id: callId,
+      itemId: fileChangeItem?.id || callId,
+      status: readString(payload.status) || fileChangeItem?.status || "completed",
+      success: payload.success !== false,
+      changes,
+    }),
+  ];
+}
+
+function turnFileChangeSnapshotNotifications(state, turnId) {
+  const patchEntries = Array.from(state.applyPatchCalls.entries());
+  if (!turnId || patchEntries.length === 0) {
+    return [];
+  }
+
+  const changes = patchEntries.flatMap(([, item]) => Array.isArray(item?.changes) ? item.changes : []);
+  if (changes.length === 0) {
+    return [];
+  }
+
+  const [lastCallId, lastItem] = patchEntries[patchEntries.length - 1];
+  const itemId = readString(lastItem?.id) || readString(lastCallId) || buildSyntheticItemId("file-change", state.threadId, turnId);
+  return [
+    createNotification("codex/event/patch_apply_end", {
+      threadId: state.threadId,
+      turnId,
+      id: turnId,
+      call_id: itemId,
+      itemId,
+      status: "completed",
+      success: true,
+      changes,
+      remodexTurnFileChangeSnapshot: true,
+    }),
+  ];
+}
+
 function toolOutputNotifications(state, payload) {
   if (!state.activeTurnId) {
     return [];
@@ -597,6 +767,28 @@ function imageGenerationNotifications(state, payload, { preferCallId = false } =
   ];
 }
 
+function itemCompletedNotifications(state, payload) {
+  const item = payload && typeof payload.item === "object" && !Array.isArray(payload.item)
+    ? payload.item
+    : null;
+  if (!item || normalizeRolloutItemType(item.type) !== "plan") {
+    return [];
+  }
+
+  const turnId = resolveRolloutEventTurnId(state, payload);
+  if (!turnId) {
+    return [];
+  }
+
+  return [
+    createNotification("item/completed", {
+      threadId: state.threadId,
+      turnId,
+      item,
+    }),
+  ];
+}
+
 function ensureThinkingNotifications(state) {
   if (!state.activeTurnId || state.hasThinking) {
     return [];
@@ -626,6 +818,10 @@ function createMirrorState(threadId) {
     reasoningItemId: null,
     hasThinking: false,
     commandCalls: new Map(),
+    applyPatchCalls: new Map(),
+    emittedPatchApplyEndCalls: new Set(),
+    pendingUserMessages: [],
+    activeTurnIdIsSynthetic: false,
   };
 }
 
@@ -677,6 +873,58 @@ function parseToolArguments(rawArguments) {
   return parsed && typeof parsed === "object" ? parsed : {};
 }
 
+function planUpdateNotifications(state, argumentsObject) {
+  const plan = normalizeProgressPlanSteps(argumentsObject.plan);
+  if (plan.length === 0) {
+    return [];
+  }
+
+  const params = {
+    threadId: state.threadId,
+    turnId: state.activeTurnId,
+    plan,
+  };
+  const explanation = readString(argumentsObject.explanation);
+  if (explanation) {
+    params.explanation = explanation;
+  }
+
+  return [createNotification("turn/plan/updated", params)];
+}
+
+function normalizeProgressPlanSteps(rawPlan) {
+  if (!Array.isArray(rawPlan)) {
+    return [];
+  }
+
+  return rawPlan.flatMap((rawStep) => {
+    if (!rawStep || typeof rawStep !== "object") {
+      return [];
+    }
+
+    const step = readString(rawStep.step);
+    const status = normalizeProgressPlanStatus(rawStep.status);
+    if (!step || !status) {
+      return [];
+    }
+
+    return [{ step, status }];
+  });
+}
+
+function normalizeProgressPlanStatus(rawStatus) {
+  const normalized = readString(rawStatus);
+  switch (normalized) {
+  case "pending":
+  case "in_progress":
+  case "inProgress":
+  case "completed":
+    return normalized;
+  default:
+    return "";
+  }
+}
+
 function resolveToolCommand(toolName, argumentsObject) {
   if (isCommandToolName(toolName)) {
     return firstNonEmptyString([
@@ -704,6 +952,10 @@ function isCommandToolName(toolName) {
   return normalized === "exec_command" || normalized === "shell_command";
 }
 
+function isInternalProgressPlanToolName(toolName) {
+  return readString(toolName).toLowerCase() === "update_plan";
+}
+
 function genericToolActivityMessage(toolName) {
   switch (readString(toolName).toLowerCase()) {
   case "apply_patch":
@@ -722,8 +974,51 @@ function shouldMirrorAgentMessage(payload) {
   return phase !== "commentary";
 }
 
-function createNotification(method, params) {
-  return { method, params };
+function createNotification(method, params = {}) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return { method, params };
+  }
+
+  return {
+    method,
+    params: {
+      remodexDesktopMirror: true,
+      remodexRolloutLiveMirror: true,
+      ...params,
+    },
+  };
+}
+
+function flushPendingUserMessageNotifications(state, turnId) {
+  const messages = state.pendingUserMessages.splice(0);
+  if (messages.length === 0) {
+    return [];
+  }
+
+  return messages.map((pending) => createNotification("codex/event/user_message", {
+    threadId: state.threadId,
+    turnId: turnId || state.activeTurnId || "",
+    message: pending.message,
+    ...(pending.id ? { id: pending.id } : {}),
+    ...timestampParams(pending.timestamp),
+  }));
+}
+
+function readUserMessageTimestamp(entry, payload = {}) {
+  return firstNonEmptyString([
+    readString(payload.createdAt),
+    readString(payload.created_at),
+    readString(payload.timestamp),
+    readString(payload.time),
+    readString(entry?.timestamp),
+  ]);
+}
+
+function timestampParams(timestamp) {
+  const normalizedTimestamp = readString(timestamp);
+  return normalizedTimestamp
+    ? { createdAt: normalizedTimestamp, timestamp: normalizedTimestamp }
+    : {};
 }
 
 function buildSyntheticItemId(kind, threadId, turnId, suffix = "") {
@@ -731,6 +1026,18 @@ function buildSyntheticItemId(kind, threadId, turnId, suffix = "") {
   return `rollout-${kind}:${threadId}:${turnId}${suffixPart}`;
 }
 
+function buildSyntheticTurnId(state, entry) {
+  const timestamp = readString(entry?.timestamp) || "unknown";
+  return `rollout-turn:${state.threadId}:${timestamp}`;
+}
+
+function resolveRolloutEventTurnId(state, payload = {}) {
+  if (state.activeTurnIdIsSynthetic && state.activeTurnId) {
+    return state.activeTurnId;
+  }
+  return readString(payload.turn_id) || readString(payload.turnId) || state.activeTurnId || "";
+}
+
 function buildAgentMessageItemId(threadId, turnId, entry, message) {
   const timestamp = readString(entry?.timestamp) || "untimed";
   const messageHash = crypto
@@ -765,6 +1072,10 @@ function resetRunState(state) {
   state.reasoningItemId = null;
   state.hasThinking = false;
   state.commandCalls.clear();
+  state.applyPatchCalls.clear();
+  state.emittedPatchApplyEndCalls.clear();
+  state.pendingUserMessages.length = 0;
+  state.activeTurnIdIsSynthetic = false;
 }
 
 function readThreadId(params) {

package/src/rollout-watch.js

@@ -498,7 +498,11 @@ function collectRecentRolloutFiles(
     }
   }
 
-  candidates.sort(compareRolloutFileOrder);
+  candidates.sort((lhs, rhs) =>
+    (rhs.mtimeMs - lhs.mtimeMs)
+      || path.basename(rhs.filePath).localeCompare(path.basename(lhs.filePath))
+      || rhs.filePath.localeCompare(lhs.filePath)
+  );
   return candidates.slice(0, candidateLimit);
 }
 

package/src/secure-device-state.js

@@ -1,7 +1,7 @@
 // FILE: secure-device-state.js
-// Purpose: Persists canonical bridge identity, trusted-phone state, and last seen iPhone app version for local QR pairing.
+// Purpose: Persists canonical bridge identity, trusted mobile state, and last seen companion metadata for local QR pairing.
 // Layer: CLI helper
-// Exports: loadOrCreateBridgeDeviceState, readBridgeDeviceState, resetBridgeDeviceState, rememberTrustedPhone, rememberLastSeenPhoneAppVersion, getTrustedPhonePublicKey, resolveBridgeRelaySession
+// Exports: loadOrCreateBridgeDeviceState, readBridgeDeviceState, resetBridgeDeviceState, resetBridgeTrustState, rememberTrustedPhone, rememberLastSeenPhoneAppVersion, rememberLastSeenClientDeviceKind, getTrustedPhonePublicKey, resolveBridgeRelaySession
 // Depends on: fs, os, path, crypto, child_process
 
 const fs = require("fs");
@@ -83,6 +83,30 @@ function resetBridgeDeviceState() {
   };
 }
 
+// Clears trusted phones while preserving the Mac's stable identity across re-pairing.
+function resetBridgeTrustState() {
+  const existingState = readBridgeDeviceState();
+  if (!existingState) {
+    return {
+      hadState: false,
+      preservedMacIdentity: false,
+      clearedTrustedPhones: false,
+    };
+  }
+
+  const nextState = normalizeBridgeDeviceState({
+    ...existingState,
+    trustedPhones: {},
+  });
+  const clearedTrustedPhones = Object.keys(existingState.trustedPhones || {}).length > 0;
+  writeBridgeDeviceState(nextState);
+  return {
+    hadState: true,
+    preservedMacIdentity: true,
+    clearedTrustedPhones,
+  };
+}
+
 // Generates a fresh relay session for every bridge launch so QR pairing stays explicit per-run.
 function resolveBridgeRelaySession(state, { persist = true } = {}) {
   return {
@@ -129,6 +153,22 @@ function rememberLastSeenPhoneAppVersion(state, phoneAppVersion, { persist = tru
   return nextState;
 }
 
+function rememberLastSeenClientDeviceKind(state, deviceKind, { persist = true } = {}) {
+  const normalizedDeviceKind = normalizeDeviceKind(deviceKind);
+  if (!normalizedDeviceKind) {
+    return state;
+  }
+
+  const nextState = normalizeBridgeDeviceState({
+    ...state,
+    lastSeenDeviceKind: normalizedDeviceKind,
+  });
+  if (persist) {
+    writeBridgeDeviceState(nextState);
+  }
+  return nextState;
+}
+
 function getTrustedPhonePublicKey(state, phoneDeviceId) {
   const normalizedDeviceId = normalizeNonEmptyString(phoneDeviceId);
   if (!normalizedDeviceId) {
@@ -152,6 +192,7 @@ function createBridgeDeviceState() {
     macIdentityPublicKey: base64UrlToBase64(publicJwk.x),
     macIdentityPrivateKey: base64UrlToBase64(privateJwk.d),
     trustedPhones: {},
+    lastSeenDeviceKind: null,
     lastSeenPhoneAppVersion: null,
   };
 }
@@ -361,6 +402,8 @@ function normalizeBridgeDeviceState(rawState) {
   const macIdentityPublicKey = normalizeNonEmptyString(rawState?.macIdentityPublicKey);
   const macIdentityPrivateKey = normalizeNonEmptyString(rawState?.macIdentityPrivateKey);
   const lastSeenPhoneAppVersion = normalizeNonEmptyString(rawState?.lastSeenPhoneAppVersion) || null;
+  const lastSeenDeviceKind = normalizeDeviceKind(rawState?.lastSeenDeviceKind)
+    || inferLegacyDeviceKind({ lastSeenPhoneAppVersion });
 
   if (!macDeviceId || !macIdentityPublicKey || !macIdentityPrivateKey) {
     throw new Error("Bridge device state is incomplete");
@@ -384,6 +427,7 @@ function normalizeBridgeDeviceState(rawState) {
     macIdentityPublicKey,
     macIdentityPrivateKey,
     trustedPhones,
+    lastSeenDeviceKind,
     lastSeenPhoneAppVersion,
   };
 }
@@ -406,6 +450,24 @@ function recoverBridgeDeviceIdentity(state, { fallbackState = null } = {}) {
   return nextState;
 }
 
+function normalizeDeviceKind(value) {
+  const normalized = normalizeNonEmptyString(value).toLowerCase();
+  if (normalized === "ios" || normalized === "iphone") {
+    return "iphone";
+  }
+  if (normalized === "android") {
+    return "android";
+  }
+  if (normalized === "mac" || normalized === "macos" || normalized === "darwin") {
+    return "mac";
+  }
+  return normalized || null;
+}
+
+function inferLegacyDeviceKind({ lastSeenPhoneAppVersion } = {}) {
+  return lastSeenPhoneAppVersion ? "iphone" : null;
+}
+
 function bridgeStatesEqual(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
@@ -451,8 +513,10 @@ module.exports = {
   getTrustedPhonePublicKey,
   loadOrCreateBridgeDeviceState,
   readBridgeDeviceState,
+  rememberLastSeenClientDeviceKind,
   rememberLastSeenPhoneAppVersion,
   rememberTrustedPhone,
   resetBridgeDeviceState,
+  resetBridgeTrustState,
   resolveBridgeRelaySession,
 };