relay-companion 0.1.26 → 0.1.28

package/overlay/main.cjs

@@ -20,7 +20,7 @@
 //   - Mutations (accept/reject/approve/decline/answer) call RelayClient with device-token
 //     auth. ack/mark-read writes state.json directly (atomic temp+rename).
 
-const { app, BrowserWindow, Menu, Tray, ipcMain, nativeImage, shell, screen } = require("electron");
+const { app, BrowserWindow, Menu, Tray, ipcMain, nativeImage, shell, screen, systemPreferences } = require("electron");
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
@@ -30,6 +30,11 @@ const { execFile, execFileSync, spawn, pathToFileURL } = (() => {
   return { execFile: cp.execFile, execFileSync: cp.execFileSync, spawn: cp.spawn, pathToFileURL: url.pathToFileURL };
 })();
 const { hostFromBundle, chooseClickHost } = require("./host-select.cjs");
+const {
+  reinforceSpacePresence,
+  showInactiveOnAllSpaces,
+  subscribeActiveSpaceChanges,
+} = require("./space-presence.cjs");
 
 const RELAY_HOME = process.env.RELAY_HOME || process.env.RELAY_COMPANION_HOME || path.join(os.homedir(), ".relay-companion");
 const STATE_PATH = path.join(RELAY_HOME, "state.json");
@@ -884,31 +889,59 @@ function anchorTopRight() {
   return { x: wa.x + wa.width - WIN.width - MARGIN, y: wa.y + MARGIN, width: WIN.width, height: WIN.height };
 }
 
+function placeOverlayWindow({ reposition = true, moveTop = false } = {}) {
+  if (!win || win.isDestroyed()) return;
+  if (reposition) {
+    try {
+      win.setBounds(anchorTopRight(), false);
+    } catch (error) {
+      console.error("[overlay] setBounds failed:", error && error.message);
+    }
+  }
+  reinforceSpacePresence(win, { moveTop });
+}
+
 // Show the overlay window. Electron's forwarded-mousemove stream (the thing that
 // lets the renderer detect hover on a click-through window) can stall across a
 // hide()/show() cycle, leaving the window permanently click-through. Re-assert
 // setIgnoreMouseEvents on every hidden->shown transition and tell the renderer to
 // reset its interactivity handshake.
