relay-companion 0.1.41 → 0.1.43

package/overlay/inbox.html

@@ -190,6 +190,16 @@
     transition:background-color .14s var(--settle);
   }
   .row:hover { background:rgba(31,26,23,.025); }
+  .row-delete {
+    appearance:none; position:absolute; top:9px; right:9px; width:25px; height:25px;
+    display:flex; align-items:center; justify-content:center; border:0; border-radius:7px;
+    background:rgba(255,255,255,.86); color:var(--muted-3); cursor:pointer; opacity:0;
+    transition:opacity .14s var(--settle), color .14s var(--settle), background .14s var(--settle);
+  }
+  .row:hover .row-delete, .row-delete:focus-visible { opacity:1; }
+  .row-delete:hover { color:#a83a32; background:#fff1ef; }
+  .row-delete:disabled { opacity:.45; cursor:default; }
+  .row.deletable .rk-time { margin-right:22px; }
   @keyframes rowEnter { from { opacity:0; transform:translateY(-12px); } to { opacity:1; transform:none; } }
   .row.enter { animation:rowEnter .52s var(--soft) both; }
 
@@ -1248,8 +1258,11 @@
       const body = r.bodyMarkdown || r.body || "";
       const preview = kind === "human_question" ? "" : bodyPreview(body, subject, 110);
       const previewHtml = preview ? `<div class="rk-preview">${esc(preview)}</div>` : "";
+      const canDelete = kind === "plain_relay" || kind === "human_question" || kind === "task_completed" || kind === "task_cancelled" || kind === "task_failed";
+      const deleteButton = canDelete ? `<button class="row-delete" type="button" data-delete="${esc(r.id)}" data-stop="1" aria-label="Move to Recently Deleted" title="Move to Recently Deleted"><svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7h16M9 7V4h6v3M7 7l1 13h8l1-13M10 11v5M14 11v5"/></svg></button>` : "";
       return `
-      <div class="row ${r.unread ? "unread" : ""}${fresh ? " enter" : ""}" data-id="${esc(r.id)}" data-opening-id="${esc(r.id)}">
+      <div class="row ${r.unread ? "unread" : ""}${fresh ? " enter" : ""}${canDelete ? " deletable" : ""}" data-id="${esc(r.id)}" data-opening-id="${esc(r.id)}">
+        ${deleteButton}
         <div class="rk-top">
           <span class="rk-dot"></span>
           <span class="rk-from">From</span>
@@ -1354,6 +1367,25 @@
       ta.addEventListener("input", () => { ta.style.height = "auto"; ta.style.height = Math.min(84, ta.scrollHeight) + "px"; });
       ta.addEventListener("mousedown", () => setInteractive(true));
     }
+    for (const btn of relaysListEl.querySelectorAll("[data-delete]")) {
+      const id = btn.getAttribute("data-delete");
+      btn.addEventListener("click", async (event) => {
+        event.stopPropagation();
+        if (btn.disabled) return;
+        btn.disabled = true;
+        showRowError(id, "");
+        try {
+          const res = await window.relay.deleteRelay(id);
+          if (!res || res.ok === false) {
+            showRowError(id, (res && res.error) || "Could not move this relay to Recently Deleted.");
+            btn.disabled = false;
+          }
+        } catch (err) {
+          showRowError(id, (err && err.message) || "Could not move this relay to Recently Deleted.");
+          btn.disabled = false;
+        }
+      });
+    }
     // accept/reject are hidden with the Tasks surface. Only connector_reauth keeps a
     // [data-review] "Reconnect" affordance here.
     for (const btn of relaysListEl.querySelectorAll("[data-review]")) {

package/overlay/main.cjs

@@ -656,6 +656,32 @@ function ackPacket(packetId) {
   pushInbox(true).catch(() => {});
 }
 
+async function deletePacket(packetId) {
+  if (!packetId) return { ok: false, error: "Missing relay id." };
+  const row = rowById(packetId);
+  if (!row) return { ok: true };
+  try {
+    // Server first: a transient network/API error must never make a recoverable
+    // item disappear locally without actually entering Recently Deleted.
+    const client = await relayClient();
+    await client.deleteInboxItem(packetId, { idempotencyKey: idempotencyKey("inbox_delete") });
+    withJsonLock(STATE_PATH, () => {
+      const store = readStore();
+      if (store.packets) delete store.packets[packetId];
+      writeStateAtomic(store);
+    });
+    presentedRelayIds.delete(packetId);
+    activeAttentionIds.delete(packetId);
+    writeOverlayPrefs();
+    await pushInbox(true);
+    return { ok: true };
+  } catch (error) {
+    const message = error && error.message ? error.message : String(error);
+    console.error("[overlay] relay delete failed:", message);
+    return { ok: false, error: message };
+  }
+}
+
 // ---- mutations -----------------------------------------------------------
 
 function idempotencyKey(prefix) {
@@ -1598,6 +1624,7 @@ ipcMain.on("relay:openSent", (_e, id) => {
 ipcMain.on("relay:openTask", (_e, taskId) => openTaskDetail(taskId));
 ipcMain.on("relay:openUrl", (_e, url) => openUrlTarget(url));
 ipcMain.on("relay:ack", (_e, id) => ackPacket(id));
+ipcMain.handle("relay:delete", (_e, id) => deletePacket(id));
 ipcMain.handle("relay:refreshSent", async () => {
   await refreshSent();
   await pushInbox(true);

package/overlay/preload.cjs

@@ -15,6 +15,7 @@ contextBridge.exposeInMainWorld("relay", {
   open: (id) => ipcRenderer.send("relay:open", id),
   openSent: (id) => ipcRenderer.send("relay:openSent", id),
   ack: (id) => ipcRenderer.send("relay:ack", id),
+  deleteRelay: (id) => ipcRenderer.invoke("relay:delete", id),
   openUrl: (url) => ipcRenderer.send("relay:openUrl", url),
   refreshSent: () => ipcRenderer.invoke("relay:refreshSent"),
 

package/package.json

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

package/src/client.js

@@ -73,6 +73,18 @@ export class RelayClient {
     return this.#req("POST", `/v1/relays/${encodeURIComponent(id)}/read`, payload);
   }
 
+  deleteInboxItem(itemId, payload = {}) {
+    return this.#req("POST", `/v1/inbox-items/${encodeURIComponent(itemId)}/delete`, payload);
+  }
+
+  recentlyDeleted() {
+    return this.#req("GET", "/v1/recently-deleted");
+  }
+
+  restoreInboxItem(itemId, payload = {}) {
+    return this.#req("POST", `/v1/recently-deleted/${encodeURIComponent(itemId)}/restore`, payload);
+  }
+
   openRelay(token) {
     return this.#req("GET", `/v1/open/${encodeURIComponent(token)}`, undefined, { auth: false });
   }

package/src/desktop-migration.js

@@ -43,7 +43,11 @@ function readMarker(markerPath) {
 }
 
 function markerSurfacePaths(marker) {
-  return [marker?.appPath, marker?.pillPlistPath, marker?.daemonPlistPath];
+  const appExecutablePath =
+    typeof marker?.appPath === "string" && marker.appPath
+      ? path.join(marker.appPath, "Contents", "MacOS", "applet")
+      : null;
+  return [marker?.appPath, appExecutablePath, marker?.pillPlistPath, marker?.daemonPlistPath];
 }
 
 export function desktopMigrationMarkerIsCurrent(

package/src/install.js

@@ -194,21 +194,44 @@ export function installRelayMacApp({
       appPaths: [RELAY_MAC_APP_NAME, RELAY_MAC_APP_FALLBACK_NAME].map((name) => path.join(applicationsDir, name)),
     };
   }
-  const tmpPath = `${appPath}.${process.pid}.${Date.now()}.tmp`;
+  // Keep the staging bundle's final extension as .app. osacompile decides whether
+  // to produce an application bundle from the output extension; a generic .tmp
+  // path would produce a flat compiled script instead. Nest it under a hidden,
+  // same-volume directory so Spotlight cannot transiently expose a duplicate app.
+  const stagingDir = path.join(applicationsDir, `.relay-app-staging-${process.pid}-${Date.now()}`);
+  const tmpPath = path.join(stagingDir, RELAY_MAC_APP_NAME);
   const contentsDir = path.join(tmpPath, "Contents");
   const macosDir = path.join(contentsDir, "MacOS");
   const resourcesDir = path.join(contentsDir, "Resources");
-  const launcherPath = path.join(macosDir, "Relay");
+  const appletExecutablePath = path.join(macosDir, "applet");
+  const launcherPath = path.join(resourcesDir, "relay-launcher.sh");
   const logPath = path.join(homeDir, ".relay", "pill.log");
   const pillPlistPath = path.join(homeDir, "Library", "LaunchAgents", `${PILL_LAUNCH_LABEL}.plist`);
   const version = packageVersion(packageRoot);
 
   try {
-    fs.rmSync(tmpPath, { recursive: true, force: true });
-    fs.mkdirSync(macosDir, { recursive: true });
-    fs.mkdirSync(resourcesDir, { recursive: true });
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+    fs.mkdirSync(applicationsDir, { recursive: true });
+    fs.mkdirSync(stagingDir, { recursive: true });
     fs.mkdirSync(path.dirname(logPath), { recursive: true });
 
+    // LaunchServices rejects a shell script used directly as CFBundleExecutable
+    // (NSOSStatusErrorDomain -10669 on current macOS), even when it has a valid
+    // shebang and executable mode. Generate the system AppleScript applet wrapper
+    // so the bundle has a native universal Mach-O executable. The applet only runs
+    // our resource shell script; it does not automate or inspect another app.
+    const appletSource = [
+      "on run",
+      '  set launcherPath to POSIX path of (path to resource "relay-launcher.sh")',
+      '  do shell script "/bin/sh " & quoted form of launcherPath',
+      "end run",
+    ].join("\n");
+    const compiled = runCommand("/usr/bin/osacompile", ["-e", appletSource, "-o", tmpPath]);
+    if (!compiled.ok || !fs.existsSync(appletExecutablePath)) {
+      throw new Error(`could not compile native Relay app launcher${compiled.out ? `: ${compiled.out}` : ""}`);
+    }
+    fs.mkdirSync(resourcesDir, { recursive: true });
+
     const launcher = [
       "#!/bin/sh",
       'nonce="app-$$-$(date +%s)"',
@@ -247,35 +270,61 @@ export function installRelayMacApp({
 <dict>
   <key>CFBundleName</key><string>Relay</string>
   <key>CFBundleDisplayName</key><string>Relay</string>
-  <key>CFBundleExecutable</key><string>Relay</string>
+  <key>CFBundleExecutable</key><string>applet</string>
   <key>CFBundleIdentifier</key><string>${RELAY_MAC_BUNDLE_IDENTIFIER}</string>
+  <key>CFBundleInfoDictionaryVersion</key><string>6.0</string>
   <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleSignature</key><string>aplt</string>
   <key>CFBundleShortVersionString</key><string>${plistEscape(version)}</string>
   <key>CFBundleVersion</key><string>${plistEscape(version)}</string>
 ${iconEntry}  <key>LSUIElement</key><true/>
   <key>NSHighResolutionCapable</key><true/>
+  <key>OSAAppletShowStartupScreen</key><false/>
 </dict>
 </plist>
 `;
     fs.writeFileSync(path.join(contentsDir, "Info.plist"), info);
     fs.writeFileSync(path.join(contentsDir, "PkgInfo"), "APPL????");
 
+    // osacompile signs the initial applet, so adding our launcher, icon, and final
+    // Info.plist invalidates that temporary signature. Re-sign the completed bundle
+    // and verify it before exposing it to LaunchServices; otherwise a bundle can be
+    // indexed by Spotlight yet still fail when the user clicks it.
+    const signed = runCommand("/usr/bin/codesign", ["--force", "--deep", "--sign", "-", tmpPath]);
+    if (!signed.ok) {
+      throw new Error(`could not sign native Relay app launcher${signed.out ? `: ${signed.out}` : ""}`);
+    }
+    const verified = runCommand("/usr/bin/codesign", ["--verify", "--deep", "--strict", tmpPath]);
+    if (!verified.ok) {
+      throw new Error(`could not verify native Relay app launcher${verified.out ? `: ${verified.out}` : ""}`);
+    }
+
     // Replace the Relay-owned bundle atomically enough that Spotlight never indexes
     // a half-written app. LaunchServices/Spotlight refreshes are best-effort; merely
     // placing a valid .app under ~/Applications is sufficient on a normal macOS host.
-    fs.mkdirSync(applicationsDir, { recursive: true });
+    // Re-check ownership at the destructive boundary in case another process placed
+    // or replaced an unrelated app at the chosen path while the bundle was compiling.
+    if (fs.existsSync(appPath) && !isRelayOwnedMacApp(appPath)) {
+      throw new Error("Relay app target changed during installation");
+    }
     fs.rmSync(appPath, { recursive: true, force: true });
     fs.renameSync(tmpPath, appPath);
+    fs.rmSync(stagingDir, { recursive: true, force: true });
     runCommand("/usr/bin/touch", [appPath]);
     runCommand(
       "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister",
       ["-f", appPath]
     );
     runCommand("/usr/bin/mdimport", [appPath]);
-    return { ok: true, appPath, launcherPath: path.join(appPath, "Contents", "MacOS", "Relay") };
+    return {
+      ok: true,
+      appPath,
+      launcherPath: path.join(appPath, "Contents", "Resources", "relay-launcher.sh"),
+      appletExecutablePath: path.join(appPath, "Contents", "MacOS", "applet"),
+    };
   } catch (error) {
     try {
-      fs.rmSync(tmpPath, { recursive: true, force: true });
+      fs.rmSync(stagingDir, { recursive: true, force: true });
     } catch {}
     return {
       ok: false,

package/src/mcp.js

@@ -94,6 +94,45 @@ export const TOOLS = [
       "List ordinary Relay messages addressed to this human. This does not list task coordination relays; use relay_task_status for task state.",
     inputSchema: { type: "object", properties: {} },
   },
+  {
+    name: "relay_inbox_delete",
+    description:
+      "Move one Relay inbox item to Recently Deleted for this human. This immediately removes it from the Relay website inbox and companion pill, but does not erase the sender's Sent history and does not cancel, answer, or otherwise change an underlying Relay task. The item remains recoverable for exactly 30 days, then its recovery snapshot is permanently erased and restoration is impossible. For an ordinary relay, pass the relayId returned by relay_inbox_list. For a task question shown in the pill/site, pass human_question:<messageId>. For a terminal task notification, pass task_completed:<taskId>, task_cancelled:<taskId>, or task_failed:<taskId>. Do not guess an id or delete merely to acknowledge/mark handled; use relay_acknowledge for that ordinary-relay workflow. A pending human question may leave its agent task paused even after the inbox item is deleted, because deletion is only inbox organization. This operation is idempotent for a given item while it remains in Recently Deleted.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        itemId: {
+          type: "string",
+          description:
+            "Exact stable inbox item id. Use relayId for ordinary relays, human_question:<messageId> for a task question, or task_<terminal-state>:<taskId> for a terminal task notification.",
+        },
+        idempotencyKey: { type: "string", description: "A unique key of at least 8 characters for this deletion request." },
+      },
+      required: ["itemId", "idempotencyKey"],
+    },
+  },
+  {
+    name: "relay_recently_deleted_list",
+    description:
+      "Fetch this human's complete Recently Deleted Relay inbox. Use this before attempting a restore whenever the human describes an item by sender, title, content, or approximate time instead of giving an exact itemId. Results are ordered newest deletion first and include the exact itemId required by relay_recently_deleted_restore, source type, sender/title/body snapshot, deletion time, permanentlyDeletesAt, and daysRemaining. Recently Deleted exists only on the Relay website and through these MCP tools; it is intentionally never shown in the companion pill. Items remain here for 30 days from their most recent deletion. After permanentlyDeletesAt the recovery snapshot is erased, the item no longer appears here, and neither an agent nor Relay support can restore it. Listing is read-only and does not extend the 30-day deadline.",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "relay_recently_deleted_restore",
+    description:
+      "Restore one exact inbox item from this human's Recently Deleted folder. First call relay_recently_deleted_list unless the human supplied an exact current itemId; match cautiously using sender, title, body, sourceType, and timestamps, and ask the human if multiple items could match. Never invent or infer an id. Restoration is only possible before permanentlyDeletesAt. A successful restore removes the item from Recently Deleted and makes it eligible to reappear in the website inbox and companion pill; the companion treats the restore as fresh delivery so an older item can notify again. Restoring a task question does not answer it, and may re-expose a still-paused run; restoring a task-status notification does not reopen the completed/cancelled/failed task. Restoring an ordinary relay does not alter the sender's Sent record. This operation is idempotent for the same already-restored item.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        itemId: {
+          type: "string",
+          description: "The exact itemId returned by relay_recently_deleted_list. Do not use a title, relay subject, or guessed task/message id.",
+        },
+        idempotencyKey: { type: "string", description: "A unique key of at least 8 characters for this restore request." },
+      },
+      required: ["itemId", "idempotencyKey"],
+    },
+  },
   {
     name: "relay_acknowledge",
     description:
@@ -456,6 +495,12 @@ export async function handleCall(client, name, args) {
       );
     case "relay_inbox_list":
       return text(await client.inbox());
+    case "relay_inbox_delete":
+      return text(await client.deleteInboxItem(args.itemId, { idempotencyKey: args.idempotencyKey }));
+    case "relay_recently_deleted_list":
+      return text(await client.recentlyDeleted());
+    case "relay_recently_deleted_restore":
+      return text(await client.restoreInboxItem(args.itemId, { idempotencyKey: args.idempotencyKey }));
     case "relay_acknowledge":
       return text(await client.acknowledge(args.relayId, { idempotencyKey: args.idempotencyKey }));
     case "relay_task_create":

package/src/notifications.js

@@ -113,7 +113,7 @@ function taskNotification(task, kind, title, body, url, extra = {}) {
   };
 }
 
