relay-companion 0.1.42 → 0.1.44

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.42",
+  "version": "0.1.44",
   "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/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,
     };
   }
@@ -238,6 +249,24 @@ function writeCompanionState(statePath, state) {
   fs.renameSync(tmp, statePath);
 }
 
+/** Apply server tombstones to rows already staged by this companion. */
+export function removeSuppressedCompanionItems(itemIds, { statePath = companionStatePath() } = {}) {
+  const suppressed = new Set((itemIds || []).filter(Boolean).map(String));
+  if (!suppressed.size) return 0;
+  return withJsonLock(statePath, () => {
+    const state = readCompanionState(statePath);
+    state.packets ||= {};
+    let removed = 0;
+    for (const id of suppressed) {
+      if (!state.packets[id]) continue;
+      delete state.packets[id];
+      removed += 1;
+    }
+    if (removed) writeCompanionState(statePath, state);
+    return removed;
+  });
+}
+
 function accountMarker({ user = currentUser(), deviceId = readConfig().deviceId || "" } = {}) {
   return {
     userId: user?.id || "",

package/src/task-daemon.js

@@ -14,6 +14,7 @@ import {
   defaultStageRelayCompanionItem,
   freshNotifications,
   markNotificationsProcessed,
+  removeSuppressedCompanionItems,
   reconcileAnsweredQuestions,
   stagePlainRelayItem as defaultStagePlainRelayItem,
 } from "./notifications.js";
@@ -171,11 +172,14 @@ async function pollHumanNotifications({ client, ledger, stageCompanionItem, stag
       client.listConnectors(),
     ]);
     const events = await pollVisibleTaskEvents({ client, ledger, tasks, log });
+    const removed = removeSuppressedCompanionItems(relays.inboxState?.suppressedItemIds || []);
+    if (removed) log(`removed ${removed} Relay item(s) moved to Recently Deleted elsewhere`);
     const notifications = buildHumanNotifications({
       user: me.user,
       tasks: tasks.tasks || [],
       relays: relays.relays || [],
       connectors: connectors.connectors || [],
+      inboxState: relays.inboxState || {},
     });
     const fresh = freshNotifications(ledger, notifications);
     const staged = [];