relay-companion 0.1.91 → 0.1.93

package/overlay/inbox.html

@@ -1564,6 +1564,7 @@
   // The relay row whose open-actions card is expanded. Like openingIds, this
   // survives the innerHTML rebuilds renderRelays performs on every push.
   let expandedRelayId = null;
+  let expandedSentId = null;   // Sent row whose open-actions menu is expanded
   // A conversation expands its actions IN PLACE, exactly like a single relay.
   // Taking over the whole pane (the old thread-detail push) lost the user's
   // place in the list for what is really a three-item menu.
@@ -1588,7 +1589,11 @@
     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
-    if (source === "sent" && window.relay.openSent) window.relay.openSent(id);
+    // Sent rows carry the same three modes as received relays; each has its own
+    // IPC so the sent copy is staged/forged before the open.
+    if (source === "sent" && mode === "current" && window.relay.openSentInCurrent) window.relay.openSentInCurrent(id);
+    else if (source === "sent" && mode === "fresh" && window.relay.openSentFresh) window.relay.openSentFresh(id);
+    else if (source === "sent" && window.relay.openSent) window.relay.openSent(id);
     else if (mode === "current" && window.relay.openInCurrent) window.relay.openInCurrent(id);
     else if (mode === "fresh" && window.relay.openFresh) window.relay.openFresh(id);
     else window.relay.open(id);
@@ -1731,10 +1736,12 @@
   // Preview plus the two host-open actions, as one small text-first menu.
   // Preview is the primary, non-navigation path; the other actions hand the
   // relay to a current or fresh host session.
-  function openActionsHtml(id, { thread, previewable = true, threadId = "", messageCount = 0 } = {}) {
-    const preview = thread ? `data-thread-preview="${esc(id)}"` : `data-preview="${esc(id)}"`;
-    const cur = thread ? `data-thread-open-current="${esc(id)}"` : `data-open-current="${esc(id)}"`;
-    const fresh = thread ? `data-thread-open-fresh="${esc(id)}"` : `data-open-fresh="${esc(id)}"`;
+  function openActionsHtml(id, { thread, previewable = true, threadId = "", messageCount = 0, sent = false } = {}) {
+    // Sent rows use their own data-* namespace so the Sent list's wiring stays
+    // independent of the Relays list (same menu, same three actions, own IPC).
+    const preview = sent ? `data-sent-preview="${esc(id)}"` : thread ? `data-thread-preview="${esc(id)}"` : `data-preview="${esc(id)}"`;
+    const cur = sent ? `data-sent-open-current="${esc(id)}"` : thread ? `data-thread-open-current="${esc(id)}"` : `data-open-current="${esc(id)}"`;
+    const fresh = sent ? `data-sent-open-fresh="${esc(id)}"` : thread ? `data-thread-open-fresh="${esc(id)}"` : `data-open-fresh="${esc(id)}"`;
     const previewItem = previewable
       ? `<button class="oa-item oa-primary" type="button" role="menuitem" ${preview}>${thread ? "Preview Latest Received Relay" : "Preview"}</button><div class="oa-sep" role="separator"></div>`
       : "";
@@ -2102,8 +2109,10 @@
       const preview = bodyPreview(body, subject, 118);
       const detail = sentDetail(r);
       const klass = sentClass(r);
+      const expanded = id === expandedSentId;
+      const openCard = expanded ? openActionsHtml(id, { sent: true }) : "";
       return `
-      <div class="row sent ${klass}" data-sent-id="${esc(id)}" data-opening-id="${esc(id)}">
+      <div class="row sent ${klass}${expanded ? " expanded" : ""}" data-sent-id="${esc(id)}" data-opening-id="${esc(id)}">
         <div class="rk-top">
           <span class="rk-dot"></span>
           <span class="rk-from">To</span>
@@ -2114,16 +2123,46 @@
         <div class="rk-subject">${esc(subject)}</div>
         ${preview ? `<div class="rk-preview">${esc(preview)}</div>` : ""}
         <div class="row-note">${esc(detail)}</div>
+        ${openCard}
+        <div class="row-err${rowNotes.get(id)?.cls === "ok" ? " ok" : ""}" data-err="${esc(id)}">${esc(rowNotes.get(id)?.text || "")}</div>
       </div>`;
     }).join("");
     wireSentRows();
   }