-function showOverlayWindow() {
-  if (!win || win.isDestroyed() || win.isVisible()) return;
-  win.showInactive();
+function showOverlayWindow({ force = false, reposition = true } = {}) {
+  if (!win || win.isDestroyed()) return;
+  const visible = win.isVisible();
+  if (visible && !force) {
+    reinforceSpacePresence(win);
+    return;
+  }
+  placeOverlayWindow({ reposition });
+  const shown = showInactiveOnAllSpaces(win, { force });
   win.setIgnoreMouseEvents(true, { forward: true });
-  win.webContents.send("shown");
+  if (shown) win.webContents.send("shown");
 }
 
-function maybeShow() {
+function maybeShow({ force = false, reposition = true } = {}) {
   if (!win || win.isDestroyed()) return;
   // Dismissed keeps the window hidden except while a ghost notification is up.
   // trayForcedVisible honors an explicit status-area click even when no host runs.
   const dismissedEffective = trayAvailable && dismissed;
   const wanted = (hostRunning || trayForcedVisible) && (!dismissedEffective || ghostActive);
   if (wanted) {
-    showOverlayWindow();
+    showOverlayWindow({ force, reposition });
   } else if (win.isVisible()) {
     win.hide();
   }
 }
 
+function refreshOverlayForActiveSpace({ force = false } = {}) {
+  if (!win || win.isDestroyed()) return;
+  reinforceSpacePresence(win, { moveTop: true });
+  readHostProcesses((err, stdout) => {
+    if (!err) updateHostRunningFromProcesses(stdout);
+    if (hostRunning) trayForcedVisible = false;
+    maybeShow({ force, reposition: false });
+  });
+}
+
 function readHostProcesses(cb) {
   if (process.platform === "win32") {
     execFile("tasklist", ["/FO", "CSV", "/NH"], cb);
@@ -1010,6 +1043,21 @@ function createWindow() {
   setInterval(pollHosts, 1500);
 }
 
+function installActiveSpaceWatcher() {
+  if (process.platform !== "darwin") return;
+  subscribeActiveSpaceChanges(
+    systemPreferences,
+    () => {
+      // Space transitions finish asynchronously. Force one re-show after the switch
+      // starts and again after the animation settles so macOS cannot leave the
+      // transparent accessory window assigned only to the previous Desktop.
+      setTimeout(() => refreshOverlayForActiveSpace({ force: true }), 120);
+      setTimeout(() => refreshOverlayForActiveSpace({ force: true }), 700);
+    },
+    { log: (message) => console.error("[overlay]", message) },
+  );
+}
+
 // ---- OS status area (tray/menu bar) ----------------------------------------
 
 // The Relay mark lives in the OS status area: macOS menu bar, Windows system tray.
@@ -1040,8 +1088,8 @@ function createTrayIcon() {
 function showFromTray() {
   setDismissed(false);
   ghostActive = false;
-  if (!hostRunning) trayForcedVisible = true; // an explicit click always gets the card
-  maybeShow();
+  trayForcedVisible = true; // an explicit click always gets the card
+  maybeShow({ force: true });
   if (win && !win.isDestroyed()) win.webContents.send("openFull");
 }
 
@@ -1117,7 +1165,10 @@ ipcMain.on("relay:interactive", (_e, interactive) => {
   if (win && !win.isDestroyed()) win.setIgnoreMouseEvents(!interactive, { forward: true });
 });
 ipcMain.on("relay:setPos", (_e, x, y) => {
-  if (win && !win.isDestroyed() && Number.isFinite(x) && Number.isFinite(y)) win.setPosition(Math.round(x), Math.round(y));
+  if (win && !win.isDestroyed() && Number.isFinite(x) && Number.isFinite(y)) {
+    win.setPosition(Math.round(x), Math.round(y));
+    reinforceSpacePresence(win);
+  }
 });
 // ✕ on the card: hide the overlay entirely until the status-area Relay mark is clicked.
 // The renderer plays its exit animation first, then sends this.
@@ -1176,6 +1227,7 @@ if (!gotSingleInstanceLock) {
     if (process.platform === "darwin" && app.dock) app.dock.hide(); // accessory: no dock icon, no NC banners
     createWindow();
     createTray();
+    installActiveSpaceWatcher();
   });
 
   app.on("window-all-closed", () => {

package/overlay/space-presence.cjs

@@ -0,0 +1,53 @@
+const ACTIVE_SPACE_CHANGED = "NSWorkspaceActiveSpaceDidChangeNotification";
+
+function isUsableWindow(win) {
+  return Boolean(win && !(typeof win.isDestroyed === "function" && win.isDestroyed()));
+}
+
+function reinforceSpacePresence(win, { moveTop = false } = {}) {
+  if (!isUsableWindow(win)) return false;
+  try {
+    win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+  } catch {}
+  try {
+    win.setAlwaysOnTop(true, "floating");
+  } catch {}
+  if (moveTop && typeof win.moveTop === "function") {
+    try {
+      win.moveTop();
+    } catch {}
+  }
+  return true;
+}
+
+function showInactiveOnAllSpaces(win, { force = false } = {}) {
+  if (!isUsableWindow(win)) return false;
+  const visible = typeof win.isVisible === "function" ? win.isVisible() : false;
+  if (visible && !force) {
+    reinforceSpacePresence(win);
+    return false;
+  }
+
+  reinforceSpacePresence(win);
+  if (visible && force && typeof win.hide === "function") win.hide();
+  if (typeof win.showInactive === "function") win.showInactive();
+  reinforceSpacePresence(win, { moveTop: true });
+  return true;
+}
+
+function subscribeActiveSpaceChanges(systemPreferences, callback, { log = () => {} } = {}) {
+  if (!systemPreferences || typeof systemPreferences.subscribeWorkspaceNotification !== "function") return null;
+  try {
+    return systemPreferences.subscribeWorkspaceNotification(ACTIVE_SPACE_CHANGED, () => callback());
+  } catch (error) {
+    log(`space change subscription failed: ${error && error.message ? error.message : String(error)}`);
+    return null;
+  }
+}
+
+module.exports = {
+  ACTIVE_SPACE_CHANGED,
+  reinforceSpacePresence,
+  showInactiveOnAllSpaces,
+  subscribeActiveSpaceChanges,
+};

package/package.json

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

package/src/auto-update.js

@@ -172,6 +172,10 @@ export function spawnDetachedUpdate({
     `  ROOT="$(npm root -g 2>/dev/null)"`,
     `  PKG="$ROOT/${PACKAGE_NAME}"`,
     `  ELECTRON="$PKG/node_modules/electron/dist/Electron.app/Contents/MacOS/Electron"`,
+    `  if [ ! -x "$ELECTRON" ] && [ -f "$PKG/node_modules/electron/install.js" ]; then`,
+    `    echo "[relay-update] $(date) electron runtime missing; running electron install.js" >> ${LOG} 2>&1`,
+    `    node "$PKG/node_modules/electron/install.js" >> ${LOG} 2>&1 || true`,
+    `  fi`,
     `  if [ -x "$ELECTRON" ] && [ -f "$PKG/bin/relay.js" ] && grep -q '"version"' "$PKG/package.json" 2>/dev/null; then`,
     `    echo "[relay-update] $(date) install verified; restarting services" >> ${LOG} 2>&1`,
     `    /bin/launchctl kickstart -k gui/${uid}/${PILL_LABEL} >> ${LOG} 2>&1 || true`,
@@ -179,10 +183,16 @@ export function spawnDetachedUpdate({
     `  else`,
     `    echo "[relay-update] $(date) post-install verify FAILED; restoring ${restore}" >> ${LOG} 2>&1`,
     `    npm install -g ${PACKAGE_NAME}@${restore} >> ${LOG} 2>&1 || true`,
+    `    ROOT="$(npm root -g 2>/dev/null)"`,
+    `    PKG="$ROOT/${PACKAGE_NAME}"`,
+    `    if [ -f "$PKG/node_modules/electron/install.js" ]; then node "$PKG/node_modules/electron/install.js" >> ${LOG} 2>&1 || true; fi`,
     `  fi`,
     `else`,
     `  echo "[relay-update] $(date) install FAILED; restoring ${restore}" >> ${LOG} 2>&1`,
     `  npm install -g ${PACKAGE_NAME}@${restore} >> ${LOG} 2>&1 || true`,
+    `  ROOT="$(npm root -g 2>/dev/null)"`,
+    `  PKG="$ROOT/${PACKAGE_NAME}"`,
+    `  if [ -f "$PKG/node_modules/electron/install.js" ]; then node "$PKG/node_modules/electron/install.js" >> ${LOG} 2>&1 || true; fi`,
     `fi`,
   ].join("\n");
   const child = spawnImpl("/bin/sh", ["-c", script], { detached: true, stdio: "ignore" });

package/src/install.js

@@ -240,6 +240,30 @@ function electronPathForPackageRoot(packageRoot) {
   }
 }
 
+export function ensureElectronRuntime(packageRoot, { runCommand = run } = {}) {
+  let electronPath = electronPathForPackageRoot(packageRoot);
+  if (electronPath && fs.existsSync(electronPath)) return { ok: true, electronPath, repaired: false };
+
+  const installScript = path.join(packageRoot, "node_modules", "electron", "install.js");
+  if (!fs.existsSync(installScript)) {
+    return { ok: false, reason: "electron_install_script_missing", electronPath, installScript };
+  }
+
+  const res = runCommand(process.execPath, [installScript], { timeoutMs: npmInstallTimeoutMs() });
+  electronPath = electronPathForPackageRoot(packageRoot);
+  if (res.ok && electronPath && fs.existsSync(electronPath)) {
+    return { ok: true, electronPath, repaired: true };
+  }
+
+  return {
+    ok: false,
+    reason: "electron_runtime_missing",
+    electronPath,
+    installScript,
+    detail: res.out,
+  };
+}
+
 /** Whether an agent CLI is on PATH. */
 export function commandExists(cmd) {
   const res = spawnSync(cmd, ["--version"], { encoding: "utf8", timeout: 8000 });
@@ -333,10 +357,11 @@ export function installDaemonAutostart(bin = relayBinPath(), node = process.exec
 export function installPillAutostart(bin = relayBinPath(), { platform = process.platform, runCommand = run } = {}) {
   if (platform !== "darwin" && platform !== "win32") return { ok: false, reason: "autostart_unsupported_platform" };
   const packageRoot = packageRootForBin(bin);
-  const electronPath = electronPathForPackageRoot(packageRoot);
+  const electron = ensureElectronRuntime(packageRoot, { runCommand });
+  const electronPath = electron.electronPath;
   const overlayMain = path.join(packageRoot, "overlay", "main.cjs");
-  if (!electronPath || !fs.existsSync(overlayMain)) {
-    return { ok: false, reason: "pill_runtime_missing", electronPath, overlayMain };
+  if (!electron.ok || !electronPath || !fs.existsSync(overlayMain)) {
+    return { ok: false, reason: "pill_runtime_missing", electronPath, overlayMain, electron };
   }
   if (platform === "win32") {
     const logPath = path.join(os.homedir(), ".relay", "pill.log");