@makerbi/remodex 1.5.4 → 2.0.0

package/src/macos-launch-agent.js

@@ -5,13 +5,14 @@
 // Depends on: child_process, fs, os, path, ./bridge, ./daemon-state, ./codex-desktop-refresher, ./qr, ./secure-device-state
 
 const { execFileSync } = require("child_process");
+const { createHash } = require("crypto");
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
 const { startBridge } = require("./bridge");
 const { readBridgeConfig } = require("./codex-desktop-refresher");
 const { printQR } = require("./qr");
-const { resetBridgeDeviceState } = require("./secure-device-state");
+const { readBridgeDeviceState, resetBridgeTrustState } = require("./secure-device-state");
 const {
   clearBridgeStatus,
   clearPairingSession,
@@ -122,6 +123,65 @@ async function startMacOSBridgeService({
   };
 }
 
+// Restarts the installed LaunchAgent without rewriting relay config, useful during local bridge development.
+async function restartMacOSBridgeService({
+  env = process.env,
+  platform = process.platform,
+  fsImpl = fs,
+  execFileSyncImpl = execFileSync,
+  osImpl = os,
+  waitForPairing = false,
+  pairingTimeoutMs = DEFAULT_PAIRING_WAIT_TIMEOUT_MS,
+  pairingPollIntervalMs = DEFAULT_PAIRING_WAIT_INTERVAL_MS,
+  ...startOptions
+} = {}) {
+  assertDarwinPlatform(platform);
+  const plistPath = resolveLaunchAgentPlistPath({ env, osImpl });
+  if (!fsImpl.existsSync(plistPath)) {
+    return startMacOSBridgeService({
+      env,
+      platform,
+      fsImpl,
+      execFileSyncImpl,
+      osImpl,
+      waitForPairing,
+      pairingTimeoutMs,
+      pairingPollIntervalMs,
+      ...startOptions,
+    });
+  }
+
+  const startedAt = Date.now();
+  if (waitForPairing) {
+    clearPairingSession({ env, fsImpl });
+  }
+
+  kickstartLaunchAgent({
+    env,
+    execFileSyncImpl,
+    plistPath,
+  });
+
+  if (waitForPairing) {
+    const pairingSession = await waitForFreshPairingSession({
+      env,
+      fsImpl,
+      startedAt,
+      timeoutMs: pairingTimeoutMs,
+      intervalMs: pairingPollIntervalMs,
+    });
+    return {
+      plistPath,
+      pairingSession,
+    };
+  }
+
+  return {
+    plistPath,
+    pairingSession: null,
+  };
+}
+
 function stopMacOSBridgeService({
   env = process.env,
   platform = process.platform,
@@ -150,7 +210,7 @@ function resetMacOSBridgePairing({
   platform = process.platform,
   execFileSyncImpl = execFileSync,
   fsImpl = fs,
-  resetBridgePairingImpl = resetBridgeDeviceState,
+  resetBridgePairingImpl = resetBridgeTrustState,
 } = {}) {
   assertDarwinPlatform(platform);
   stopMacOSBridgeService({
@@ -217,6 +277,7 @@ function getMacOSBridgeServiceStatus({
     daemonConfig: sanitizedDaemonConfigForStatus(readDaemonConfig({ env, fsImpl })),
     bridgeStatus: readBridgeStatus({ env, fsImpl }),
     pairingSession: readPairingSession({ env, fsImpl }),
+    trustedDevice: buildTrustedDeviceSummary(readBridgeDeviceState()),
     stdoutLogPath: resolveBridgeStdoutLogPath({ env }),
     stderrLogPath: resolveBridgeStderrLogPath({ env }),
   };
@@ -242,12 +303,18 @@ function printMacOSBridgeServiceStatus(options = {}) {
   const bridgeState = status.bridgeStatus?.state || "unknown";
   const connectionStatus = status.bridgeStatus?.connectionStatus || "unknown";
   const pairingCreatedAt = status.pairingSession?.createdAt || "none";
+  const activeDevice = status.bridgeStatus?.activeDevice || status.bridgeStatus?.activePhone;
+  const trustedPhoneCount = status.trustedDevice?.trustedPhoneCount || 0;
+  const activeDeviceName = formatDeviceKind(activeDevice?.deviceKind) || "device";
+  const trustedDeviceName = formatDeviceKind(status.trustedDevice?.lastSeenDeviceKind) || "device";
   console.log(`[remodex] Service label: ${status.label}`);
   console.log(`[remodex] Installed: ${status.installed ? "yes" : "no"}`);
   console.log(`[remodex] Launchd loaded: ${status.launchdLoaded ? "yes" : "no"}`);
   console.log(`[remodex] PID: ${status.launchdPid || status.bridgeStatus?.pid || "unknown"}`);
   console.log(`[remodex] Bridge state: ${bridgeState}`);
   console.log(`[remodex] Connection: ${connectionStatus}`);
+  console.log(`[remodex] Active ${activeDeviceName}: ${activeDevice?.connected ? activeDevice.phoneFingerprint || "yes" : "no"}`);
+  console.log(`[remodex] Trusted ${trustedDeviceName}: ${trustedPhoneCount > 0 ? "yes" : "no"}`);
   console.log(`[remodex] Pairing payload: ${pairingCreatedAt}`);
   console.log(`[remodex] Stdout log: ${status.stdoutLogPath}`);
   console.log(`[remodex] Stderr log: ${status.stderrLogPath}`);
@@ -388,6 +455,31 @@ function restartLaunchAgent({
   ], { stdio: ["ignore", "ignore", "pipe"] });
 }
 
+function kickstartLaunchAgent({
+  env = process.env,
+  execFileSyncImpl = execFileSync,
+  plistPath,
+} = {}) {
+  try {
+    execFileSyncImpl("launchctl", [
+      "kickstart",
+      "-k",
+      launchAgentLabelDomain(env),
+    ], { stdio: ["ignore", "ignore", "pipe"] });
+  } catch {
+    execFileSyncImpl("launchctl", [
+      "bootstrap",
+      launchAgentDomain(env),
+      plistPath,
+    ], { stdio: ["ignore", "ignore", "pipe"] });
+    execFileSyncImpl("launchctl", [
+      "kickstart",
+      "-k",
+      launchAgentLabelDomain(env),
+    ], { stdio: ["ignore", "ignore", "pipe"] });
+  }
+}
+
 function bootoutLaunchAgent({
   env = process.env,
   execFileSyncImpl = execFileSync,
@@ -544,7 +636,44 @@ function normalizeNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
 
+function buildTrustedDeviceSummary(deviceState) {
+  const trustedPhoneEntries = Object.entries(deviceState?.trustedPhones || {})
+    .filter(([phoneDeviceId, publicKey]) => normalizeNonEmptyString(phoneDeviceId) && normalizeNonEmptyString(publicKey));
+  const firstTrustedPhoneId = trustedPhoneEntries[0]?.[0] || "";
+  const lastSeenPhoneAppVersion = normalizeNonEmptyString(deviceState?.lastSeenPhoneAppVersion) || null;
+  return {
+    macDeviceFingerprint: shortFingerprint(deviceState?.macDeviceId),
+    trustedPhoneCount: trustedPhoneEntries.length,
+    trustedPhoneFingerprint: shortFingerprint(firstTrustedPhoneId),
+    lastSeenDeviceKind: normalizeNonEmptyString(deviceState?.lastSeenDeviceKind) || (lastSeenPhoneAppVersion ? "iphone" : null),
+    lastSeenPhoneAppVersion,
+  };
+}
+
+function formatDeviceKind(deviceKind) {
+  const normalized = normalizeNonEmptyString(deviceKind).toLowerCase();
+  if (normalized === "iphone") {
+    return "iPhone";
+  }
+  if (normalized === "android") {
+    return "Android";
+  }
+  if (normalized === "mac") {
+    return "Mac";
+  }
+  return "";
+}
+
+function shortFingerprint(value) {
+  const normalized = normalizeNonEmptyString(value);
+  if (!normalized) {
+    return null;
+  }
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 8);
+}
+
 module.exports = {
+  buildTrustedDeviceSummary,
   buildLaunchAgentPlist,
   getMacOSBridgeServiceStatus,
   mergeBridgeStatusForDaemon,
@@ -552,6 +681,7 @@ module.exports = {
   printMacOSBridgeServiceStatus,
   resetMacOSBridgePairing,
   resolveLaunchAgentPlistPath,
+  restartMacOSBridgeService,
   runMacOSBridgeService,
   startMacOSBridgeService,
   stopMacOSBridgeService,

package/src/project-handler.js

@@ -2,11 +2,12 @@
 // Purpose: Serves safe Mac-local project folder discovery and creation requests from the iOS app.
 // Layer: Bridge handler
 // Exports: handleProjectRequest plus testable project filesystem helpers
-// Depends on: fs, os, path
+// Depends on: fs, os, path, ./codex-home
 
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
+const { resolveCodexHome } = require("./codex-home");
 
 const DEFAULT_DIRECTORY_LIMIT = 200;
 const DEFAULT_DIRECTORY_SEARCH_LIMIT = 80;
@@ -14,6 +15,14 @@ const DEFAULT_DIRECTORY_SEARCH_MAX_DEPTH = 8;
 const DEFAULT_DIRECTORY_SEARCH_MAX_VISITED = 5000;
 const DEFAULT_HIDDEN_DIRECTORY_NAMES = new Set(["Library"]);
 
+// Rootless chat slug rules mirror Codex Desktop's `~/Documents/Codex/<DATE>/<slug>`
+// convention so iOS-created Quick Chats land in the same bucket Desktop classifies
+// as projectless.
+const ROOTLESS_CHAT_SLUG_MAX_TOKENS = 6;
+const ROOTLESS_CHAT_SLUG_MAX_LENGTH = 60;
+const ROOTLESS_CHAT_SLUG_FALLBACK = "new-chat";
+const ROOTLESS_CHAT_DEDUP_LIMIT = 50;
+
 // ─── ENTRY POINT ─────────────────────────────────────────────
 
 function handleProjectRequest(rawMessage, sendResponse) {
@@ -58,6 +67,8 @@ async function handleProjectMethod(method, params, options = {}) {
   switch (method) {
     case "project/quickLocations":
       return projectQuickLocations(options);
+    case "project/projectlessRoots":
+      return projectProjectlessRoots(options);
     case "project/listDirectory":
       return projectListDirectory(params, options);
     case "project/searchDirectories":
@@ -66,6 +77,8 @@ async function handleProjectMethod(method, params, options = {}) {
       return projectValidatePath(params, options);
     case "project/createDirectory":
       return projectCreateDirectory(params, options);
+    case "project/createRootlessChatRoot":
+      return projectCreateRootlessChatRoot(params, options);
     default:
       throw projectError("unknown_method", `Unknown project method: ${method}`);
   }
@@ -99,6 +112,24 @@ async function projectQuickLocations(options = {}) {
   return { locations };
 }
 
+async function projectProjectlessRoots(options = {}) {
+  const homeDir = resolveHomeDir(options);
+  const codexHome = path.resolve(readString(options.codexHome) || resolveCodexHome());
+  const documentedThreadsRoot = path.join(codexHome, "threads");
+  const desktopDocumentsRoot = path.join(homeDir, "Documents", "Codex");
+  const roots = uniqueExistingOrCandidatePaths([
+    documentedThreadsRoot,
+    desktopDocumentsRoot,
+  ]);
+
+  return {
+    codexHome,
+    roots,
+    documentedThreadsRoot,
+    desktopDocumentsRoot,
+  };
+}
+
 async function projectListDirectory(params, options = {}) {
   const requestedPath = readString(params.path) || resolveHomeDir(options);
   const directory = await requireUsableDirectory(requestedPath, options);
@@ -184,6 +215,116 @@ async function projectCreateDirectory(params, options = {}) {
   };
 }
 
+// Mirrors the Codex Desktop "Chats" convention by materializing a dated rootless
+// chat folder under `~/Documents/Codex/<DATE>/<slug>` (or its Windows equivalent
+// `%USERPROFILE%\Documents\Codex\<DATE>\<slug>`) before the iOS client issues
+// `thread/start`. Without an explicit cwd the app-server falls back to its own
+// process working directory (often the user's home), which would otherwise show
+// up in the sidebar as a project named after the user account.
+async function projectCreateRootlessChatRoot(params = {}, options = {}) {
+  const homeDir = resolveHomeDir(options);
+  const desktopDocumentsRoot = path.join(homeDir, "Documents", "Codex");
+  const dateFolder = readString(params.dateFolder) || formatRootlessChatDate(new Date());
+  if (!isISODateFolderName(dateFolder)) {
+    throw projectError("invalid_date_folder", "The chat date folder must be in YYYY-MM-DD format.");
+  }
+
+  const slugBase = rootlessChatSlugFromPromptHint(params.promptHint);
+  const dateRootPath = path.join(desktopDocumentsRoot, dateFolder);
+
+  try {
+    await fs.promises.mkdir(dateRootPath, { recursive: true });
+  } catch (error) {
+    throw projectError("create_failed", error?.message || "Unable to prepare the Codex chats folder.");
+  }
+
+  const targetPath = await reserveUniqueRootlessChatPath(dateRootPath, slugBase);
+  try {
+    await fs.promises.mkdir(targetPath, { recursive: false });
+  } catch (error) {
+    if (error?.code !== "EEXIST") {
+      throw projectError("create_failed", error?.message || "Unable to create the rootless chat folder.");
+    }
+  }
+
+  const resolvedPath = await safeRealpath(targetPath);
+  return {
+    path: resolvedPath,
+    parentPath: dateRootPath,
+    name: path.basename(resolvedPath),
+    slug: slugBase,
+    dateFolder,
+    root: desktopDocumentsRoot,
+  };
+}
+
+// Codex Desktop generates kebab-case slugs from the first words of the prompt
+// (e.g. "mi-dici-la-pwd-corrente" from "mi dici la pwd corrente?"). We mirror
+// the same shape so that side-by-side users with the desktop app see a
+// consistent chat folder naming scheme.
+function rootlessChatSlugFromPromptHint(rawPromptHint) {
+  const hint = typeof rawPromptHint === "string" ? rawPromptHint.normalize("NFKD") : "";
+  const sanitized = hint
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gu, " ")
+    .trim();
+  if (!sanitized) {
+    return ROOTLESS_CHAT_SLUG_FALLBACK;
+  }
+
+  const tokens = sanitized
+    .split(/\s+/)
+    .filter(Boolean)
+    .slice(0, ROOTLESS_CHAT_SLUG_MAX_TOKENS);
+  if (!tokens.length) {
+    return ROOTLESS_CHAT_SLUG_FALLBACK;
+  }
+
+  let slug = tokens.join("-");
+  if (slug.length > ROOTLESS_CHAT_SLUG_MAX_LENGTH) {
+    slug = slug.slice(0, ROOTLESS_CHAT_SLUG_MAX_LENGTH).replace(/-+$/g, "");
+  }
+  return slug || ROOTLESS_CHAT_SLUG_FALLBACK;
+}
+
+// Appends "-2", "-3", … so two rapid-fire chats with the same first words
+// keep distinct folders instead of fighting over the same path.
+async function reserveUniqueRootlessChatPath(parentDirectory, slugBase) {
+  for (let attempt = 0; attempt < ROOTLESS_CHAT_DEDUP_LIMIT; attempt += 1) {
+    const candidateSlug = attempt === 0 ? slugBase : `${slugBase}-${attempt + 1}`;
+    const candidatePath = path.join(parentDirectory, candidateSlug);
+    try {
+      await fs.promises.access(candidatePath, fs.constants.F_OK);
+    } catch {
+      return candidatePath;
+    }
+  }
+
+  return path.join(parentDirectory, `${slugBase}-${Date.now()}`);
+}
+
+function formatRootlessChatDate(date) {
+  const year = date.getFullYear().toString().padStart(4, "0");
+  const month = (date.getMonth() + 1).toString().padStart(2, "0");
+  const day = date.getDate().toString().padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+function isISODateFolderName(value) {
+  if (typeof value !== "string" || value.length !== 10) {
+    return false;
+  }
+  return /^\d{4}-\d{2}-\d{2}$/u.test(value);
+}
+
+async function safeRealpath(candidatePath) {
+  try {
+    return await fs.promises.realpath(candidatePath);
+  } catch {
+    return path.resolve(candidatePath);
+  }
+}
+
 // ─── Filesystem Helpers ──────────────────────────────────────
 
 async function readDirectoryEntries(directoryPath, options = {}) {
@@ -462,6 +603,23 @@ function resolveHomeDir(options = {}) {
   return options.homeDir || os.homedir();
 }
 
+function uniqueExistingOrCandidatePaths(paths) {
+  const seen = new Set();
+  const result = [];
+
+  for (const candidatePath of paths) {
+    const normalizedPath = path.resolve(candidatePath);
+    const realPath = realpathSyncIfAvailable(normalizedPath) || normalizedPath;
+    if (seen.has(realPath)) {
+      continue;
+    }
+    seen.add(realPath);
+    result.push(realPath);
+  }
+
+  return result;
+}
+
 function realpathSyncIfAvailable(candidatePath) {
   try {
     return fs.realpathSync(candidatePath);
@@ -485,9 +643,12 @@ module.exports = {
   handleProjectRequest,
   handleProjectMethod,
   projectQuickLocations,
+  projectProjectlessRoots,
   projectListDirectory,
   projectSearchDirectories,
   projectValidatePath,
   projectCreateDirectory,
+  projectCreateRootlessChatRoot,
   validateDirectory,
+  rootlessChatSlugFromPromptHint,
 };

package/src/push-notification-service-client.js

@@ -5,6 +5,8 @@
 // Depends on: global fetch
 
 const DEFAULT_PUSH_SERVICE_TIMEOUT_MS = 10_000;
+const DEFAULT_PUSH_SERVICE_RETRY_LIMIT = 2;
+const DEFAULT_PUSH_SERVICE_RETRY_BASE_DELAY_MS = 500;
 
 function createPushNotificationServiceClient({
   baseUrl = "",
@@ -13,8 +15,16 @@ function createPushNotificationServiceClient({
   fetchImpl = globalThis.fetch,
   logPrefix = "[remodex]",
   requestTimeoutMs = DEFAULT_PUSH_SERVICE_TIMEOUT_MS,
+  retryLimit = DEFAULT_PUSH_SERVICE_RETRY_LIMIT,
+  retryBaseDelayMs = DEFAULT_PUSH_SERVICE_RETRY_BASE_DELAY_MS,
+  sleepImpl = sleep,
 } = {}) {
   const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const safeRetryLimit = normalizeNonNegativeInteger(retryLimit, DEFAULT_PUSH_SERVICE_RETRY_LIMIT);
+  const safeRetryBaseDelayMs = normalizeNonNegativeInteger(
+    retryBaseDelayMs,
+    DEFAULT_PUSH_SERVICE_RETRY_BASE_DELAY_MS
+  );
 
   async function registerDevice({
     deviceToken,
@@ -55,48 +65,70 @@ function createPushNotificationServiceClient({
       return { ok: false, skipped: true };
     }
 
-    const controller = typeof AbortController === "function" && requestTimeoutMs > 0
-      ? new AbortController()
-      : null;
-    const timeoutID = controller
-      ? setTimeout(() => {
-        controller.abort(createTimeoutAbortError(requestTimeoutMs));
-      }, requestTimeoutMs)
-      : null;
-
-    let response;
-    try {
-      response = await fetchImpl(`${normalizedBaseUrl}${pathname}`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-        },
-        body: JSON.stringify(payload),
-        signal: controller?.signal,
-      });
-    } catch (error) {
-      if (isAbortError(error)) {
-        const timeoutError = new Error(`Push service request timed out after ${requestTimeoutMs}ms`);
-        timeoutError.code = "push_request_timeout";
-        throw timeoutError;
+    const bodyJSON = JSON.stringify(payload);
+    let lastError = null;
+    for (let attempt = 0; attempt <= safeRetryLimit; attempt += 1) {
+      if (attempt > 0) {
+        const delayMs = safeRetryBaseDelayMs * Math.pow(2, attempt - 1);
+        if (delayMs > 0) {
+          await sleepImpl(delayMs);
+        }
       }
-      throw error;
-    } finally {
-      if (timeoutID) {
-        clearTimeout(timeoutID);
+
+      const controller = typeof AbortController === "function" && requestTimeoutMs > 0
+        ? new AbortController()
+        : null;
+      const timeoutID = controller
+        ? setTimeout(() => {
+          controller.abort(createTimeoutAbortError(requestTimeoutMs));
+        }, requestTimeoutMs)
+        : null;
+
+      let response;
+      try {
+        response = await fetchImpl(`${normalizedBaseUrl}${pathname}`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+          },
+          body: bodyJSON,
+          signal: controller?.signal,
+        });
+      } catch (error) {
+        lastError = error;
+        if (isAbortError(error)) {
+          continue;
+        }
+        if (isRetryableNetworkError(error)) {
+          continue;
+        }
+        throw error;
+      } finally {
+        if (timeoutID) {
+          clearTimeout(timeoutID);
+        }
+      }
+
+      const responseText = await response.text();
+      const parsed = safeParseJSON(responseText);
+      if (!response.ok) {
+        const message = parsed?.error || parsed?.message || responseText || `HTTP ${response.status}`;
+        const error = new Error(message);
+        error.status = response.status;
+        if (response.status >= 500 && attempt < safeRetryLimit) {
+          lastError = error;
+          continue;
+        }
+        throw error;
       }
-    }
 
-    const responseText = await response.text();
-    const parsed = safeParseJSON(responseText);
-    if (!response.ok) {
-      const message = parsed?.error || parsed?.message || responseText || `HTTP ${response.status}`;
-      const error = new Error(message);
-      error.status = response.status;
-      throw error;
+      return parsed ?? { ok: true };
     }
 
-    return parsed ?? { ok: true };
+    if (lastError) {
+      throw lastError;
+    }
+    return { ok: false };
   }
 
   return {
@@ -127,6 +159,7 @@ function normalizeBaseUrl(value) {
 function createTimeoutAbortError(timeoutMs) {
   const error = new Error(`Push service request timed out after ${timeoutMs}ms`);
   error.name = "AbortError";
+  error.code = "push_request_timeout";
   return error;
 }
 
@@ -134,6 +167,21 @@ function isAbortError(error) {
   return error?.name === "AbortError" || error?.code === "ABORT_ERR";
 }
 
+function isRetryableNetworkError(error) {
+  const code = error?.code ?? "";
+  return code === "ECONNRESET" || code === "ECONNREFUSED" || code === "ETIMEDOUT"
+    || code === "ENETUNREACH" || code === "EHOSTUNREACH" || code === "ENOTFOUND"
+    || error?.message?.includes("fetch failed");
+}
+
+function normalizeNonNegativeInteger(value, fallback) {
+  return Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+function sleep(delayMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
 function safeParseJSON(value) {
   if (!value || typeof value !== "string") {
     return null;

package/src/push-notification-tracker.js

@@ -9,6 +9,9 @@ const {
 } = require("./push-notification-completion-dedupe");
 
 const DEFAULT_PREVIEW_MAX_CHARS = 160;
+const MAX_THREAD_TITLE_ENTRIES = 200;
+const MAX_TURN_STATE_ENTRIES = 500;
+const MAX_THREAD_ID_BY_TURN_ENTRIES = 500;
 
 function createPushNotificationTracker({
   sessionId,
@@ -73,6 +76,10 @@ function createPushNotificationTracker({
   // Remembers thread/turn linkage before the terminal event arrives on a different payload shape.
   function rememberMessageContext({ threadId, turnId, params, eventObject }) {
     if (threadId && turnId) {
+      if (!threadIdByTurnId.has(turnId) && threadIdByTurnId.size >= MAX_THREAD_ID_BY_TURN_ENTRIES) {
+        const oldest = threadIdByTurnId.keys().next().value;
+        threadIdByTurnId.delete(oldest);
+      }
       threadIdByTurnId.set(turnId, threadId);
       ensureTurnState(threadId, turnId);
     }
@@ -83,6 +90,10 @@ function createPushNotificationTracker({
 
     const nextTitle = extractThreadTitle(params, eventObject);
     if (nextTitle) {
+      if (!threadTitleById.has(threadId) && threadTitleById.size >= MAX_THREAD_TITLE_ENTRIES) {
+        const oldest = threadTitleById.keys().next().value;
+        threadTitleById.delete(oldest);
+      }
       threadTitleById.set(threadId, nextTitle);
     }
   }
@@ -225,6 +236,10 @@ function createPushNotificationTracker({
   function ensureTurnState(threadId, turnId) {
     const key = turnStateKey(threadId, turnId);
     if (!turnStateByKey.has(key)) {
+      if (turnStateByKey.size >= MAX_TURN_STATE_ENTRIES) {
+        const oldest = turnStateByKey.keys().next().value;
+        turnStateByKey.delete(oldest);
+      }
       turnStateByKey.set(key, {
         latestAssistantPreview: "",
         latestFailurePreview: "",

package/src/qr.js

@@ -9,7 +9,6 @@ const qrcode = require("qrcode-terminal");
 
 const SHORT_PAIRING_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 const SHORT_PAIRING_CODE_LENGTH = 10;
-
 // Generates a short-lived human-friendly pairing token for reconnect flows.
 function createShortPairingCode({
   length = SHORT_PAIRING_CODE_LENGTH,
@@ -50,7 +49,7 @@ function printQR(pairingSessionOrPayload, options = {}) {
   console.log("\nScan this QR with the iPhone:\n");
   qrcode.generate(payload, { small: true });
   if (pairingCode) {
-    console.log("Or paste this pairing code in the iPhone app:\n");
+    console.log("Or enter this pairing code in the iPhone app:\n");
     console.log(pairingCode);
   }
   console.log(`\nSession ID: ${sessionIdShort || "(none)"}`);
@@ -58,9 +57,7 @@ function printQR(pairingSessionOrPayload, options = {}) {
   console.log(`Expires: ${new Date(pairingPayload.expiresAt).toISOString()}\n`);
 
   if (shouldPrintPairingJson({ env, explicitValue: options.printPairingJson })) {
-    // Opt-in only: this is the same bearer-like payload as the QR scan target.
-    console.log("Pairing JSON (debug only; same sensitive bytes as the QR):\n");
-    console.log(`${payload}\n`);
+    console.log("Pairing JSON debug output is disabled because the payload contains private relay metadata.\n");
   }
 }