+  // A sent row expands into the SAME three-action menu as a received relay:
+  // Preview (read your own message in place), Open in Current Chat, Open in
+  // New Chat — each routed to the sent-side IPC.
   function wireSentRows() {
     for (const el of sentListEl.querySelectorAll(".row.sent")) {
       const id = el.getAttribute("data-sent-id");
       if (openingIds.has(id)) el.classList.add("opening");
       el.addEventListener("click", () => {
-        openRelayFromUI(id, "sent");
+        expandedSentId = expandedSentId === id ? null : id;
+        renderSent();
+      });
+    }
+    for (const z of sentListEl.querySelectorAll('[data-stop="1"]')) {
+      z.addEventListener("click", (e) => e.stopPropagation());
+    }
+    for (const btn of sentListEl.querySelectorAll("[data-sent-preview]")) {
+      btn.addEventListener("click", () => {
+        expandedSentId = null;
+        window.relay.preview(btn.getAttribute("data-sent-preview"));
+        renderSent();
+      });
+    }
+    for (const btn of sentListEl.querySelectorAll("[data-sent-open-current]")) {
+      const id = btn.getAttribute("data-sent-open-current");
+      btn.addEventListener("click", () => {
+        expandedSentId = null;
+        openRelayFromUI(id, "sent", "current");
+      });
+    }
+    for (const btn of sentListEl.querySelectorAll("[data-sent-open-fresh]")) {
+      const id = btn.getAttribute("data-sent-open-fresh");
+      btn.addEventListener("click", () => {
+        expandedSentId = null;
+        openRelayFromUI(id, "sent", "fresh");
       });
     }
   }
@@ -2945,6 +2984,7 @@
   // relays plus the live Sent list. Local data only — the pill shows the
   // user's own exchanges; the API's /v1/threads serves web and agents.
   let threadDetailId = null; // threadId while a thread's history is open
