relay-companion 0.1.21 → 0.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.21",
+  "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 {
@@ -78,87 +81,135 @@ export async function notifyCodexDesktopThreads({
   return { attempted: true, ok: results.some((result) => result.ok), results };
 }
 
-export function buildCodexDesktopRefreshExpression({ threadIds = [], pinnedThreadIds = null, openThreadId = null } = {}) {
-  const rendererCode = `(${async function relayRefreshCodexRenderer(payload) {
-    const hostId = "local";
-    const bridge = window.electronBridge;
-    if (!bridge?.sendMessageFromView) return { ok: false, reason: "missing-electron-bridge" };
+// Runs INSIDE each Codex renderer: it is serialized to a string via toString()
+// and evaluated in the window's page context, so it must be self-contained — no
+// imports, only renderer globals (window, location). Exported at module scope so
+// the thread-routing decision can be unit-tested directly.
+export async function relayRefreshCodexRenderer(payload) {
+  const hostId = "local";
+  const bridge = window.electronBridge;
+  if (!bridge?.sendMessageFromView) return { ok: false, reason: "missing-electron-bridge" };
 
-    const sent = [];
-    async function send(message) {
-      try {
-        await bridge.sendMessageFromView(message);
-        sent.push({ type: message.type, ok: true });
-      } catch (error) {
-        sent.push({ type: message.type, ok: false, error: String(error?.message || error) });
-      }
+  const sent = [];
+  // 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 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) });
     }
+  }
 
-    if (Array.isArray(payload.pinnedThreadIds)) {
-      await send({ type: "set-pinned-thread-ids-for-host", hostId, threadIds: payload.pinnedThreadIds });
-    }
-    if (payload.threadIds.length) {
-      await send({ type: "hydrate-pinned-threads", hostId, threadIds: payload.threadIds });
-    }
-    await send({ type: "refresh-recent-conversations-for-host", hostId });
-    for (const threadId of payload.threadIds) {
-      // Codex Desktop (>=0.142) serves thread views from its in-memory core and
-      // never cold-loads externally created threads — the view spins forever
-      // until an app restart. Adopt the thread the way the app itself opens one:
-      // drop any stale cache entry, ask the tail-hydration path to load history
-      // (feature-gated; harmless when off — dependentConversationIds is REQUIRED
-      // or the handler throws), then maybe-resume-conversation, which activates
-      // the thread summary and resumes the conversation from the rollout on disk.
-      await send({ type: "discard-conversation-from-cache", conversationId: threadId });
-      await send({ type: "ensure-conversation-history-loaded", conversationId: threadId, dependentConversationIds: [] });
-      await send({
-        type: "maybe-resume-conversation",
-        hostId,
-        conversationId: threadId,
-        model: null,
-        serviceTier: null,
-        reasoningEffort: null,
-        workspaceRoots: [],
-        collaborationMode: null,
-      });
-      await send({ type: "broadcast-conversation-snapshot-for-host", hostId, conversationId: threadId });
-    }
-    if (payload.openThreadId) {
+  if (Array.isArray(payload.pinnedThreadIds)) {
+    await send({ type: "set-pinned-thread-ids-for-host", hostId, threadIds: payload.pinnedThreadIds });
+  }
+  if (payload.threadIds.length) {
+    await send({ type: "hydrate-pinned-threads", hostId, threadIds: payload.threadIds });
+  }
+  await send({ type: "refresh-recent-conversations-for-host", hostId });
+  for (const threadId of payload.threadIds) {
+    // Codex Desktop (>=0.142) serves thread views from its in-memory core and
+    // never cold-loads externally created threads — the view spins forever
+    // until an app restart. Adopt the thread the way the app itself opens one:
+    // drop any stale cache entry, ask the tail-hydration path to load history
+    // (feature-gated; harmless when off — dependentConversationIds is REQUIRED
+    // or the handler throws), then maybe-resume-conversation, which activates
+    // the thread summary and resumes the conversation from the rollout on disk.
+    await send({ type: "discard-conversation-from-cache", conversationId: threadId });
+    await send({ type: "ensure-conversation-history-loaded", conversationId: threadId, dependentConversationIds: [] });
+    await send({
+      type: "maybe-resume-conversation",
+      hostId,
+      conversationId: threadId,
+      model: null,
+      serviceTier: null,
+      reasoningEffort: null,
+      workspaceRoots: [],
+      collaborationMode: null,
+    });
+    await send({ type: "broadcast-conversation-snapshot-for-host", hostId, conversationId: threadId });
+  }
+  if (payload.openThreadId) {
+    const encoded = encodeURIComponent(String(payload.openThreadId));
+    const navTo = (path) => {
       try {
-        window.postMessage(
-          {
-            type: "navigate-to-route",
-            path: `/hotkey-window/thread/${encodeURIComponent(String(payload.openThreadId))}`,
-          },
-          location.origin,
-        );
-        sent.push({ type: "navigate-to-route", ok: true, threadId: payload.openThreadId });
+        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, error: String(error?.message || 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 };
+}
 
-    return { ok: sent.some((item) => item.ok), href: location.href, openThreadId: payload.openThreadId || null, sent };
-  }.toString()})(${JSON.stringify({
+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());
 
   return `(async () => {
     const req = process.mainModule?.require || process.getBuiltinModule("module").createRequire(process.cwd() + "/");
     const { BrowserWindow } = req("electron");
     const code = ${JSON.stringify(rendererCode)};
+    const wantsFocus = ${JSON.stringify(wantsFocus)};
     const windows = [];
     for (const win of BrowserWindow.getAllWindows()) {
       if (win.isDestroyed()) continue;
       try {
-        windows.push({
-          id: win.id,
-          visible: win.isVisible(),
-          url: win.webContents.getURL(),
-          result: await win.webContents.executeJavaScript(code, true),
-        });
+        const url = win.webContents.getURL();
+        const result = await win.webContents.executeJavaScript(code, true);
+        // Bring the main window forward after navigating it to the thread, the way
+        // Codex's own restoreShowAndFocusWindow does. The hotkey overlay manages
+        // its own visibility, so leave it alone and only surface the main window.
+        let focused = false;
+        if (wantsFocus && !String(url || "").includes("/hotkey-window")) {
+          try {
+            if (win.isMinimized()) win.restore();
+            win.show();
+            win.focus();
+            focused = true;
+          } catch {}
+        }
+        windows.push({ id: win.id, visible: win.isVisible(), url, focused, result });
       } catch (error) {
         windows.push({ id: win.id, ok: false, error: String(error?.message || error) });
       }

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)}`);