@makerbi/remodex 1.3.8 → 1.3.9

package/package.json

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

package/src/bridge.js

@@ -51,12 +51,14 @@ 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 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()
@@ -1376,8 +1378,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 +1781,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 +1810,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 +1843,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) {

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/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,