androdex 1.1.5 → 1.1.6

package/README.md

@@ -102,12 +102,32 @@ npm install
 npm start
 ```
 
+## Release
+
+Publish the npm package from this directory, not from the repository root:
+
+```sh
+cd androdex-bridge
+npm test
+npm pack --dry-run
+npm version patch --no-git-tag-version
+npm publish --access public
+```
+
+Verify the published version after the release:
+
+```sh
+npm view androdex version
+```
+
+If your npm account requires write-time 2FA, rerun the publish command with `--otp=<code>`.
+
 ## Manual Smoke Checklist
 
 1. Run `androdex up` and confirm the Android app can pair successfully.
 2. Run `androdex up` inside a workspace and confirm the host keeps Codex bound to that local project.
 3. From Android, open an existing thread and create a new one to confirm the remote client flow still works end to end.
-4. If desktop refresh is enabled, verify phone-authored thread activity updates the host Codex desktop as expected without a Settings bounce.
+4. If desktop refresh is enabled, verify phone-authored thread activity updates the host Codex desktop via the Settings-bounce remount workaround.
 5. Restart the launchd service or reconnect the phone and confirm the saved pairing and active workspace recover without losing host-local state.
 
 ## Project status

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "androdex",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "macOS host bridge between Codex and the Androdex Android app. Run `androdex up` to start.",
   "main": "src/index.js",
   "bin": {

package/src/bridge.js

@@ -11,7 +11,6 @@ const {
   CodexDesktopRefresher,
   readBridgeConfig,
 } = require("./codex-desktop-refresher");
-const { createDesktopThreadReadRefresher } = require("./codex-desktop-thread-sync");
 const { createCodexRpcClient } = require("./codex-rpc-client");
 const { createThreadRolloutActivityWatcher } = require("./rollout-watch");
 const { printQR } = require("./qr");
@@ -132,18 +131,12 @@ function startBridge({
     },
     requestIdPrefix: `androdex-bridge-${sessionId}`,
   });
-  const refreshDesktopThreadState = createDesktopThreadReadRefresher({
-    sendCodexRequest(method, params) {
-      return codexRpcClient.sendRequest(method, params);
-    },
-  });
   const desktopRefresher = new CodexDesktopRefresher({
     enabled: config.refreshEnabled,
     debounceMs: config.refreshDebounceMs,
     refreshCommand: config.refreshCommand,
     bundleId: config.codexBundleId,
     appPath: config.codexAppPath,
-    refreshThreadState: refreshDesktopThreadState,
   });
   const workspaceRuntime = createWorkspaceRuntime({
     config,
@@ -273,6 +266,7 @@ function startBridge({
     }
 
     logConnectionStatus("connecting");
+    let hasSeenInboundRelayTraffic = false;
     const nextSocket = new WebSocket(relaySessionUrl, {
       headers: {
         "x-role": "mac",
@@ -308,6 +302,7 @@ function startBridge({
     });
 
     nextSocket.on("message", (data) => {
+      hasSeenInboundRelayTraffic = true;
       markRelayActivity();
       const message = typeof data === "string" ? data : data.toString("utf8");
       if (secureTransport.handleIncomingWireMessage(message, {
@@ -324,7 +319,14 @@ function startBridge({
       }
     });
 
-    nextSocket.on("pong", markRelayActivity);
+    nextSocket.on("pong", () => {
+      hasSeenInboundRelayTraffic = true;
+      markRelayActivity();
+    });
+    nextSocket.on("ping", () => {
+      hasSeenInboundRelayTraffic = true;
+      markRelayActivity();
+    });
     nextSocket.on("close", (code) => {
       clearRelayWatchdog();
       logConnectionStatus("disconnected");
@@ -629,8 +631,7 @@ function startBridge({
       }
 
       if (codexHandshakeState !== "warm") {
-        forwardedInitializeRequestIds.add(String(parsed.id));
-        return false;
+        primeCodexHandshake();
       }
 
       sendApplicationResponse(JSON.stringify({
@@ -645,7 +646,10 @@ function startBridge({
 
     if (method === "initialized") {
       cachedInitializedNotification = true;
-      return codexHandshakeState === "warm" || !workspaceRuntime.hasActiveWorkspace();
+      if (workspaceRuntime.hasActiveWorkspace() && codexHandshakeState !== "warm") {
+        primeCodexHandshake();
+      }
+      return true;
     }
 
     return false;
@@ -704,7 +708,12 @@ function startBridge({
   }
 
   function primeCodexHandshake() {
-    if (!workspaceRuntime.hasActiveWorkspace() || codexHandshakeState === "warm" || !cachedInitializeParams) {
+    if (
+      !workspaceRuntime.hasActiveWorkspace()
+      || codexHandshakeState === "warm"
+      || !cachedInitializeParams
+      || syntheticInitializeRequest
+    ) {
       return;
     }
     sendSyntheticInitialize(cachedInitializeParams, false);
@@ -797,6 +806,10 @@ function startBridge({
         return;
       }
 
+      if (!hasSeenInboundRelayTraffic) {
+        return;
+      }
+
       if (hasRelayConnectionGoneStale(lastRelayActivityAt)) {
         console.warn("[androdex] relay heartbeat stalled; forcing reconnect");
         publishBridgeStatus({

package/src/codex-desktop-refresher.js

@@ -2,10 +2,9 @@
 // Purpose: Debounced Mac desktop refresh controller for Codex.app after phone-authored conversation changes.
 // Layer: CLI helper
 // Exports: CodexDesktopRefresher, readBridgeConfig
-// Depends on: child_process, fs, path, ./rollout-watch
+// Depends on: child_process, path, ./rollout-watch
 
 const { execFile } = require("child_process");
-const fs = require("fs");
 const path = require("path");
 const { createThreadRolloutActivityWatcher } = require("./rollout-watch");
 
@@ -36,7 +35,6 @@ class CodexDesktopRefresher {
     now = () => Date.now(),
     refreshExecutor = null,
     watchThreadRolloutFactory = createThreadRolloutActivityWatcher,
-    refreshThreadState = null,
     refreshBackend = null,
     customRefreshFailureThreshold = DEFAULT_CUSTOM_REFRESH_FAILURE_THRESHOLD,
   } = {}) {
@@ -53,7 +51,6 @@ class CodexDesktopRefresher {
     this.now = now;
     this.refreshExecutor = refreshExecutor;
     this.watchThreadRolloutFactory = watchThreadRolloutFactory;
-    this.refreshThreadState = refreshThreadState;
     this.refreshBackend = refreshBackend
       || (this.refreshCommand ? "command" : (this.refreshExecutor ? "command" : "applescript"));
     this.customRefreshFailureThreshold = customRefreshFailureThreshold;
@@ -211,9 +208,23 @@ class CodexDesktopRefresher {
   }
 
   scheduleNewThreadFallback() {
-    this.clearFallbackTimer();
+    if (!this.canRefresh()) {
+      return;
+    }
+
+    if (this.fallbackTimer) {
+      return;
+    }
+
     this.fallbackTimer = setTimeout(() => {
-      this.queueRefresh("phone", { threadId: null, url: NEW_THREAD_DEEP_LINK }, "new-thread fallback");
+      this.fallbackTimer = null;
+      if (!this.pendingNewThread || this.pendingTargetThreadId) {
+        return;
+      }
+
+      this.noteRefreshTarget({ threadId: null, url: NEW_THREAD_DEEP_LINK });
+      this.pendingRefreshKinds.add("phone");
+      this.scheduleRefresh("fallback thread/start");
     }, this.fallbackNewThreadMs);
   }
 
@@ -227,7 +238,11 @@ class CodexDesktopRefresher {
   }
 
   ensureWatcher(threadId) {
-    if (!threadId || this.activeWatchedThreadId === threadId) {
+    if (!this.canRefresh() || !threadId) {
+      return;
+    }
+
+    if (this.activeWatchedThreadId === threadId && this.activeWatcher) {
       return;
     }
 
@@ -235,40 +250,43 @@ class CodexDesktopRefresher {
     this.activeWatchedThreadId = threadId;
     this.watchStartAt = this.now();
     this.lastRolloutSize = null;
+    this.mode = "watching_thread";
     this.activeWatcher = this.watchThreadRolloutFactory({
       threadId,
-      timeoutMs: this.rolloutLookupTimeoutMs,
+      lookupTimeoutMs: this.rolloutLookupTimeoutMs,
       idleTimeoutMs: this.rolloutIdleTimeoutMs,
-      onActivity: ({ size }) => {
-        if (size === this.lastRolloutSize) {
-          return;
-        }
-
-        this.lastRolloutSize = size;
-        const target = { threadId, url: buildThreadDeepLink(threadId) };
-        this.queueRefresh("phone", target, "rollout activity");
-      },
+      onEvent: (event) => this.handleWatcherEvent(event),
       onIdle: () => {
-        if (this.stopWatcherAfterRefreshThreadId === threadId) {
-          this.stopWatcher();
-        }
+        this.log(`rollout watcher idle thread=${threadId}`);
+        this.stopWatcher();
+        this.mode = this.pendingNewThread ? "pending_new_thread" : "idle";
       },
       onTimeout: () => {
+        this.log(`rollout watcher timeout thread=${threadId}`);
         this.stopWatcher();
+        this.mode = this.pendingNewThread ? "pending_new_thread" : "idle";
       },
-      onError: () => {
+      onError: (error) => {
+        this.log(`rollout watcher failed thread=${threadId}: ${error.message}`);
         this.stopWatcher();
+        this.mode = this.pendingNewThread ? "pending_new_thread" : "idle";
       },
     });
   }
 
   stopWatcher() {
-    this.activeWatcher?.stop?.();
+    if (!this.activeWatcher) {
+      this.activeWatchedThreadId = null;
+      this.watchStartAt = 0;
+      this.lastRolloutSize = null;
+      return;
+    }
+
+    this.activeWatcher.stop();
     this.activeWatcher = null;
     this.activeWatchedThreadId = null;
     this.watchStartAt = 0;
     this.lastRolloutSize = null;
-    this.stopWatcherAfterRefreshThreadId = null;
   }
 
   scheduleRefresh(reason) {
@@ -276,11 +294,18 @@ class CodexDesktopRefresher {
       return;
     }
 
-    this.clearRefreshTimer();
+    if (this.refreshTimer) {
+      this.log(`refresh already pending: ${reason}`);
+      return;
+    }
+
+    const elapsedSinceLastRefresh = this.now() - this.lastRefreshAt;
+    const waitMs = Math.max(0, this.debounceMs - elapsedSinceLastRefresh);
+    this.log(`refresh scheduled: ${reason}`);
     this.refreshTimer = setTimeout(() => {
       this.refreshTimer = null;
-      void this.executeRefresh(reason);
-    }, this.debounceMs);
+      void this.runPendingRefresh();
+    }, waitMs);
   }
 
   clearRefreshTimer() {
@@ -292,116 +317,180 @@ class CodexDesktopRefresher {
     this.refreshTimer = null;
   }
 
-  async executeRefresh(reason) {
-    if (this.refreshRunning || !this.canRefresh() || !this.hasPendingRefreshWork()) {
+  async runPendingRefresh() {
+    if (!this.canRefresh()) {
+      this.clearPendingState();
       return;
     }
 
-    this.refreshRunning = true;
-    try {
-      const completionTargetUrl = this.pendingCompletionTargetUrl;
-      const completionTurnId = this.pendingCompletionTurnId;
-      const completionThreadId = this.pendingCompletionTargetThreadId;
-      const watcherThreadIdToStop = this.stopWatcherAfterRefreshThreadId;
-      const targetUrl = this.pendingTargetUrl;
-      const targetThreadId = this.pendingTargetThreadId;
-      const refreshKinds = new Set(this.pendingRefreshKinds);
+    if (!this.hasPendingRefreshWork()) {
+      return;
+    }
 
-      this.clearPendingState();
+    if (this.refreshRunning) {
+      this.log("refresh skipped (debounced): another refresh is already running");
+      return;
+    }
 
-      if (completionTargetUrl) {
-        await this.syncThreadStateBeforeRefresh(completionThreadId);
-        await this.runRefresh(completionTargetUrl, {
-          reason,
-          refreshKinds,
-          isCompletionRun: true,
-        });
-        this.lastTurnIdRefreshed = completionTurnId || null;
-        if (completionThreadId && watcherThreadIdToStop === completionThreadId) {
-          this.stopWatcher();
-        }
-        return;
-      }
+    const isCompletionRun = this.pendingCompletionRefresh;
+    const pendingRefreshKinds = isCompletionRun
+      ? new Set(["completion"])
+      : new Set(this.pendingRefreshKinds);
+    const completionTurnId = this.pendingCompletionTurnId;
+    const targetUrl = isCompletionRun ? this.pendingCompletionTargetUrl : this.pendingTargetUrl;
+    const targetThreadId = isCompletionRun
+      ? this.pendingCompletionTargetThreadId
+      : this.pendingTargetThreadId;
+    const stopWatcherAfterRefreshThreadId = isCompletionRun
+      ? this.stopWatcherAfterRefreshThreadId
+      : null;
+    const shouldForceCompletionRefresh = isCompletionRun;
+
+    if (isCompletionRun) {
+      this.pendingCompletionRefresh = false;
+      this.pendingCompletionTurnId = null;
+      this.clearPendingCompletionTarget();
+      this.stopWatcherAfterRefreshThreadId = null;
+    } else {
+      this.pendingRefreshKinds.clear();
+      this.clearPendingTarget();
+    }
+
+    this.refreshRunning = true;
+    this.log(
+      `refresh running: ${Array.from(pendingRefreshKinds).join("+")}${targetThreadId ? ` thread=${targetThreadId}` : ""}`
+    );
 
-      if (targetUrl) {
-        await this.syncThreadStateBeforeRefresh(targetThreadId || null);
-        await this.runRefresh(targetUrl, {
-          reason,
-          refreshKinds,
-          isCompletionRun: false,
-        });
+    let didRefresh = false;
+    try {
+      const refreshSignature = `${targetUrl || "app"}|${targetThreadId || "no-thread"}`;
+      if (
+        !shouldForceCompletionRefresh
+        && refreshSignature === this.lastRefreshSignature
+        && this.now() - this.lastRefreshAt < this.debounceMs
+      ) {
+        this.log(`refresh skipped (duplicate target): ${refreshSignature}`);
+      } else {
+        await this.executeRefresh(targetUrl);
+        this.lastRefreshAt = this.now();
+        this.lastRefreshSignature = refreshSignature;
+        this.consecutiveRefreshFailures = 0;
+        didRefresh = true;
       }
-    } catch (error) {
-      this.consecutiveRefreshFailures += 1;
-      const message = extractErrorMessage(error);
-      this.log(`refresh failed (${reason}): ${message}`);
-      if (this.consecutiveRefreshFailures >= this.customRefreshFailureThreshold || isDesktopUnavailableError(message)) {
-        this.disableRuntimeRefresh(message);
+      if (completionTurnId && didRefresh) {
+        this.lastTurnIdRefreshed = completionTurnId;
       }
+    } catch (error) {
+      this.handleRefreshFailure(error);
     } finally {
       this.refreshRunning = false;
+      if (
+        didRefresh
+        && stopWatcherAfterRefreshThreadId
+        && stopWatcherAfterRefreshThreadId === this.activeWatchedThreadId
+      ) {
+        this.stopWatcher();
+        this.mode = this.pendingNewThread ? "pending_new_thread" : "idle";
+      }
+      // A completion refresh can queue while another refresh is still running,
+      // so retry whenever either queue still has work.
       if (this.hasPendingRefreshWork()) {
-        this.scheduleRefresh("follow-up refresh");
+        this.scheduleRefresh("pending follow-up refresh");
       }
     }
   }
 
-  async syncThreadStateBeforeRefresh(threadId) {
-    if (!threadId || typeof this.refreshThreadState !== "function") {
-      return;
+  executeRefresh(targetUrl) {
+    if (typeof this.refreshExecutor === "function") {
+      return this.refreshExecutor({
+        targetUrl,
+        bundleId: this.bundleId,
+        appPath: this.appPath,
+      });
     }
 
-    try {
-      await this.refreshThreadState({ threadId });
-    } catch (error) {
-      this.log(`thread state refresh failed for ${threadId}: ${extractErrorMessage(error)}`);
+    if (this.refreshBackend === "command") {
+      return execFilePromise("sh", ["-lc", this.refreshCommand]);
     }
+
+    return execFilePromise("osascript", [
+      REFRESH_SCRIPT_PATH,
+      this.bundleId,
+      this.appPath,
+      targetUrl || "",
+    ]);
+  }
+
+  clearPendingCompletionTarget() {
+    this.pendingCompletionTargetUrl = "";
+    this.pendingCompletionTargetThreadId = "";
   }
 
-  async runRefresh(targetUrl, { reason, refreshKinds = new Set(), isCompletionRun = false } = {}) {
-    const signature = `${targetUrl}|${isCompletionRun ? "completion" : "activity"}`;
-    if (
-      !isCompletionRun
-      && signature === this.lastRefreshSignature
-      && (this.now() - this.lastRefreshAt) < this.midRunRefreshThrottleMs
-    ) {
+  handleWatcherEvent(event) {
+    if (!event?.threadId || event.threadId !== this.activeWatchedThreadId) {
       return;
     }
 
-    this.lastRefreshSignature = signature;
-    this.lastRefreshAt = this.now();
-    this.consecutiveRefreshFailures = 0;
-    this.log(`refreshing desktop (${reason}) -> ${targetUrl}`);
+    const previousSize = this.lastRolloutSize;
+    this.lastRolloutSize = event.size;
+    this.noteRefreshTarget({
+      threadId: event.threadId,
+      url: buildThreadDeepLink(event.threadId),
+    });
 
-    if (typeof this.refreshExecutor === "function") {
-      await this.refreshExecutor({
-        targetUrl,
-        bundleId: this.bundleId,
-        appPath: this.appPath,
-      });
+    if (event.reason === "materialized") {
+      this.queueRefresh("rollout_materialized", {
+        threadId: event.threadId,
+        url: buildThreadDeepLink(event.threadId),
+      }, `rollout ${event.reason}`);
       return;
     }
 
-    if (this.refreshBackend === "command") {
-      await execFilePromise("sh", ["-lc", this.refreshCommand]);
+    if (event.reason !== "growth") {
       return;
     }
 
-    if (this.refreshBackend === "applescript") {
-      await execFilePromise("osascript", [
-        REFRESH_SCRIPT_PATH,
-        this.bundleId,
-        this.appPath,
-        targetUrl,
-      ]);
+    if (previousSize == null) {
+      this.queueRefresh("rollout_growth", {
+        threadId: event.threadId,
+        url: buildThreadDeepLink(event.threadId),
+      }, "rollout first-growth");
+      this.lastMidRunRefreshAt = this.now();
       return;
     }
+
+    if (this.now() - this.lastMidRunRefreshAt < this.midRunRefreshThrottleMs) {
+      return;
+    }
+
+    this.lastMidRunRefreshAt = this.now();
+    this.queueRefresh("rollout_growth", {
+      threadId: event.threadId,
+      url: buildThreadDeepLink(event.threadId),
+    }, "rollout mid-run");
   }
 
   log(message) {
     console.log(`${this.logPrefix} ${message}`);
   }
 
+  handleRefreshFailure(error) {
+    const message = extractErrorMessage(error);
+    console.error(`${this.logPrefix} refresh failed: ${message}`);
+
+    if (this.refreshBackend === "applescript" && isDesktopUnavailableError(message)) {
+      this.disableRuntimeRefresh("desktop refresh unavailable on this Mac");
+      return;
+    }
+
+    if (this.refreshBackend === "command") {
+      this.consecutiveRefreshFailures += 1;
+      if (this.consecutiveRefreshFailures >= this.customRefreshFailureThreshold) {
+        this.disableRuntimeRefresh("custom refresh command kept failing");
+      }
+    }
+  }
+
   disableRuntimeRefresh(reason) {
     if (!this.runtimeRefreshAvailable) {
       return;

package/src/macos-launch-agent.js

@@ -99,6 +99,7 @@ async function startMacOSBridgeService({
     osImpl,
     nodePath,
     cliPath,
+    refreshEnabled: Boolean(nextConfig.refreshEnabled),
   });
   restartLaunchAgent({
     env,
@@ -172,6 +173,7 @@ function getMacOSBridgeServiceStatus({
   const pairingFreshness = classifyPairingPayloadFreshness(pairingSession);
   const duplicateBridgeProcesses = listDuplicateBridgeProcesses({ execFileSyncImpl, launchdPid: launchd.pid });
   const deviceState = runCatchingLoadBridgeDeviceState(loadBridgeDeviceStateImpl);
+  const daemonConfig = readDaemonConfig({ env, fsImpl });
   return {
     label: SERVICE_LABEL,
     platform: "darwin",
@@ -182,6 +184,7 @@ function getMacOSBridgeServiceStatus({
     pairingSession,
     pairingFreshness,
     hasTrustedPhone: hasTrustedPhones(deviceState),
+    refreshEnabled: Boolean(daemonConfig?.refreshEnabled),
     duplicateBridgeProcesses,
     stdoutLogPath: resolveBridgeStdoutLogPath({ env }),
     stderrLogPath: resolveBridgeStderrLogPath({ env }),
@@ -200,6 +203,7 @@ function printMacOSBridgeServiceStatus(options = {}) {
   console.log(`[androdex] Bridge state: ${bridgeState}`);
   console.log(`[androdex] Connection: ${connectionStatus}`);
   console.log(`[androdex] Trusted phone: ${status.hasTrustedPhone ? "yes" : "no"}`);
+  console.log(`[androdex] Desktop refresh: ${status.refreshEnabled ? "enabled" : "disabled"}`);
   console.log(`[androdex] Pairing payload: ${pairingCreatedAt} (${status.pairingFreshness})`);
   if (status.duplicateBridgeProcesses.length > 0) {
     console.log(`[androdex] Duplicate bridge processes: ${status.duplicateBridgeProcesses.length}`);
@@ -227,6 +231,7 @@ function writeLaunchAgentPlist({
   osImpl = os,
   nodePath = process.execPath,
   cliPath = path.resolve(__dirname, "..", "bin", "androdex.js"),
+  refreshEnabled = false,
 } = {}) {
   const plistPath = resolveLaunchAgentPlistPath({ env, osImpl });
   const stateDir = resolveAndrodexStateDir({ env, osImpl });
@@ -241,6 +246,7 @@ function writeLaunchAgentPlist({
     stderrLogPath,
     nodePath,
     cliPath,
+    refreshEnabled,
   });
 
   fsImpl.mkdirSync(path.dirname(plistPath), { recursive: true });
@@ -256,6 +262,7 @@ function buildLaunchAgentPlist({
   stderrLogPath,
   nodePath,
   cliPath,
+  refreshEnabled = false,
 }) {
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -286,6 +293,8 @@ function buildLaunchAgentPlist({
     <string>${escapeXml(pathEnv)}</string>
     <key>ANDRODEX_DEVICE_STATE_DIR</key>
     <string>${escapeXml(stateDir)}</string>
+    <key>ANDRODEX_REFRESH_ENABLED</key>
+    <string>${escapeXml(refreshEnabled ? "true" : "false")}</string>
   </dict>
   <key>StandardOutPath</key>
   <string>${escapeXml(stdoutLogPath)}</string>

package/src/scripts/codex-refresh.applescript

@@ -1,5 +1,5 @@
 -- FILE: codex-refresh.applescript
--- Purpose: Reopens Codex on the requested route without detouring through Settings.
+-- Purpose: Forces a non-destructive route bounce inside Codex so the target thread remounts without killing runs.
 -- Layer: UI automation helper
 -- Args: bundle id, app path fallback, optional target deep link
 
@@ -7,6 +7,7 @@ on run argv
   set bundleId to item 1 of argv
   set appPath to item 2 of argv
   set targetUrl to ""
+  set bounceUrl to "codex://settings"
 
   if (count of argv) is greater than or equal to 3 then
     set targetUrl to item 3 of argv
@@ -18,6 +19,9 @@ on run argv
 
   delay 0.12
 
+  my openCodexUrl(bundleId, appPath, bounceUrl)
+  delay 0.18
+
   if targetUrl is not "" then
     my openCodexUrl(bundleId, appPath, targetUrl)
   else
@@ -33,7 +37,7 @@ end run
 on openCodexUrl(bundleId, appPath, targetUrl)
   try
     if targetUrl is not "" then
-      open location targetUrl
+      do shell script "open -b " & quoted form of bundleId & " " & quoted form of targetUrl
     else
       do shell script "open -b " & quoted form of bundleId
     end if

package/src/codex-desktop-thread-sync.js

@@ -1,34 +0,0 @@
-// FILE: codex-desktop-thread-sync.js
-// Purpose: Refreshes app-server thread state from disk before nudging the desktop UI.
-// Layer: CLI helper
-// Exports: createDesktopThreadReadRefresher
-// Depends on: none
-
-function createDesktopThreadReadRefresher({
-  sendCodexRequest,
-  includeTurns = true,
-} = {}) {
-  if (typeof sendCodexRequest !== "function") {
-    throw new Error("createDesktopThreadReadRefresher requires a sendCodexRequest function.");
-  }
-
-  return function refreshDesktopThreadState({ threadId }) {
-    const normalizedThreadId = readString(threadId);
-    if (!normalizedThreadId) {
-      return Promise.resolve(null);
-    }
-
-    return sendCodexRequest("thread/read", {
-      threadId: normalizedThreadId,
-      includeTurns,
-    });
-  };
-}
-
-function readString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : "";
-}
-
-module.exports = {
-  createDesktopThreadReadRefresher,
-};