-export function buildHumanNotifications({ user, tasks = [], relays = [], connectors = [] } = {}) {
+export function buildHumanNotifications({ user, tasks = [], relays = [], connectors = [], inboxState = {} } = {}) {
   const notifications = [];
   for (const task of tasks) {
     const participant = participantForUser(task, user);
@@ -193,12 +193,22 @@ export function buildHumanNotifications({ user, tasks = [], relays = [], connect
     };
     notifications.push({ ...notification, action: actionForNotification(notification) });
   }
-  return notifications;
+  const suppressed = new Set(inboxState.suppressedItemIds || []);
+  const restoredAtByItemId = inboxState.restoredAtByItemId || {};
+  return notifications
+    .filter((notification) => !suppressed.has(notification.id))
+    .map((notification) => ({
+      ...notification,
+      deliveryVersion: restoredAtByItemId[notification.id] || "",
+    }));
 }
 
 export function freshNotifications(ledger, notifications) {
   const seen = ledger.notifications || {};
-  return notifications.filter((notification) => !seen[notification.id]);
+  return notifications.filter((notification) => {
+    const previous = seen[notification.id];
+    return !previous || (notification.deliveryVersion || "") !== (previous.deliveryVersion || "");
+  });
 }
 
 export function markNotificationsProcessed(ledger, notifications) {
@@ -207,6 +217,7 @@ export function markNotificationsProcessed(ledger, notifications) {
   for (const notification of notifications) {
     ledger.notifications[notification.id] = {
       kind: notification.kind,
+      deliveryVersion: notification.deliveryVersion || "",
       processedAt,
     };
   }

package/src/task-daemon.js

@@ -176,6 +176,7 @@ async function pollHumanNotifications({ client, ledger, stageCompanionItem, stag
       tasks: tasks.tasks || [],
       relays: relays.relays || [],
       connectors: connectors.connectors || [],
+      inboxState: relays.inboxState || {},
     });
     const fresh = freshNotifications(ledger, notifications);
     const staged = [];