+  let threadDetailScrolledFor = null; // thread already auto-scrolled to newest (reset on leave)
   let threadDetailPartyHint = ""; // who it's with, for the header while messages load
   function threadMessages() {
     const msgs = [];
@@ -3044,7 +3084,11 @@
     const threadNote = threadOpenTarget
       ? `<div class="row-err${rowNotes.get(threadOpenTarget.id)?.cls === "ok" ? " ok" : ""}" data-err="${esc(threadOpenTarget.id)}" data-stop="1">${esc(rowNotes.get(threadOpenTarget.id)?.text || "")}</div>`
       : "";
-    thHistoryEl.innerHTML = threadActions + threadNote + thread.msgs.map((m) => `
+    // Chat-shaped, like every messaging app (and Claude itself — Sven's field
+    // note): messages read oldest -> newest downward, the open actions sit at
+    // the BOTTOM next to the newest message, and entering the thread lands you
+    // at the newest message, not the stalest.
+    thHistoryEl.innerHTML = thread.msgs.map((m) => `
       <button class="th-msg${m.unread ? " unread" : ""}" type="button" data-msg="${esc(m.id)}" data-dir="${m.direction}">
         <span class="th-msg-top">
           <span class="th-dir${m.direction === "out" ? " out" : ""}">${m.direction === "out" ? "←" : "→"}</span>
@@ -3052,7 +3096,13 @@
           <span class="th-time">${esc(timeAgo(m.at))}</span>
         </span>
         <span class="th-msg-title">${esc(m.title)}</span>
-      </button>`).join("");
+      </button>`).join("") + threadActions + threadNote;
+    // Land at the newest message when ENTERING the thread; rebuilds of the same
+    // open thread (payload pushes) keep the user's scroll position untouched.
+    if (threadDetailScrolledFor !== thread.threadId) {
+      threadDetailScrolledFor = thread.threadId;
+      requestAnimationFrame(() => { scrollEl.scrollTop = scrollEl.scrollHeight; });
+    }
     for (const el of thHistoryEl.querySelectorAll(".th-msg")) {
       el.addEventListener("click", () => {
         const id = el.getAttribute("data-msg");
@@ -3068,6 +3118,7 @@
   }
   thBackEl.addEventListener("click", () => {
     threadDetailId = null;
+    threadDetailScrolledFor = null;
     activeView = "relays";
     syncTabs();
     applyView();

package/overlay/main.cjs

@@ -1341,7 +1341,11 @@ function previewPayloadForPacket(packetId) {
   const id = String(packetId || "");
   if (!id) return null;
   const row = rowById(id);
-  if (!row || row.direction !== "inbound" || RELAY_HIDDEN_KINDS.has(row.relayNotificationKind)) return null;
+  if (!row || row.direction !== "inbound" || RELAY_HIDDEN_KINDS.has(row.relayNotificationKind)) {
+    // A Sent row lives in sentCache, not the staged packet store — read your own
+    // outbound message without leaving the pill, exactly like an inbound preview.
+    return previewPayloadForSent(id);
+  }
   return {
     relayId: id,
     title: String(row.title || row.displayTitle || "Relay"),
@@ -1352,6 +1356,27 @@ function previewPayloadForPacket(packetId) {
   };
 }
 
+// The preview payload for one of the user's own sent relays. `unread:false`
+// always: a sent message has no read state of its own to retire, and the
+// preview's ack path must never touch the recipient's receipts.
+function previewPayloadForSent(relayId) {
+  const id = String(relayId || "");
+  if (!id) return null;
+  const item = (sentCache || []).find((row) => String(row.relayId || row.id || "") === id);
+  if (!item) return null;
+  const recipient = item.recipient || {};
+  const to = recipient.name || recipient.email || item.groupName || "the recipient";
+  return {
+    relayId: id,
+    title: String(item.title || item.displayTitle || item.preview || "Relay"),
+    bodyMarkdown: String(item.bodyMarkdown || item.preview || ""),
+    senderName: `You → ${to}`,
+    createdAt: String(item.createdAt || ""),
+    unread: false,
+    outbound: true,
+  };
+}
+
 // Find an approvalId for a share_approval row. The staged row may not carry it,
 // in which case the renderer routes to the web detail page (Review) instead.
 function approvalIdForRow(row) {
@@ -2038,13 +2063,34 @@ function threadInfoFor(row) {
   return { threadId, threadCount: ids.size };
 }
 
-async function openPacketInCurrent(packetId) {
+async function openPacketInCurrent(packetId, { sent = false } = {}) {
   if (!packetId) return;
-  const row = rowById(packetId);
+  let row = rowById(packetId);
+  if (sent) {
+    // A sent relay has no staged inbound row: forge its `sent_<relayId>` copy
+    // exactly as the fresh-open path does, then inject THAT. The renderer keeps
+    // addressing the row by its relayId, so spinner/notes stay on the right row.
+    const sentItem = (sentCache || []).find((item) => String(item.relayId || item.id || "") === String(packetId));
+    if (!sentItem) {
+      console.error("[overlay] sent relay missing from cache:", packetId);
+      if (win && !win.isDestroyed()) win.webContents.send("openDone", packetId);
+      return;
+    }
+    try {
+      const stageSentRelayItem = await loadSentStager();
+      const staged = stageSentRelayItem({ item: sentItem, sender: account() }, { statePath: STATE_PATH });
+      row = rowById(staged.itemId) || row;
+    } catch (error) {
+      console.error("[overlay] sent staging for in-chat open failed:", packetId, error && error.message);
+      if (win && !win.isDestroyed()) win.webContents.send("openDone", packetId);
+      return;
+    }
+  }
   if (win && !win.isDestroyed()) win.webContents.send("opening", packetId);
   const finish = () => {
-    // Same read-state contract as a normal open: ack fires the receipts.
-    ackPacket(packetId);
+    // Sent relays carry no unread state of their own; acking one would touch the
+    // inbound copy of a self-send. Only inbound opens ack.
+    if (!sent) ackPacket(packetId);
     if (win && !win.isDestroyed()) win.webContents.send("openDone", packetId); // stop the row spinner
   };
   // Confirm the staging in the UI: without this, a successful injection is
@@ -2061,7 +2107,7 @@ async function openPacketInCurrent(packetId) {
       console.error(`[overlay] openInCurrent fallback for ${packetId}: ${note}`);
       if (win && !win.isDestroyed()) win.webContents.send("openError", packetId, `${note} — opening a new chat instead.`);
     }
-    openPacket(packetId, { fresh: true }).catch((error) =>
+    openPacket(packetId, { fresh: true, sent }).catch((error) =>
       console.error("[overlay] openInCurrent fresh fallback failed:", error && error.message),
     );
   };
@@ -3189,6 +3235,20 @@ ipcMain.handle("relay:get", () => buildPayload());
 ipcMain.on("relay:open", (_e, id) => {
   openPacket(id).catch((error) => console.error("[overlay] open failed:", error && error.message));
 });
+// Sent rows get the same three actions as received relays. "In current chat"
+// stages the sent copy through the SAME injection path (the materializer's
+// sent stager already forges a `sent_<relayId>` row), so the agent opens the
+// user's own message in the chat they are looking at.
+ipcMain.on("relay:openSentInCurrent", (_e, id) => {
+  openPacketInCurrent(id, { sent: true }).catch((error) =>
+    console.error("[overlay] sent open-in-current failed:", error && error.message),
+  );
+});
+ipcMain.on("relay:openSentFresh", (_e, id) => {
+  openPacket(id, { sent: true, fresh: true }).catch((error) =>
+    console.error("[overlay] sent fresh open failed:", error && error.message),
+  );
+});
 ipcMain.on("relay:openSent", (_e, id) => {
   openPacket(id, { sent: true }).catch((error) => console.error("[overlay] sent open failed:", error && error.message));
 });

package/overlay/preload.cjs

@@ -29,6 +29,9 @@ contextBridge.exposeInMainWorld("relay", {
   // Relay rows
   open: (id) => ipcRenderer.send("relay:open", id),
   openSent: (id) => ipcRenderer.send("relay:openSent", id),
+  // Sent rows get the same open-actions menu as received relays.
+  openSentInCurrent: (id) => ipcRenderer.send("relay:openSentInCurrent", id),
+  openSentFresh: (id) => ipcRenderer.send("relay:openSentFresh", id),
   // expand-card actions: inject into the live Claude session / force a fresh one
   preview: (id) => ipcRenderer.send("relay:preview", id),
   openInCurrent: (id) => ipcRenderer.send("relay:openInCurrent", id),

package/package.json

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

package/src/mcp.js

@@ -103,9 +103,56 @@ export const TOOLS = [
   {
     name: "relay_groups_list",
     description:
-      "List this human's Relay contact groups — named rosters of their saved contacts (e.g. 'Founders', 'Family') with each group's members. Use it when the human addresses several people at once or names a roster, then pass the chosen group's id to relay_send as recipient.groupId: the message fans out to every member and the whole roster shares ONE conversation thread where every member's reply reaches everyone (true group chat). Groups are managed on the Relay website (Contacts -> Groups); this tool is read-only.",
+      "List this human's Relay contact groups — named rosters of their saved contacts (e.g. 'Founders', 'Family') with each group's members. Use it when the human addresses several people at once or names a roster, then pass the chosen group's id to relay_send as recipient.groupId: the message fans out to every member and the whole roster shares ONE conversation thread where every member's reply reaches everyone (true group chat). To CHANGE a roster, use relay_group_create / relay_group_update / relay_group_delete — always list first so you act on a real groupId.",
     inputSchema: { type: "object", properties: {} },
   },
+  {
+    name: "relay_group_create",
+    description:
+      "Create a Relay contact group (a named roster) for this human, optionally with its starting members. Use it when they ask for a new group ('make a Founders group with Sven and Shane') — group names are unique per person, so call relay_groups_list first and use relay_group_update when the roster already exists. Members are contactIds from relay_contacts_search; look up every name BEFORE calling, and ask the human which person they meant rather than guessing between similar matches. Returns the created group with its members.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "The roster's display name, e.g. 'Founders'." },
+        memberContactIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional starting members: exact contactIds from relay_contacts_search.",
+        },
+        idempotencyKey: { type: "string" },
+      },
+      required: ["name", "idempotencyKey"],
+    },
+  },
+  {
+    name: "relay_group_update",
+    description:
+      "Rename a Relay contact group and/or add and remove its members — the same edits the human can make in the Relay pill and website. Pass any combination of name, addContactIds and removeContactIds; each member change is applied independently, so a partial failure still reports what landed. Members are contactIds from relay_contacts_search. Removing a member only takes them off the roster: it never deletes the contact and never touches past conversations. Returns the updated group.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        groupId: { type: "string", description: "The group's id (grp_...) from relay_groups_list or relay_contacts_search." },
+        name: { type: "string", description: "New display name. Omit to leave the name unchanged." },
+        addContactIds: { type: "array", items: { type: "string" }, description: "contactIds to add to the roster." },
+        removeContactIds: { type: "array", items: { type: "string" }, description: "contactIds to take off the roster." },
+        idempotencyKey: { type: "string" },
+      },
+      required: ["groupId", "idempotencyKey"],
+    },
+  },
+  {
+    name: "relay_group_delete",
+    description:
+      "Delete a Relay contact group. This removes the roster only — every member remains in the human's contact book and past group conversations stay intact — but the group can no longer be addressed as a recipient. Destructive and not undoable: confirm with the human first, and never delete a group they did not explicitly name.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        groupId: { type: "string", description: "The group's id (grp_...) from relay_groups_list." },
+        idempotencyKey: { type: "string" },
+      },
+      required: ["groupId", "idempotencyKey"],
+    },
+  },
   {
     name: "relay_contact_update",
     description:
@@ -501,6 +548,11 @@ export const MESSAGE_ONLY_TOOL_NAMES = new Set([
   "relay_contacts_search",
   "relay_contact_update",
   "relay_groups_list",
+  // Group management is ordinary-messaging functionality (the pill and website
+  // expose it in messages-only mode), so it belongs in this profile too.
+  "relay_group_create",
+  "relay_group_update",
+  "relay_group_delete",
   "relay_inbox_list",
   "relay_thread_fetch",
   "relay_acknowledge",
@@ -558,6 +610,59 @@ export async function handleCall(client, name, args, { mode = DEFAULT_COMPANION_
       return text(await client.searchContacts(args.query));
     case "relay_groups_list":
       return text(await client.groups());
+    case "relay_group_create": {
+      const group = await client.createGroup({ name: args.name });
+      const ids = Array.isArray(args.memberContactIds) ? args.memberContactIds.filter(Boolean) : [];
+      // Members are added one call at a time (the API's own shape). Report per-id
+      // outcomes instead of failing the whole create: a group that exists with
+      // three of four members is a real, recoverable state the agent must see.
+      const added = [];
+      const failed = [];
+      let current = group;
+      for (const contactId of ids) {
+        try {
+          current = await client.addGroupMember(group.id, contactId);
+          added.push(contactId);
+        } catch (err) {
+          failed.push({ contactId, error: err?.message || String(err) });
+        }
+      }
+      return text({ group: current, added, ...(failed.length ? { failed } : {}) });
+    }
+    case "relay_group_update": {
+      const groupId = args.groupId;
+      let current = null;
+      const added = [];
+      const removed = [];
+      const failed = [];
+      if (typeof args.name === "string" && args.name.trim()) {
+        current = await client.renameGroup(groupId, { name: args.name.trim() });
+      }
+      for (const contactId of Array.isArray(args.addContactIds) ? args.addContactIds.filter(Boolean) : []) {
+        try {
+          current = await client.addGroupMember(groupId, contactId);
+          added.push(contactId);
+        } catch (err) {
+          failed.push({ contactId, op: "add", error: err?.message || String(err) });
+        }
+      }
+      for (const contactId of Array.isArray(args.removeContactIds) ? args.removeContactIds.filter(Boolean) : []) {
+        try {
+          current = await client.removeGroupMember(groupId, contactId);
+          removed.push(contactId);
+        } catch (err) {
+          failed.push({ contactId, op: "remove", error: err?.message || String(err) });
+        }
+      }
+      // No-op calls still return the group, so the agent always sees real state.
+      if (!current) {
+        const all = await client.groups();
+        current = (all.groups || []).find((g) => g.id === groupId) || null;
+      }
+      return text({ group: current, added, removed, ...(failed.length ? { failed } : {}) });
+    }
+    case "relay_group_delete":
+      return text(await client.deleteGroup(args.groupId));
     case "relay_contact_update":
       return text(
         await client.updateContact(args.contactId, {