relay-companion 0.1.70 → 0.1.71

package/overlay/inbox.html

@@ -1432,6 +1432,7 @@
   }
   function openRelayFromUI(id, source = "relay", mode = "open") {
     if (!id || openingIds.has(id)) return;
+    clearRowNote(id); // a previous open's failure text must not outlive the retry
     openingIds.set(id, performance.now());
     for (const el of openingTargets(id)) el.classList.add("opening");
     setTimeout(() => stopOpening(id), 6000); // safety: never spin forever if openDone is missed
@@ -1634,6 +1635,14 @@
     if (el) el.textContent = message || "";
   }
   function cssId(id) { return String(id).replace(/"/g, '\\"'); }
+  // The .row-err slot carries both inline errors and the green injection note, and one
+  // relay can be rendered into more than one list, so wipe every copy of the row's slot.
+  function clearRowNote(id) {
+    for (const el of document.querySelectorAll(`[data-err="${CSS.escape(id)}"]`)) {
+      el.textContent = "";
+      el.classList.remove("ok");
+    }
+  }
 
   async function runRowAction(id, btn, fn) {
     if (!btn || btn.disabled) return;
@@ -2711,6 +2720,16 @@
       }, 12000));
     }
   });
+  // An open that failed leaves the relay UNREAD on purpose (it never reached the user),
+  // so the row has to say what happened — otherwise the spinner just stops and the click
+  // looks like it worked. Cleared by the next open of the same row.
+  if (window.relay.onOpenError) window.relay.onOpenError((id, message) => {
+    if (!message) return;
+    for (const el of document.querySelectorAll(`[data-err="${CSS.escape(id)}"]`)) {
+      el.classList.remove("ok");
+      el.innerHTML = esc(message);
+    }
+  });
   window.relay.refresh().then((p) => {
     onPayload(p);
     console.log("[overlay] booted ok, relays=" + (p && p.relays ? p.relays.length : 0) + " sent=" + (p && p.sent ? p.sent.length : 0));

package/overlay/main.cjs

@@ -1375,6 +1375,95 @@ function openClaudeDeepLinkVerified(url, fallbackUrl, label, { freshlyForged = f
   }, 1000);
 }
 
+// The CLI's `open` prints ONE pretty-printed JSON object on stdout and sends every
+// log line to stderr, so a plain parse should suffice — but a single stray stdout
+// line (a Node warning, a dep's console.log) used to turn a SUCCESSFUL open into a
+// browser fallback, so recover by slicing the outermost {...} instead of giving up.
+function parseOpenResult(out) {
+  const text = String(out || "").trim();
+  const read = (raw) => {
+    const parsed = JSON.parse(raw);
+    return {
+      url: parsed.url || null,
+      skipExternalOpen: Boolean(parsed.skipExternalOpen),
+      freshlyForged: Boolean(parsed.claudeFreshlyForged),
+    };
+  };
+  try {
+    return read(text);
+  } catch {}
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    try {
+      return read(text.slice(start, end + 1));
+    } catch {}
+  }
+  return { url: null, skipExternalOpen: false, freshlyForged: false };
+}
+
+// Both stdout and stderr in the failure log: a Windows field report where stdout
+// was empty is the whole reason the "exit" -> "close" fix below exists.
+function tailFor(stream) {
+  return String(stream || "").trim().split("\n").slice(-2).join(" | ");
+}
+
+// Whether the `relay claude-hook` runtime is registered in ~/.claude/settings.json.
+// "Open in current chat" stages a file that ONLY that runtime consumes, so without
+// it the click is a silent no-op. Loaded lazily like the modules above (install.js
+// is ESM; this overlay is CommonJS).
+let claudeHooksModulePromise = null;
+function loadClaudeHooksModule() {
+  if (!claudeHooksModulePromise) {
+    const installUrl = pathToFileURL(path.join(__dirname, "..", "src", "install.js")).href;
+    claudeHooksModulePromise = import(installUrl).catch((error) => {
+      claudeHooksModulePromise = null;
+      throw error;
+    });
+  }
+  return claudeHooksModulePromise;
+}
+
+// A missing or unparseable settings file counts as NOT installed: staging into a
+// machine with no hook runtime is worse than a fresh open, so fail closed.
+function claudeHooksInstalled(install) {
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(install.claudeSettingsPath(), "utf8")) || {};
+  } catch {
+    return false;
+  }
+  const hooks = settings.hooks;
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) return false;
+  for (const entries of Object.values(hooks)) {
+    for (const entry of Array.isArray(entries) ? entries : []) {
+      for (const hook of entry && Array.isArray(entry.hooks) ? entry.hooks : []) {
+        if (install.isRelayClaudeHookCommand(hook && hook.command)) return true;
+      }
+    }
+  }
+  return false;
+}
+
+// Register the claude-hook runtime for FUTURE Claude sessions (idempotent; it preserves
+// every user hook). installClaudeHooks defaults its node to process.execPath, which under
+// Electron is the OVERLAY binary — a hook command Claude could never run, and one that
+// would make the presence check above pass forever. So resolve a real node first and skip
+// the repair entirely when the machine has none.
+function repairClaudeHooks(install) {
+  execFile(process.platform === "win32" ? "where" : "/usr/bin/which", ["node"], (error, out) => {
+    const node = String(out || "").split("\n")[0].trim();
+    if (error || !node) {
+      console.error("[overlay] cannot register the claude-hook runtime: no node found on PATH");
+      return;
+    }
+    const result = install.installClaudeHooks(undefined, install.stableNodePath(node));
+    if (!result || !result.ok) {
+      console.error("[overlay] claude-hook registration failed:", (result && result.reason) || "unknown");
+    }
+  });
+}
+
 // Click-to-open a Relay row. A relay materializes a REAL native agent session
 // inside the already-running foregrounded host (Claude Desktop or Codex) via the
 // companion CLI's `open` command, so it appears in that app's recents rail. The
