@makerbi/remodex 1.3.8 → 1.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makerbi/remodex",
-  "version": "1.3.8",
+  "version": "1.3.10",
   "description": "Local bridge between Codex and the Remodex mobile app. Run `remodex up` to start.",
   "main": "src/index.js",
   "bin": {

package/src/bridge.js

@@ -51,12 +51,17 @@ const { createShortPairingCode, SHORT_PAIRING_CODE_LENGTH } = require("./qr");
 
 const execFileAsync = promisify(execFile);
 const RELAY_WATCHDOG_PING_INTERVAL_MS = 10_000;
-const RELAY_WATCHDOG_STALE_AFTER_MS = 25_000;
+// Keep the watchdog above the relay heartbeat cadence so quiet healthy sockets survive idle gaps.
+const RELAY_WATCHDOG_STALE_AFTER_MS = 70_000;
 const BRIDGE_STATUS_HEARTBEAT_INTERVAL_MS = 5_000;
 const STALE_RELAY_STATUS_MESSAGE = "Relay heartbeat stalled; reconnect pending.";
+const CLOSE_CODE_INVALID_RELAY_REQUEST = 4000;
+const CLOSE_CODE_REPLACED_BY_NEW_MAC = 4001;
+const CLOSE_CODE_MAC_UNAUTHORIZED = 4005;
 const RELAY_HISTORY_IMAGE_REFERENCE_URL = "remodex://history-image-elided";
-const RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES = 3 * 1024 * 1024;
+const RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES = 4 * 1024 * 1024;
 const RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS = 24_000;
+const RELAY_HISTORY_RECENT_TURN_TARGET = 40;
 
 function buildRelayUserAgentHeader({ version = bridgePackageVersion } = {}) {
   const normalizedVersion = typeof version === "string" && version.trim()
@@ -144,6 +149,7 @@ function startBridge({
   let lastRelayActivityAt = 0;
   let lastPublishedBridgeStatus = null;
   let lastConnectionStatus = null;
+  let lastConnectionError = "";
   let codexLaunchState = config.codexEndpoint ? "connected" : "starting";
   let codexHandshakeState = config.codexEndpoint ? "warm" : "cold";
   const forwardedInitializeRequestIds = new Set();
@@ -320,35 +326,42 @@ function startBridge({
   }
 
   // Keeps npm start output compact by emitting only high-signal connection states.
-  function logConnectionStatus(status) {
-    if (lastConnectionStatus === status) {
+  function logConnectionStatus(status, lastError = "") {
+    if (lastConnectionStatus === status && lastConnectionError === lastError) {
       return;
     }
 
     lastConnectionStatus = status;
+    lastConnectionError = lastError;
     publishBridgeStatus({
       state: "running",
       connectionStatus: status,
       pid: process.pid,
-      lastError: "",
+      lastError,
     });
     console.log(`[remodex] ${status}`);
+    if (lastError) {
+      console.error(`[remodex] ${lastError}`);
+    }
   }
 
   // Retries the relay socket while preserving the active Codex process and session id.
-  function scheduleRelayReconnect(closeCode) {
+  function scheduleRelayReconnect(closeCode, closeReason = "") {
     if (isShuttingDown) {
       return;
     }
 
-    if (closeCode === 4000 || closeCode === 4001) {
-      logConnectionStatus("disconnected");
+    if (isTerminalRelayCloseCode(closeCode)) {
+      const lastError = buildRelayCloseStatusError(closeCode, closeReason);
+      logConnectionStatus("disconnected", lastError);
       shutdown(codex, () => socket, () => {
         isShuttingDown = true;
         bridgeWakeAssertion.stop();
         clearReconnectTimer();
         clearRelayWatchdog();
         clearBridgeStatusHeartbeat();
+      }, {
+        exitCode: closeCode === CLOSE_CODE_MAC_UNAUTHORIZED ? 1 : 0,
       });
       return;
     }
@@ -419,18 +432,19 @@ function startBridge({
       markRelayActivity();
     });
 
-    nextSocket.on("close", (code) => {
+    nextSocket.on("close", (code, reason) => {
+      const closeReason = normalizeWebSocketCloseReason(reason);
       if (socket === nextSocket) {
         clearRelayWatchdog();
       }
-      logConnectionStatus("disconnected");
+      logConnectionStatus("disconnected", buildRelayCloseStatusError(code, closeReason));
       if (socket === nextSocket) {
         socket = null;
       }
       stopContextUsageWatcher();
       rolloutLiveMirror?.stopAll();
       desktopRefresher.handleTransportReset();
-      scheduleRelayReconnect(code);
+      scheduleRelayReconnect(code, closeReason);
     });
 
     nextSocket.on("error", () => {
@@ -471,12 +485,13 @@ function startBridge({
   codex.onClose(() => {
     clearRelayWatchdog();
     clearBridgeStatusHeartbeat();
-    logConnectionStatus("disconnected");
+    const lastError = lastConnectionError || "";
+    logConnectionStatus("disconnected", lastError);
     publishBridgeStatus({
       state: "stopped",
       connectionStatus: "disconnected",
       pid: process.pid,
-      lastError: "",
+      lastError,
     });
     isShuttingDown = true;
     bridgeWakeAssertion.stop();
@@ -1279,7 +1294,7 @@ function buildMacRegistration(deviceState, pairingSession) {
   };
 }
 
-function shutdown(codex, getSocket, beforeExit = () => {}) {
+function shutdown(codex, getSocket, beforeExit = () => {}, { exitCode = 0 } = {}) {
   beforeExit();
 
   const socket = getSocket();
@@ -1289,7 +1304,41 @@ function shutdown(codex, getSocket, beforeExit = () => {}) {
 
   codex.shutdown();
 
-  setTimeout(() => process.exit(0), 100);
+  setTimeout(() => process.exit(exitCode), 100);
+}
+
+function isTerminalRelayCloseCode(closeCode) {
+  return closeCode === CLOSE_CODE_INVALID_RELAY_REQUEST
+    || closeCode === CLOSE_CODE_REPLACED_BY_NEW_MAC
+    || closeCode === CLOSE_CODE_MAC_UNAUTHORIZED;
+}
+
+function normalizeWebSocketCloseReason(reason) {
+  if (typeof reason === "string") {
+    return reason.trim();
+  }
+
+  if (Buffer.isBuffer(reason)) {
+    return reason.toString("utf8").trim();
+  }
+
+  return "";
+}
+
+function buildRelayCloseStatusError(closeCode, closeReason = "") {
+  if (!Number.isInteger(closeCode) || closeCode === 1000 || closeCode === 1005) {
+    return "";
+  }
+
+  const normalizedReason = normalizeNonEmptyString(closeReason);
+  if (closeCode === CLOSE_CODE_MAC_UNAUTHORIZED) {
+    return normalizedReason
+      || "Relay authorization failed. Set REMODEX_RELAY_ACCESS_TOKEN or use a relay that does not require a Mac access token.";
+  }
+
+  return normalizedReason
+    ? `Relay closed the connection (${closeCode}): ${normalizedReason}`
+    : `Relay closed the connection (${closeCode}).`;
 }
 
 function extractBridgeMessageContext(rawMessage) {
@@ -1376,8 +1425,8 @@ function normalizeNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
 
-// Shrinks `thread/read` and `thread/resume` snapshots by eliding bulky history payloads
-// that the iPhone does not render directly (inline images, compaction replacement history).
+// Shrinks `thread/read` and `thread/resume` snapshots for mobile relay delivery.
+// This elides bulky blobs and replaces oversized older history with a compact marker.
 function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod) {
   if (requestMethod !== "thread/read" && requestMethod !== "thread/resume") {
     return rawMessage;
@@ -1779,19 +1828,25 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
   }
 
   const turns = thread.turns;
-  let trimmedTurns = turns.slice();
+  let trimmedTurns = turns.length > RELAY_HISTORY_RECENT_TURN_TARGET
+    ? turns.slice(-RELAY_HISTORY_RECENT_TURN_TARGET)
+    : turns.slice();
   while (trimmedTurns.length > 1) {
-    trimmedTurns = trimmedTurns.slice(1);
-    const candidateThread = {
-      ...thread,
-      turns: trimmedTurns,
-      historyTailTruncatedForRelay: true,
-    };
+    if (trimmedTurns.length === turns.length) {
+      trimmedTurns = trimmedTurns.slice(1);
+    }
+    const candidateThread = buildRelayHistoryCompactedThread(
+      thread,
+      buildRelayCompactedHistoryTurns(turns, trimmedTurns),
+      Math.max(0, turns.length - trimmedTurns.length),
+      trimmedTurns.length
+    );
     encoded = encodeRelayThreadPayload(parsed, candidateThread);
     if (encoded != null && Buffer.byteLength(encoded, "utf8") <= RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES) {
       return encoded;
     }
     workingThread = candidateThread;
+    trimmedTurns = trimmedTurns.slice(1);
   }
 
   const newestTurn = trimmedTurns[0];
@@ -1802,14 +1857,23 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
   let trimmedItems = newestTurn.items.slice();
   while (trimmedItems.length > 1) {
     trimmedItems = trimmedItems.slice(1);
-    const candidateThread = {
-      ...thread,
-      turns: [{
+    const compactedTurnPrefix = buildRelayHistoryCompactionTurn(
+      Math.max(0, turns.length - 1),
+      1,
+      thread
+    );
+    const candidateThread = buildRelayHistoryCompactedThread(
+      thread,
+      compactedTurnPrefix ? [compactedTurnPrefix, {
+        ...newestTurn,
+        items: trimmedItems,
+      }] : [{
         ...newestTurn,
         items: trimmedItems,
       }],
-      historyTailTruncatedForRelay: true,
-    };
+      Math.max(0, turns.length - 1),
+      1
+    );
     encoded = encodeRelayThreadPayload(parsed, candidateThread);
     if (encoded != null && Buffer.byteLength(encoded, "utf8") <= RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES) {
       return encoded;
@@ -1826,28 +1890,93 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
     mostRecentItem,
     RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS
   );
-  let candidateThread = {
-    ...thread,
-    turns: [{
-      ...newestTurn,
-      items: [truncatedItem],
-    }],
-    historyTailTruncatedForRelay: true,
-  };
+  let candidateThread = buildRelayHistoryCompactedThread(
+    thread,
+    [
+      ...buildRelayCompactedHistoryTurns(turns, [newestTurn]).slice(0, -1),
+      {
+        ...newestTurn,
+        items: [truncatedItem],
+      },
+    ],
+    Math.max(0, turns.length - 1),
+    1
+  );
   encoded = encodeRelayThreadPayload(parsed, candidateThread);
   if (encoded != null && Buffer.byteLength(encoded, "utf8") <= RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES) {
     return encoded;
   }
 
-  candidateThread = {
+  candidateThread = buildRelayHistoryCompactedThread(
+    thread,
+    [
+      ...buildRelayCompactedHistoryTurns(turns, [newestTurn]).slice(0, -1),
+      {
+        ...newestTurn,
+        items: [compactHistoryItemForRelay(mostRecentItem, RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS)],
+      },
+    ],
+    Math.max(0, turns.length - 1),
+    1
+  );
+  return encodeRelayThreadPayload(parsed, candidateThread);
+}
+
+function buildRelayHistoryCompactedThread(thread, turns, omittedTurnCount, keptTurnCount) {
+  return {
     ...thread,
-    turns: [{
-      ...newestTurn,
-      items: [compactHistoryItemForRelay(mostRecentItem, RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS)],
-    }],
+    turns,
     historyTailTruncatedForRelay: true,
+    remodexHistoryCompacted: omittedTurnCount > 0,
+    remodexOmittedTurnCount: omittedTurnCount,
+    remodexKeptTurnCount: keptTurnCount,
+  };
+}
+
+function buildRelayCompactedHistoryTurns(allTurns, keptTurns) {
+  const omittedTurnCount = Math.max(0, allTurns.length - keptTurns.length);
+  const compactionTurn = buildRelayHistoryCompactionTurn(
+    omittedTurnCount,
+    keptTurns.length,
+    allTurns[0]
+  );
+  return compactionTurn ? [compactionTurn, ...keptTurns] : keptTurns;
+}
+
+function buildRelayHistoryCompactionTurn(omittedTurnCount, keptTurnCount, idSource = {}) {
+  if (omittedTurnCount <= 0) {
+    return null;
+  }
+
+  const baseId = normalizeNonEmptyString(idSource?.id)
+    || normalizeNonEmptyString(idSource?.turnId)
+    || normalizeNonEmptyString(idSource?.turn_id)
+    || "history";
+  const text = [
+    "Earlier conversation compacted for mobile loading.",
+    "",
+    `Older turns omitted: ${omittedTurnCount}`,
+    `Recent turns kept: ${keptTurnCount}`,
+    "Full history remains available on the Mac runtime.",
+  ].join("\n");
+
+  return {
+    id: `remodex-history-compacted-${baseId}`,
+    remodexSynthetic: true,
+    remodexHistoryCompacted: true,
+    remodexOmittedTurnCount: omittedTurnCount,
+    remodexKeptTurnCount: keptTurnCount,
+    items: [
+      {
+        id: `remodex-history-compacted-item-${baseId}`,
+        type: "assistant_message",
+        role: "assistant",
+        text,
+        remodexSynthetic: true,
+        remodexHistoryCompacted: true,
+      },
+    ],
   };
-  return encodeRelayThreadPayload(parsed, candidateThread);
 }
 
 function encodeRelayThreadPayload(parsed, thread) {
@@ -2021,10 +2150,12 @@ function persistBridgePreferences(
 
 module.exports = {
   buildHeartbeatBridgeStatus,
+  buildRelayCloseStatusError,
   buildRelayAccessTokenHeaders,
   buildRelayUserAgentHeader,
   createMacOSBridgeWakeAssertion,
   hasRelayConnectionGoneStale,
+  isTerminalRelayCloseCode,
   persistBridgePreferences,
   sanitizeLiveGeneratedImageMessageForRelay,
   sanitizeThreadHistoryImagesForRelay,

package/src/ios-app-compatibility.js

@@ -4,8 +4,8 @@
 // Exports: version comparison + bridge/iPhone compatibility helpers
 // Depends on: none
 
-const MINIMUM_SUPPORTED_IOS_APP_VERSION = "1.1";
-const IOS_APP_COMPATIBILITY_GATE_BRIDGE_VERSION = "1.3.8";
+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 NOTICE_BOX_WIDTH = 74;

package/src/macos-launch-agent.js

@@ -334,6 +334,11 @@ function restartLaunchAgent({
     launchAgentDomain(env),
     plistPath,
   ], { stdio: ["ignore", "ignore", "pipe"] });
+  execFileSyncImpl("launchctl", [
+    "kickstart",
+    "-k",
+    launchAgentLabelDomain(env),
+  ], { stdio: ["ignore", "ignore", "pipe"] });
 }
 
 function bootoutLaunchAgent({

package/src/package-version-status.js

@@ -10,7 +10,7 @@ const { version: installedVersion = "" } = require("../package.json");
 const DEFAULT_CACHE_TTL_MS = 30 * 60 * 1000;
 const DEFAULT_EMPTY_CACHE_RETRY_MS = 60 * 1000;
 const DEFAULT_INITIAL_FETCH_WAIT_MS = 250;
-const REMODEX_REGISTRY_URL = "https://registry.npmjs.org/remodex/latest";
+const REMODEX_REGISTRY_URL = "https://registry.npmjs.org/@makerbi%2fremodex/latest";
 
 function createBridgePackageVersionStatusReader({
   cacheTtlMs = DEFAULT_CACHE_TTL_MS,

package/src/project-handler.js

@@ -9,6 +9,9 @@ const os = require("os");
 const path = require("path");
 
 const DEFAULT_DIRECTORY_LIMIT = 200;
+const DEFAULT_DIRECTORY_SEARCH_LIMIT = 80;
+const DEFAULT_DIRECTORY_SEARCH_MAX_DEPTH = 8;
+const DEFAULT_DIRECTORY_SEARCH_MAX_VISITED = 5000;
 const DEFAULT_HIDDEN_DIRECTORY_NAMES = new Set(["Library"]);
 
 // ─── ENTRY POINT ─────────────────────────────────────────────
@@ -57,6 +60,8 @@ async function handleProjectMethod(method, params, options = {}) {
       return projectQuickLocations(options);
     case "project/listDirectory":
       return projectListDirectory(params, options);
+    case "project/searchDirectories":
+      return projectSearchDirectories(params, options);
     case "project/validatePath":
       return projectValidatePath(params, options);
     case "project/createDirectory":
@@ -112,6 +117,32 @@ async function projectListDirectory(params, options = {}) {
   };
 }
 
+async function projectSearchDirectories(params, options = {}) {
+  const requestedPath = readString(params.path) || resolveHomeDir(options);
+  const query = readString(params.query);
+  const directory = await requireUsableDirectory(requestedPath, options);
+  if (!query) {
+    return {
+      path: directory.path,
+      entries: [],
+    };
+  }
+
+  const includeHidden = params.includeHidden === true;
+  const entries = await searchDirectoryEntries(directory.path, query, {
+    ...options,
+    includeHidden,
+    limit: normalizeSearchLimit(params.limit),
+    maxDepth: normalizeSearchDepth(params.maxDepth),
+    maxVisited: normalizeSearchVisitedLimit(params.maxVisited),
+  });
+
+  return {
+    path: directory.path,
+    entries,
+  };
+}
+
 async function projectValidatePath(params, options = {}) {
   const requestedPath = readString(params.path);
   if (!requestedPath) {
@@ -181,6 +212,62 @@ async function readDirectoryEntries(directoryPath, options = {}) {
     .slice(0, options.limit || DEFAULT_DIRECTORY_LIMIT);
 }
 
+async function searchDirectoryEntries(rootPath, query, options = {}) {
+  const tokens = searchTokens(query);
+  if (!tokens.length) {
+    return [];
+  }
+
+  const limit = options.limit || DEFAULT_DIRECTORY_SEARCH_LIMIT;
+  const maxDepth = options.maxDepth ?? DEFAULT_DIRECTORY_SEARCH_MAX_DEPTH;
+  const maxVisited = options.maxVisited || DEFAULT_DIRECTORY_SEARCH_MAX_VISITED;
+  const queue = [{ directoryPath: rootPath, depth: 0 }];
+  const visitedDirectories = new Set([realpathSyncIfAvailable(rootPath) || rootPath]);
+  const matches = [];
+  let visitedCount = 0;
+
+  while (queue.length && matches.length < limit && visitedCount < maxVisited) {
+    const { directoryPath, depth } = queue.shift();
+    visitedCount += 1;
+
+    let dirents;
+    try {
+      dirents = await fs.promises.readdir(directoryPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const dirent of sortedDirents(dirents)) {
+      if (!options.includeHidden && isHiddenDirectoryName(dirent.name)) {
+        continue;
+      }
+
+      const childPath = path.join(directoryPath, dirent.name);
+      const directory = await directoryEntryForPath(childPath, dirent, options);
+      if (!directory) {
+        continue;
+      }
+
+      if (directoryMatchesSearch(directory, tokens)) {
+        matches.push(directory);
+        if (matches.length >= limit) {
+          break;
+        }
+      }
+
+      if (!dirent.isSymbolicLink() && depth < maxDepth) {
+        const realPath = directory.path;
+        if (!visitedDirectories.has(realPath)) {
+          visitedDirectories.add(realPath);
+          queue.push({ directoryPath: realPath, depth: depth + 1 });
+        }
+      }
+    }
+  }
+
+  return matches;
+}
+
 async function directoryEntryForPath(candidatePath, dirent, options = {}) {
   if (!dirent.isDirectory() && !dirent.isSymbolicLink()) {
     return null;
@@ -325,6 +412,52 @@ function normalizeLimit(rawLimit) {
   return Math.min(Math.floor(numericLimit), DEFAULT_DIRECTORY_LIMIT);
 }
 
+function normalizeSearchLimit(rawLimit) {
+  const numericLimit = Number(rawLimit);
+  if (!Number.isFinite(numericLimit) || numericLimit <= 0) {
+    return DEFAULT_DIRECTORY_SEARCH_LIMIT;
+  }
+
+  return Math.min(Math.floor(numericLimit), DEFAULT_DIRECTORY_SEARCH_LIMIT);
+}
+
+function normalizeSearchDepth(rawDepth) {
+  const numericDepth = Number(rawDepth);
+  if (!Number.isFinite(numericDepth) || numericDepth < 0) {
+    return DEFAULT_DIRECTORY_SEARCH_MAX_DEPTH;
+  }
+
+  return Math.min(Math.floor(numericDepth), DEFAULT_DIRECTORY_SEARCH_MAX_DEPTH);
+}
+
+function normalizeSearchVisitedLimit(rawLimit) {
+  const numericLimit = Number(rawLimit);
+  if (!Number.isFinite(numericLimit) || numericLimit <= 0) {
+    return DEFAULT_DIRECTORY_SEARCH_MAX_VISITED;
+  }
+
+  return Math.min(Math.floor(numericLimit), DEFAULT_DIRECTORY_SEARCH_MAX_VISITED);
+}
+
+function sortedDirents(dirents) {
+  return [...dirents].sort((left, right) => (
+    left.name.localeCompare(right.name, undefined, { sensitivity: "base" })
+  ));
+}
+
+function searchTokens(query) {
+  return query
+    .toLowerCase()
+    .split(/\s+/)
+    .map((token) => token.trim())
+    .filter(Boolean);
+}
+
+function directoryMatchesSearch(directory, tokens) {
+  const haystack = directory.name.toLowerCase();
+  return tokens.every((token) => haystack.includes(token));
+}
+
 function resolveHomeDir(options = {}) {
   return options.homeDir || os.homedir();
 }
@@ -353,6 +486,7 @@ module.exports = {
   handleProjectMethod,
   projectQuickLocations,
   projectListDirectory,
+  projectSearchDirectories,
   projectValidatePath,
   projectCreateDirectory,
   validateDirectory,