@makerbi/remodex 1.5.0 → 1.5.2

package/src/macos-launch-agent.js

@@ -127,13 +127,19 @@ function stopMacOSBridgeService({
   platform = process.platform,
   execFileSyncImpl = execFileSync,
   fsImpl = fs,
+  processImpl = process,
 } = {}) {
   assertDarwinPlatform(platform);
+  const previousStatus = readBridgeStatus({ env, fsImpl });
   bootoutLaunchAgent({
     env,
     execFileSyncImpl,
     ignoreMissing: true,
   });
+  terminateRecordedBridgeProcess(previousStatus, {
+    execFileSyncImpl,
+    processImpl,
+  });
   clearPairingSession({ env, fsImpl });
   clearBridgeStatus({ env, fsImpl });
 }
@@ -156,6 +162,44 @@ function resetMacOSBridgePairing({
   return resetBridgePairingImpl();
 }
 
+// Stops orphaned run-service processes left behind when launchd reports the job missing.
+function terminateRecordedBridgeProcess(status, {
+  execFileSyncImpl = execFileSync,
+  processImpl = process,
+} = {}) {
+  const pid = Number(status?.pid);
+  if (!Number.isInteger(pid) || pid <= 0 || pid === processImpl.pid) {
+    return false;
+  }
+
+  if (!isRecordedRemodexBridgeProcess(pid, { execFileSyncImpl })) {
+    return false;
+  }
+
+  try {
+    processImpl.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Checks the command line before killing so stale status files cannot target unrelated processes.
+function isRecordedRemodexBridgeProcess(pid, { execFileSyncImpl = execFileSync } = {}) {
+  try {
+    const command = execFileSyncImpl("ps", [
+      "-p",
+      String(pid),
+      "-o",
+      "command=",
+    ], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return command.includes("remodex")
+      && command.includes("run-service");
+  } catch {
+    return false;
+  }
+}
+
 function getMacOSBridgeServiceStatus({
   env = process.env,
   platform = process.platform,

package/src/secure-device-state.js

@@ -14,6 +14,7 @@ const DEFAULT_STORE_DIR = path.join(os.homedir(), ".remodex");
 const DEFAULT_STORE_FILE = path.join(DEFAULT_STORE_DIR, "device-state.json");
 const KEYCHAIN_SERVICE = "com.remodex.bridge.device-state";
 const KEYCHAIN_ACCOUNT = "default";
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 let hasLoggedKeychainMismatch = false;
 
 // Loads the canonical bridge state or bootstraps a fresh one when no trusted state exists yet.
@@ -22,8 +23,11 @@ function loadOrCreateBridgeDeviceState() {
   const keychainRecord = readKeychainStateRecord();
 
   if (fileRecord.state) {
-    reconcileLegacyKeychainMirror(fileRecord.state, keychainRecord);
-    return fileRecord.state;
+    const canonicalState = recoverBridgeDeviceIdentity(fileRecord.state, {
+      fallbackState: keychainRecord.state,
+    });
+    reconcileLegacyKeychainMirror(canonicalState, keychainRecord);
+    return canonicalState;
   }
 
   if (fileRecord.error) {
@@ -31,8 +35,9 @@ function loadOrCreateBridgeDeviceState() {
       warnOnce(
         "[remodex] Recovering the canonical device-state.json from the legacy Keychain pairing mirror."
       );
-      writeBridgeDeviceState(keychainRecord.state);
-      return keychainRecord.state;
+      const recoveredState = recoverBridgeDeviceIdentity(keychainRecord.state);
+      writeBridgeDeviceState(recoveredState);
+      return recoveredState;
     }
     throw corruptedStateError("device-state.json", fileRecord.error);
   }
@@ -47,8 +52,9 @@ function loadOrCreateBridgeDeviceState() {
   }
 
   if (keychainRecord.state) {
-    writeBridgeDeviceState(keychainRecord.state);
-    return keychainRecord.state;
+    const recoveredState = recoverBridgeDeviceIdentity(keychainRecord.state);
+    writeBridgeDeviceState(recoveredState);
+    return recoveredState;
   }
 
   const nextState = createBridgeDeviceState();
@@ -86,7 +92,7 @@ function resolveBridgeRelaySession(state, { persist = true } = {}) {
   };
 }
 
-// Persists the trusted iPhone identity so reconnects can be authenticated during the current pairing flow.
+// Persists trusted mobile identities so reconnects can be authenticated across paired iPhone/iPad clients.
 function rememberTrustedPhone(state, phoneDeviceId, phoneIdentityPublicKey, { persist = true } = {}) {
   const normalizedDeviceId = normalizeNonEmptyString(phoneDeviceId);
   const normalizedPublicKey = normalizeNonEmptyString(phoneIdentityPublicKey);
@@ -94,10 +100,10 @@ function rememberTrustedPhone(state, phoneDeviceId, phoneIdentityPublicKey, { pe
     return state;
   }
 
-  // Remodex supports one trusted iPhone per Mac, so a new trust record replaces old ones.
   const nextState = normalizeBridgeDeviceState({
     ...state,
     trustedPhones: {
+      ...(state?.trustedPhones || {}),
       [normalizedDeviceId]: normalizedPublicKey,
     },
   });
@@ -382,10 +388,32 @@ function normalizeBridgeDeviceState(rawState) {
   };
 }
 
+function recoverBridgeDeviceIdentity(state, { fallbackState = null } = {}) {
+  if (isValidBridgeDeviceId(state?.macDeviceId)) {
+    return state;
+  }
+
+  if (fallbackState && isValidBridgeDeviceId(fallbackState.macDeviceId)) {
+    warnOnce("[remodex] Recovering an invalid saved bridge device identity from the legacy Keychain mirror.");
+    writeBridgeDeviceState(fallbackState);
+    return fallbackState;
+  }
+
+  warnOnce("[remodex] Rotating an invalid saved bridge device identity; scan the fresh QR to pair again.");
+  const nextState = createBridgeDeviceState();
+  nextState.lastSeenPhoneAppVersion = state?.lastSeenPhoneAppVersion || null;
+  writeBridgeDeviceState(nextState);
+  return nextState;
+}
+
 function bridgeStatesEqual(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
+function isValidBridgeDeviceId(value) {
+  return UUID_V4_PATTERN.test(normalizeNonEmptyString(value));
+}
+
 function normalizeNonEmptyString(value) {
   if (typeof value !== "string") {
     return "";

package/src/session-jsonl-history.js

@@ -0,0 +1,197 @@
+// FILE: session-jsonl-history.js
+// Purpose: Reconstructs a small thread/turns/list page from local Codex session JSONL files.
+
+const fs = require("fs");
+
+function readThreadTurnsListPageFromSessionJsonl(filePath, {
+  threadId = "",
+  limit = 5,
+  maxLimit = 5,
+  cursor = null,
+  fsModule = fs,
+} = {}) {
+  if (!filePath || cursor != null) {
+    return null;
+  }
+
+  const content = fsModule.readFileSync(filePath, "utf8");
+  const turns = parseSessionJsonlTurns(content, { threadId });
+  if (turns.length === 0) {
+    return null;
+  }
+
+  const requestedLimit = Number.isInteger(limit) && limit > 0 ? limit : 5;
+  const requestedMaxLimit = Number.isInteger(maxLimit) && maxLimit > 0 ? maxLimit : 5;
+  const safeLimit = Math.min(requestedLimit, requestedMaxLimit, 5);
+  const pageTurns = turns.slice(-safeLimit).reverse();
+  return {
+    data: pageTurns,
+    nextCursor: turns.length > pageTurns.length ? "remodex-jsonl-fallback-older-unavailable" : null,
+    remodexJsonlFallback: true,
+  };
+}
+
+function parseSessionJsonlTurns(content, { threadId = "" } = {}) {
+  const turns = [];
+  const turnsById = new Map();
+  let activeTurnId = "";
+  let sessionThreadId = normalizeString(threadId);
+
+  const lines = String(content || "").split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].trim();
+    if (!line) {
+      continue;
+    }
+
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (entry?.type === "session_meta") {
+      const payload = objectValue(entry.payload);
+      sessionThreadId ||= normalizeString(payload?.id)
+        || normalizeString(payload?.thread_id)
+        || normalizeString(payload?.threadId);
+      continue;
+    }
+
+    if (entry?.type === "event_msg") {
+      const payload = objectValue(entry.payload);
+      const eventType = normalizeString(payload?.type);
+      if (eventType === "task_started") {
+        activeTurnId = normalizeString(payload?.turn_id)
+          || normalizeString(payload?.turnId)
+          || activeTurnId
+          || `turn-line-${index + 1}`;
+        ensureTurn(turns, turnsById, activeTurnId, sessionThreadId, entry.timestamp);
+        continue;
+      }
+
+      if (eventType === "task_complete") {
+        const turn = ensureTurn(
+          turns,
+          turnsById,
+          normalizeString(payload?.turn_id) || normalizeString(payload?.turnId) || activeTurnId || `turn-line-${index + 1}`,
+          sessionThreadId,
+          entry.timestamp
+        );
+        turn.status = "completed";
+        continue;
+      }
+
+      if (eventType === "user_message") {
+        const turn = ensureTurn(
+          turns,
+          turnsById,
+          normalizeString(payload?.turn_id) || normalizeString(payload?.turnId) || activeTurnId || `turn-line-${index + 1}`,
+          sessionThreadId,
+          entry.timestamp
+        );
+        turn.items.push({
+          id: normalizeString(payload?.id) || `user-message-line-${index + 1}`,
+          type: "user_message",
+          role: "user",
+          text: normalizeString(payload?.message) || normalizeString(payload?.text),
+        });
+        continue;
+      }
+
+      // The final assistant text is usually present again as a response_item message.
+      // Skipping event agent_message avoids double-rendering streaming/final chunks.
+      continue;
+    }
+
+    if (entry?.type === "response_item") {
+      const payload = objectValue(entry.payload);
+      if (!payload) {
+        continue;
+      }
+      const turn = ensureTurn(
+        turns,
+        turnsById,
+        normalizeString(payload.turn_id) || normalizeString(payload.turnId) || activeTurnId || `turn-line-${index + 1}`,
+        sessionThreadId,
+        entry.timestamp
+      );
+      const item = normalizeResponseItemForHistory(payload, index + 1);
+      if (item) {
+        turn.items.push(item);
+      }
+    }
+  }
+
+  return turns.filter((turn) => turn.items.length > 0);
+}
+
+function ensureTurn(turns, turnsById, turnId, threadId, timestamp) {
+  const normalizedTurnId = normalizeString(turnId) || `turn-${turns.length + 1}`;
+  let turn = turnsById.get(normalizedTurnId);
+  if (!turn) {
+    turn = {
+      id: normalizedTurnId,
+      threadId: normalizeString(threadId) || undefined,
+      createdAt: normalizeString(timestamp) || undefined,
+      status: "running",
+      items: [],
+    };
+    turnsById.set(normalizedTurnId, turn);
+    turns.push(turn);
+  }
+  if (!turn.createdAt && timestamp) {
+    turn.createdAt = normalizeString(timestamp);
+  }
+  return turn;
+}
+
+function normalizeResponseItemForHistory(payload, lineNumber) {
+  const type = normalizeHistoryItemType(payload.type);
+  if (!type) {
+    return null;
+  }
+
+  const item = {
+    ...payload,
+    id: normalizeString(payload.id)
+      || normalizeString(payload.item_id)
+      || normalizeString(payload.itemId)
+      || `response-item-line-${lineNumber}`,
+    type,
+  };
+
+  if (type === "message" && !normalizeString(item.role)) {
+    item.role = "assistant";
+  }
+
+  return item;
+}
+
+function normalizeHistoryItemType(rawType) {
+  const normalized = normalizeString(rawType).toLowerCase().replace(/[\s_-]+/g, "");
+  if (!normalized) {
+    return "";
+  }
+  if (normalized === "functioncall") {
+    return "tool_call";
+  }
+  if (normalized === "functioncalloutput") {
+    return "tool_call_output";
+  }
+  return rawType;
+}
+
+function objectValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+
+function normalizeString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+module.exports = {
+  parseSessionJsonlTurns,
+  readThreadTurnsListPageFromSessionJsonl,
+};