@@ -1404,20 +1493,29 @@ async function openPacket(packetId, { sent = false, fresh = false } = {}) {
   }
   const row = rowById(materializationId);
   if (win && !win.isDestroyed()) win.webContents.send("opening", packetId);
-  const finish = () => {
+  // Ack marks the row read AND drops it from the attention queue, so a relay that
+  // never reached the user must NOT be acked — otherwise a failed click silently
+  // retires the notification. The spinner stop, in contrast, owes every path.
+  const finishOpened = () => {
     if (!sent) ackPacket(packetId);
     if (win && !win.isDestroyed()) win.webContents.send("openDone", packetId); // stop the row spinner
   };
+  const finishFailed = (message) => {
+    if (win && !win.isDestroyed()) {
+      if (message) win.webContents.send("openError", packetId, message);
+      win.webContents.send("openDone", packetId);
+    }
+  };
   if (!TASK_FEATURES_ALLOWED && (row?.taskId || isRelayTaskWebTarget(row?.actionUrl))) {
     console.error("[overlay] refusing to open a Relay Task in messages-only mode:", packetId);
-    return finish();
+    return finishFailed();
   }
-  if (process.env.RELAY_OVERLAY_TEST_NO_HOST_OPEN === "1") return finish();
+  if (process.env.RELAY_OVERLAY_TEST_NO_HOST_OPEN === "1") return finishOpened();
   if (row && row.relayNotificationKind === "connector_reauth") {
     shell
       .openExternal(`${webBase()}/app/connectors`)
       .catch((error) => console.error("[overlay] open failed:", error && error.message));
-    return finish();
+    return finishOpened();
   }
   frontmostBundleId((bundle) => {
     const host = resolveClickHost(bundle);
@@ -1446,16 +1544,11 @@ async function openPacket(packetId, { sent = false, fresh = false } = {}) {
     let err = "";
     child.stdout.on("data", (data) => (out += data));
     child.stderr.on("data", (data) => (err += data));
-    child.on("exit", (code) => {
-      let url = null;
-      let skipExternalOpen = false;
-      let freshlyForged = false;
-      try {
-        const parsed = JSON.parse(out.trim());
-        url = parsed.url || null;
-        skipExternalOpen = Boolean(parsed.skipExternalOpen);
-        freshlyForged = Boolean(parsed.claudeFreshlyForged);
-      } catch {}
+    // "close", never "exit": on Windows "exit" routinely fires BEFORE the stdout pipe
+    // drains, so `out` was empty, the parse failed, and a perfectly successful open was
+    // routed to the web fallback — the user got a browser instead of Claude.
+    child.on("close", (code) => {
+      const { url, skipExternalOpen, freshlyForged } = parseOpenResult(out);
       if (url || skipExternalOpen) {
         // Raise the host so the relay is visible, whichever open path ran (Claude deep
         // link, Codex bridge, or a plain url). This is the fix for "opened in the right
@@ -1469,6 +1562,7 @@ async function openPacket(packetId, { sent = false, fresh = false } = {}) {
             shell.openExternal(url).catch((error) => console.error("[overlay] openExternal failed:", error && error.message));
           }
         }
+        finishOpened();
       } else {
         console.error(
           "[overlay] open failed for",
@@ -1477,22 +1571,25 @@ async function openPacket(packetId, { sent = false, fresh = false } = {}) {
           host,
           "code",
           code,
+          "stdout:",
+          tailFor(out),
           "stderr:",
-          err.trim().split("\n").slice(-2).join(" | "),
+          tailFor(err),
         );
-        // Last-resort web fallback so the click is never a dead end.
+        // Last-resort web fallback so the click is never a dead end — but the relay
+        // did not open where it was meant to, so it stays unread and in the queue.
         const target = row && row.taskId
           ? taskWebUrl(row.taskId)
           : row && row.actionUrl
             ? absoluteUrl(row.actionUrl)
             : webBase();
         shell.openExternal(target).catch((e) => console.error("[overlay] web fallback failed:", e && e.message));
+        finishFailed("Couldn't open in Claude — opened on the web instead.");
       }
-      finish();
     });
     child.on("error", (error) => {
       console.error("[overlay] open spawn error:", error && error.message);
-      finish();
+      finishFailed("Couldn't open — Relay's open helper failed to start.");
     });
   });
 }
@@ -1594,22 +1691,50 @@ async function openPacketInCurrent(packetId) {
       }
     }
     if (!target) return fallbackFresh();
-    try {
-      claudeInject.stageInjection(RELAY_HOME, target.sessionId, {
-        relayId: packetId,
-        senderName: row.senderName || "",
-        title: row.title || row.displayTitle || "",
-        ...threadInfoFor(row),
-      });
-    } catch (error) {
-      console.error("[overlay] claude injection staging failed:", error && error.message);
-      return fallbackFresh();
-    }
-    // Raise Claude Desktop so the user watches the instruction land; a
-    // terminal-only session stays where it is (its window is not ours to raise).
-    if (target.source === "desktop") activateHost("claude", bundle);
-    confirmInjected("claude");
-    finish();
+    const stageNow = () => {
+      try {
+        claudeInject.stageInjection(RELAY_HOME, target.sessionId, {
+          relayId: packetId,
+          senderName: row.senderName || "",
+          title: row.title || row.displayTitle || "",
+          ...threadInfoFor(row),
+        });
+      } catch (error) {
+        console.error("[overlay] claude injection staging failed:", error && error.message);
+        return fallbackFresh();
+      }
+      // Raise Claude Desktop so the user watches the instruction land; a
+      // terminal-only session stays where it is (its window is not ours to raise).
+      if (target.source === "desktop") activateHost("claude", bundle);
+      confirmInjected("claude");
+      finish();
+    };
+    // NOTHING but the `relay claude-hook` runtime registered in ~/.claude/settings.json
+    // ever reads the staged file. Where setup never wrote those hooks (Windows installs
+    // where the `claude` CLI isn't on PATH — see src/install.js runSetupInstall) staging
+    // succeeds and the click is a silent, acked no-op. Check before staging. Two-arg
+    // then, not .catch: a throw out of stageNow must not re-enter the failure handler
+    // and finish the click twice.
+    loadClaudeHooksModule().then(
+      (install) => {
+        if (claudeHooksInstalled(install)) return stageNow();
+        // Repair for FUTURE sessions — but a Claude session that is already running
+        // loaded its hooks at startup and will never consume a file staged now, so this
+        // click has to take the fresh-open path, the only one that actually shows the
+        // relay. No ack here: openPacket owns the read state for the fresh open.
+        console.error(
+          "[overlay] claude-hook runtime not registered in",
+          install.claudeSettingsPath(),
+          "— 'Open in current chat' would have been a silent no-op; installing it for future sessions and opening a fresh chat instead (restart Claude to use it)",
+        );
+        repairClaudeHooks(install);
+        fallbackFresh();
+      },
+      (error) => {
+        console.error("[overlay] claude-hook runtime check failed:", error && error.message);
+        fallbackFresh();
+      },
+    );
   });
 }
 
