relay-companion 0.1.22 → 0.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "Relay companion: connects local coding agents to Relay tasks, approvals, and connector tools.",
   "type": "module",
   "bin": {

package/src/codex-desktop.js

@@ -46,7 +46,10 @@ export async function notifyCodexDesktopThreads({
   threadIds = [],
   pinnedThreadIds = null,
   openThreadId = null,
-  timeoutMs = Number(process.env.RELAY_CODEX_DESKTOP_TIMEOUT_MS || 4000),
+  primeOpen = true,
+  // The open path navigates hotkey -> (prime wait) -> /local inside the renderer,
+  // so the inspector eval must outlast RELAY_CODEX_OPEN_PRIME_MS; default higher.
+  timeoutMs = Number(process.env.RELAY_CODEX_DESKTOP_TIMEOUT_MS || 8000),
 } = {}) {
   if (process.env.RELAY_CODEX_DESKTOP_REFRESH === "0") return { attempted: false, reason: "disabled" };
   if (process.platform !== "darwin") return { attempted: false, reason: "not-darwin" };
@@ -59,7 +62,7 @@ export async function notifyCodexDesktopThreads({
   const pids = await findCodexMainPids();
   if (!pids.length) return { attempted: true, ok: false, reason: "codex-not-running", results: [] };
 
-  const expression = buildCodexDesktopRefreshExpression({ threadIds: ids, pinnedThreadIds: pinnedIds, openThreadId: openId });
+  const expression = buildCodexDesktopRefreshExpression({ threadIds: ids, pinnedThreadIds: pinnedIds, openThreadId: openId, primeOpen });
   const results = [];
   for (const pid of pids) {
     try {
@@ -88,9 +91,15 @@ export async function relayRefreshCodexRenderer(payload) {
   if (!bridge?.sendMessageFromView) return { ok: false, reason: "missing-electron-bridge" };
 
   const sent = [];
-  async function send(message) {
+  // Bound every bridge send. Some host messages (notably maybe-resume-conversation)
+  // can hang indefinitely; the original serial awaits then block the navigation
+  // that follows, leaving the thread unopened. Cap each send so the open proceeds.
+  async function send(message, timeoutMs = 2000) {
     try {
-      await bridge.sendMessageFromView(message);
+      await Promise.race([
+        bridge.sendMessageFromView(message),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("send-timeout")), timeoutMs)),
+      ]);
       sent.push({ type: message.type, ok: true });
     } catch (error) {
       sent.push({ type: message.type, ok: false, error: String(error?.message || error) });
@@ -127,33 +136,52 @@ export async function relayRefreshCodexRenderer(payload) {
     await send({ type: "broadcast-conversation-snapshot-for-host", hostId, conversationId: threadId });
   }
   if (payload.openThreadId) {
-    try {
-      const encoded = encodeURIComponent(String(payload.openThreadId));
-      // Codex renders a thread through two separate router surfaces: the main
-      // window (sidebar + recents rail) at /local/<id>, and the borderless hotkey
-      // "quick chat" overlay at /hotkey-window/thread/<id>. The app's own
-      // navigation chooses between them by whether the current window is the
-      // hotkey one (its QH() keys off location.pathname). Mirror that here so the
-      // thread opens in whichever surface the user is actually in — otherwise
-      // every open is forced into the overlay even when the main window is up.
-      const path = location.pathname.startsWith("/hotkey-window")
-        ? `/hotkey-window/thread/${encoded}`
-        : `/local/${encoded}`;
-      window.postMessage({ type: "navigate-to-route", path }, location.origin);
-      sent.push({ type: "navigate-to-route", ok: true, threadId: payload.openThreadId, path });
-    } catch (error) {
-      sent.push({ type: "navigate-to-route", ok: false, error: String(error?.message || error) });
+    const encoded = encodeURIComponent(String(payload.openThreadId));
+    const navTo = (path) => {
+      try {
+        window.postMessage({ type: "navigate-to-route", path }, location.origin);
+        sent.push({ type: "navigate-to-route", ok: true, path });
+      } catch (error) {
+        sent.push({ type: "navigate-to-route", ok: false, path, error: String(error?.message || error) });
+      }
+    };
+    // Codex renders a thread through two router surfaces: the main window
+    // (sidebar + recents rail) at /local/<id>, and the borderless hotkey
+    // "quick chat" view at /hotkey-window/thread/<id>. Two facts drive the logic:
+    //   1. The app uses an in-memory router, so location.pathname is ALWAYS
+    //      /index.html — it never reveals the current route or window kind.
+    //   2. The /local/<id> route CANNOT cold-load an externally-created relay
+    //      thread: it renders the empty "New chat" state and never recovers.
+    //      Only /hotkey-window/thread/<id> loads such a thread from disk into the
+    //      renderer store. Once loaded, /local/<id> renders it fine.
+    // So to land the user in the main window WITH content, prime the load via the
+    // hotkey route, then switch to /local/<id> once it is warm. The hotkey view
+    // shows the thread during the prime, so the transition is content -> content,
+    // never a blank flash. The second materializer pass runs with primeOpen=false
+    // and just re-asserts /local (the thread is warm by then).
+    const inHotkeyWindow = /hotkey-window/.test(location.href) || /hotkey-window/.test(location.search || "");
+    const primeMs = Number.isFinite(payload.primeMs) ? payload.primeMs : 1200;
+    if (inHotkeyWindow) {
+      navTo(`/hotkey-window/thread/${encoded}`);
+    } else if (payload.primeOpen === false) {
+      navTo(`/local/${encoded}`);
+    } else {
+      navTo(`/hotkey-window/thread/${encoded}`);
+      await new Promise((resolve) => setTimeout(resolve, primeMs));
+      navTo(`/local/${encoded}`);
     }
   }
 
   return { ok: sent.some((item) => item.ok), href: location.href, openThreadId: payload.openThreadId || null, sent };
 }
 
-export function buildCodexDesktopRefreshExpression({ threadIds = [], pinnedThreadIds = null, openThreadId = null } = {}) {
+export function buildCodexDesktopRefreshExpression({ threadIds = [], pinnedThreadIds = null, openThreadId = null, primeOpen = true } = {}) {
   const rendererCode = `(${relayRefreshCodexRenderer.toString()})(${JSON.stringify({
     threadIds: uniqueStrings(threadIds),
     pinnedThreadIds,
     openThreadId: String(openThreadId || "").trim() || null,
+    primeOpen: primeOpen !== false,
+    primeMs: Number(process.env.RELAY_CODEX_OPEN_PRIME_MS) || 1200,
   })})`;
   // Only bring a window forward when we're actually opening a thread.
   const wantsFocus = Boolean(String(openThreadId || "").trim());

package/src/materializer.js

@@ -257,13 +257,19 @@ async function materializeRowInHost({ id, row, rowState = {}, host = "claude", l
     // works. The refresh therefore discards the stale cache entry and navigates
     // through the bridge, which forces the view to reload the now-complete file.
     // The codex:// deep link is only the fallback when the bridge is unreachable.
+    // First pass PRIMES the open: it navigates to /hotkey-window/thread/<id>
+    // (the only route that cold-loads an externally-created thread from disk),
+    // waits, then switches to /local/<id> so the thread shows in the main window
+    // with the sidebar. The /local route alone renders an empty "New chat" pane
+    // for a fresh relay thread and never recovers.
     const desktopOpenResult = await refreshCodexDesktopForThreads([threadId], { force: true, openThreadId: threadId });
     // The desktop occasionally re-caches the conversation between our discard
     // and the view's load, so a single refresh still races on some first opens.
-    // A second discard + navigate pass after a short settle has rendered
-    // deterministically in every observed failure case.
+    // The second pass runs with primeOpen=false — the thread is warm from the
+    // first pass, so a plain /local navigate re-asserts it deterministically
+    // without a second hotkey->local visual transition.
     await sleep(Number(process.env.RELAY_CODEX_OPEN_SECOND_PASS_MS || 1200));
-    const secondPassResult = await refreshCodexDesktopForThreads([threadId], { force: true, openThreadId: threadId });
+    const secondPassResult = await refreshCodexDesktopForThreads([threadId], { force: true, openThreadId: threadId, primeOpen: false });
     openedInHost = Boolean(desktopOpenResult?.ok || secondPassResult?.ok);
     skipExternalOpen = openedInHost;
     url = `codex://threads/${encodeURIComponent(threadId)}`;
@@ -393,7 +399,7 @@ function ensureRelayCodexIndexMarker({ threadId, sessionPath, packetId }) {
   }
 }
 
-async function refreshCodexDesktopForThreads(threadIds, { force = false, openThreadId = null } = {}) {
+async function refreshCodexDesktopForThreads(threadIds, { force = false, openThreadId = null, primeOpen = true } = {}) {
   const uniqueThreadIds = Array.from(new Set(threadIds.filter(Boolean)));
   if (!uniqueThreadIds.length && !force) return null;
   try {
@@ -401,6 +407,7 @@ async function refreshCodexDesktopForThreads(threadIds, { force = false, openThr
       threadIds: uniqueThreadIds,
       pinnedThreadIds: readPinnedThreadIds(),
       openThreadId,
+      primeOpen,
     });
     if (process.env.RELAY_DEBUG && result.attempted && !result.ok) {
       console.error(`Relay Codex desktop refresh did not reach a running window: ${JSON.stringify(result)}`);