relay-companion 0.1.21 → 0.1.22

package/package.json

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

package/src/codex-desktop.js

@@ -78,87 +78,110 @@ 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 = [];
+  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) });
     }
+  }
 
-    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) {
-      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 });
-      } catch (error) {
-        sent.push({ type: "navigate-to-route", 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) {
+    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) });
     }
+  }
+
+  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 } = {}) {
+  const rendererCode = `(${relayRefreshCodexRenderer.toString()})(${JSON.stringify({
     threadIds: uniqueStrings(threadIds),
     pinnedThreadIds,
     openThreadId: String(openThreadId || "").trim() || null,
   })})`;
+  // 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) });
       }