@@ -1645,16 +1770,10 @@ function openTaskDetail(taskId) {
     let err = "";
     child.stdout.on("data", (data) => (out += data));
     child.stderr.on("data", (data) => (err += data));
-    child.on("exit", (code) => {
-      let url = null;
-      let skipExternalOpen = false;
-      let freshlyForged = false;
-      try {
-        const parsed = JSON.parse(out.trim());
-        url = parsed.url || null;
-        skipExternalOpen = Boolean(parsed.skipExternalOpen);
-        freshlyForged = Boolean(parsed.claudeFreshlyForged);
-      } catch {}
+    // "close", never "exit" — same Windows stdout-drain race as openPacket: an empty
+    // parse used to send a successful task open to the browser.
+    child.on("close", (code) => {
+      const { url, skipExternalOpen, freshlyForged } = parseOpenResult(out);
       if (url || skipExternalOpen) {
         activateHost(host, bundle); // raise the host so the opened task is visible
         if (url && !skipExternalOpen) {
@@ -1672,8 +1791,10 @@ function openTaskDetail(taskId) {
           host,
           "code",
           code,
+          "stdout:",
+          tailFor(out),
           "stderr:",
-          err.trim().split("\n").slice(-2).join(" | "),
+          tailFor(err),
         );
         // Last-resort web fallback so the click is never a dead end.
         shell
@@ -1949,7 +2070,10 @@ function createWindow() {
     },
   });
 
-  win.setAlwaysOnTop(true, "floating");
+  // Windows strips WS_EX_TOPMOST from a scheduled-task-launched overlay that only asks
+  // politely ("floating"); "screen-saver" is the level that survives. The periodic
+  // re-assert that recovers from later demotions lives in space-presence.cjs.
+  win.setAlwaysOnTop(true, process.platform === "win32" ? "screen-saver" : "floating");
   win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
   // Empty canvas is click-through; startHitTest() below owns this from here on.
   win.setIgnoreMouseEvents(true, { forward: true });

package/overlay/preload.cjs

@@ -8,6 +8,9 @@ contextBridge.exposeInMainWorld("relay", {
   // "Open in current chat" staged an injection: the UI confirms it so the
   // click has visible feedback (delivery is checkpoint-based, not instant).
   onInjected: (cb) => ipcRenderer.on("injected", (_e, id, info) => cb(id, info || {})),
+  // The open failed (CLI error / helper wouldn't spawn). The row stays unread, so
+  // say why inline instead of letting the spinner just stop.
+  onOpenError: (cb) => ipcRenderer.on("openError", (_e, id, message) => cb(id, message || "")),
   onOpenFull: (cb) => ipcRenderer.on("openFull", () => cb()), // status-area icon clicked
   onShown: (cb) => ipcRenderer.on("shown", () => cb()), // window re-shown; reset hover handshake
 

package/overlay/space-presence.cjs

@@ -18,22 +18,40 @@ function resetWindowZoom(win) {
   return true;
 }
 
-function reinforceSpacePresence(win, { moveTop = false } = {}) {
+function reinforceSpacePresence(win, { moveTop = false, platform = process.platform } = {}) {
   if (!isUsableWindow(win)) return false;
   resetWindowZoom(win);
-  // Only touch window-server state that actually drifted. Re-asserting
-  // setVisibleOnAllWorkspaces / setAlwaysOnTop unconditionally (every 1.5s poll +
-  // every Space change) reorders the window each time and reads as flicker.
-  try {
-    if (typeof win.isVisibleOnAllWorkspaces !== "function" || !win.isVisibleOnAllWorkspaces()) {
-      win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
-    }
-  } catch {}
-  try {
-    if (typeof win.isAlwaysOnTop !== "function" || !win.isAlwaysOnTop()) {
-      win.setAlwaysOnTop(true, "floating");
-    }
-  } catch {}
+  const isWindows = platform === "win32";
+  // All-Spaces is a macOS Spaces concept. On Windows isVisibleOnAllWorkspaces()
+  // always reports false, so the drift check below re-called the setter on every
+  // 1.5s poll for nothing.
+  if (!isWindows) {
+    // Only touch window-server state that actually drifted. Re-asserting
+    // setVisibleOnAllWorkspaces / setAlwaysOnTop unconditionally (every 1.5s poll +
+    // every Space change) reorders the window each time and reads as flicker.
+    try {
+      if (typeof win.isVisibleOnAllWorkspaces !== "function" || !win.isVisibleOnAllWorkspaces()) {
+        win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+      }
+    } catch {}
+  }
+  if (isWindows) {
+    // Re-assert unconditionally: Electron's isAlwaysOnTop() is a cached flag from
+    // its own last setAlwaysOnTop call and cannot observe the OS stripping
+    // WS_EX_TOPMOST (scheduled-task-launched windows come up without it and sink
+    // behind maximized windows). Trusting the getter made the repair a permanent
+    // no-op. SetWindowPos-to-topmost on an already-topmost window is not a visible
+    // reorder here, so the macOS flicker rationale above does not apply.
+    try {
+      win.setAlwaysOnTop(true, "screen-saver");
+    } catch {}
+  } else {
+    try {
+      if (typeof win.isAlwaysOnTop !== "function" || !win.isAlwaysOnTop()) {
+        win.setAlwaysOnTop(true, "floating");
+      }
+    } catch {}
+  }
   // moveTop is macOS orderWindow:NSWindowAbove — on a HIDDEN window that orders it
   // back on-screen. That made the dismissed pill flash on every Space switch (shown
   // here, then hidden again by the visibility sync). Raising only means anything

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.70",
+  "version": "0.1.71",
   "description": "Relay companion for ordinary messages, with dormant coordination features available only by explicit opt-in.",
   "type": "module",
   "bin": {

package/src/install.js

@@ -501,6 +501,21 @@ export function claudeSettingsPath() {
   );
 }
 
+/**
+ * True when Claude looks present on this machine, judged ONLY by the directory
+ * that holds claudeSettingsPath() (so CLAUDE_SETTINGS / CLAUDE_HOME overrides are
+ * respected for tests). Deliberately not a `claude` CLI probe: Windows installs
+ * routinely have Claude Code/Desktop with ~/.claude configured by hand and no
+ * `claude` on PATH, and those installs still need the hook runtime.
+ */
+export function claudeAppearsPresent({ settingsPath = claudeSettingsPath() } = {}) {
+  try {
+    return fs.existsSync(path.dirname(settingsPath));
+  } catch {
+    return false;
+  }
+}
+
 function shellArg(value) {
   const clean = String(value);
   return /\s/.test(clean) ? `"${clean.replaceAll('"', '\\"')}"` : clean;
@@ -1009,14 +1024,19 @@ export async function runSetupInstall({ mode = DEFAULT_COMPANION_MODE } = {}) {
   if (claude.ok) {
     installed.push("Claude Code");
     activations.push(verifyClaudeMcpRegistration({ configPath: claude.configPath }));
-    // The Open-in-current-chat hook runtime rides along with the MCP
-    // registration (both are what "Relay is installed into Claude" means).
-    claudeHooks = installClaudeHooks(bin, node);
   } else if (claude.reason === "claude_code_not_found") {
     missing.push("Claude Code");
   } else {
     missing.push("Claude Code (registration failed)");
   }
+  // The Open-in-current-chat hook runtime rides along with the MCP registration
+  // (both are what "Relay is installed into Claude" means) — but it must NOT
+  // depend on the `claude` CLI being on PATH. On Windows installClaudeCode fails
+  // with claude_code_not_found whenever the CLI is absent even though Claude
+  // Code/Desktop is installed and the MCP was registered by hand; without this
+  // fallback the hook is never written and the pill's "Open in current chat" is a
+  // silent no-op on exactly those machines.
+  if (claude.ok || claudeAppearsPresent()) claudeHooks = installClaudeHooks(bin, node);
   const codex = installCodex(bin, node, { mode: normalizedMode });
   if (codex.ok) {
     installed.push("Codex");