relay-companion 0.1.113 → 0.1.115

package/bin/relay.js

@@ -178,14 +178,37 @@ async function applyInstall({
     const detail = pill.reason ? ` (${pill.reason})` : "";
     console.log(`Could not install Relay pill autostart${detail}. Run \`relay pill\` to open it.`);
   }
+  // Nothing was installed because no agent lives on this machine. This is the
+  // single most likely outcome for someone who was sent a relay and followed the
+  // instructions, and it used to print the skip lines above and exit 0 -- with
+  // the downloadable .command wrapper then adding "Relay is set up." The person
+  // ends up with a paired device, a daemon and a pill, and no way to receive a
+  // relay in an agent, having been told it worked.
+  if (!installed.length) {
+    console.log("");
+    console.log("Relay could not finish: no agent was found on this machine.");
+    console.log("Relay delivers into a coding agent, so it needs one of these installed first:");
+    console.log("  Claude Code  https://claude.com/claude-code");
+    console.log("  Codex        https://developers.openai.com/codex");
+    console.log("Install one, then run this command again.");
+    console.log("");
+    console.log(`In the meantime you can read and reply to your relays on the web: ${absoluteWebTarget("/app/relays")}`);
+    return { installed, missing, daemon, pill, activations, agentMissing: true };
+  }
+
   const liveRequirement = liveToolRequirement({ activations, requiredHosts });
-  if (requireLiveTools && installed.length && !liveRequirement.ok) {
+  if (requireLiveTools && !liveRequirement.ok) {
+    // Registration only takes effect in a NEW agent session, so the session that
+    // ran this command can never report itself ready -- verifyClaudeMcpRegistration
+    // returns currentSessionReady:false on every path by construction. Treating
+    // that as a failure turned a successful install into `exit 1`, and skipped the
+    // open-relay step that is the entire reason the recipient ran this. Say what
+    // to do instead of failing.
     const hostLabel = liveRequirement.missingHosts.length
       ? liveRequirement.missingHosts.join(" and ")
-      : "this running agent session";
-    throw new Error(
-      `Relay paired and installed, but ${hostLabel} cannot call relay_send yet. Setup is not ready in the current agent.`,
-    );
+      : "this agent session";
+    console.log("");
+    console.log(`Relay is installed. Restart ${hostLabel} (or open a new session) to use it.`);
   }
   return { installed, missing, daemon, pill, activations };
 }
@@ -196,7 +219,7 @@ async function cmdSetup(flags) {
   writeConfig({ companionMode: mode });
   await cmdPair(flags, { promptForDefaults: Boolean(flags.interactive) });
   console.log("");
-  await applyInstall({
+  const install = await applyInstall({
     requireLiveTools: Boolean(flags["require-live-tools"]) || shouldRequireLiveTools(),
     requiredHosts: requiredLiveHosts(),
     mode,
@@ -222,6 +245,10 @@ async function cmdSetup(flags) {
       console.log(`Relay ${result.relayId} is staged in the Relay pill.`);
     }
   }
+  // The relay is opened/staged first -- the recipient should still get the thing
+  // they came for -- but setup did not achieve what it claims, so it must not
+  // report success. `exitCode` rather than `exit()` so nothing above is truncated.
+  if (install?.agentMissing) process.exitCode = 1;
 }
 
 /** Install the tools + daemon on a device that is already paired. */

package/overlay/inbox.html

@@ -3557,6 +3557,7 @@
           </span>
         </div>
         <div class="open-actions sv-actions" data-stop="1" role="menu">
+          <button class="oa-item" type="button" role="menuitem" id="svAccount" ${svBusy ? "disabled" : ""}>Account Settings…</button>
           <button class="oa-item oa-primary" type="button" role="menuitem" id="svSwitch" ${svBusy ? "disabled" : ""}>Switch Account…</button>
           <div class="oa-sep" role="separator"></div>
           <button class="oa-item${svSignOutArmed ? " sv-signout-armed" : ""}" type="button" role="menuitem" id="svSignOut" ${svBusy ? "disabled" : ""}>${svSignOutArmed ? "Sign Out — click again to confirm" : "Sign Out"}</button>
@@ -3597,6 +3598,16 @@
     for (const z of settingsViewEl.querySelectorAll('[data-stop="1"]')) {
       z.addEventListener("click", (e) => e.stopPropagation());
     }
+    // Managing addresses lives on the web (Clerk owns verification and the
+    // reverification challenge), so the pill's job is to get you there rather
+    // than to reimplement it. Without this the account panel showed an email the
+    // user had no way to change from the surface they actually live in.
+    const accountEl = document.getElementById("svAccount");
+    if (accountEl) {
+      accountEl.addEventListener("click", () => {
+        if (window.relay.openUrl) window.relay.openUrl("/app/settings");
+      });
+    }
     const switchEl = document.getElementById("svSwitch");
     if (switchEl) switchEl.addEventListener("click", beginPairFlow);
     const signOutEl = document.getElementById("svSignOut");

package/overlay/main.cjs

@@ -96,6 +96,7 @@ const {
   companionModeFromRuntime,
   taskFeaturesAllowed,
 } = require("./mode-policy.cjs");
+const { openingFaceFor, titleFromBody } = require("./message-face.cjs");
 const perf = require("./perf-counters.cjs");
 
 const RELAY_HOME = process.env.RELAY_HOME || process.env.RELAY_COMPANION_HOME || path.join(os.homedir(), ".relay-companion");
@@ -1392,6 +1393,17 @@ function previewPayloadForPacket(packetId) {
     // The thread this message belongs to, so the preview can ask for the
     // conversation around it. A relay that predates threads is its own root.
     threadId: String(row.threadId || id),
+    // A chat message opens IN its conversation; a relay carrying a subject of
+    // its own opens on the reading face. Named fields only — the projector
+    // never spreads a staged row, here or anywhere. See message-face.cjs.
+    openFace: openingFaceFor({
+      threadId: row.threadId || id,
+      title: row.title || row.displayTitle,
+      bodyMarkdown: row.bodyMarkdown,
+      relayNotificationKind: row.relayNotificationKind,
+      taskId: row.taskId,
+      type: row.type,
+    }),
   };
 }
 
@@ -1414,6 +1426,12 @@ function previewPayloadForSent(relayId) {
     unread: false,
     outbound: true,
     threadId: String(item.threadId || id),
+    openFace: openingFaceFor({
+      threadId: item.threadId || id,
+      title: item.title || item.displayTitle,
+      bodyMarkdown: item.bodyMarkdown || item.preview,
+      type: item.type,
+    }),
   };
 }
 
@@ -3071,20 +3089,6 @@ async function previewChat(threadId) {
   }
 }
 
-/**
- * A chat message has a body, not a subject — but a relay carries a title, and
- * the Relays list, notifications and email subjects all read it. Take the first
- * line so a quick reply still looks like something in every one of those.
- */
-function replyTitleFromBody(body) {
-  const first = String(body || "")
-    .split("\n")
-    .map((line) => line.replace(/^\s*[>#*\-\d.]+\s*/, "").trim())
-    .find(Boolean);
-  const title = (first || "Reply").replace(/\s+/g, " ").trim();
-  return title.length > 120 ? `${title.slice(0, 119).trimEnd()}…` : title;
-}
-
 /**
  * Send a reply. The recipient is deliberately left unset: the API addresses a
  * reply to the other party of the message it answers, and fans it out to the
@@ -3106,7 +3110,10 @@ async function sendPreviewReply(input) {
     const client = await relayClient();
     const sent = await client.sendRelay({
       recipient: {},
-      title: replyTitleFromBody(body),
+      // A chat message has a body, not a subject: the first line becomes the
+      // title every Relay surface reads — and is what marks this, when it comes
+      // back, as a line of a conversation rather than a relay to read.
+      title: titleFromBody(body),
       bodyMarkdown: body,
       inReplyToRelayId,
       idempotencyKey,

package/overlay/message-face.cjs

@@ -0,0 +1,110 @@
+"use strict";
+
+/**
+ * Which face the preview window opens on: the single message it was opened
+ * from, or the conversation that message belongs to.
+ *
+ * A relay carries a title. A CHAT MESSAGE does not — every surface that needs a
+ * subject for one (the Relays and Sent lists, notifications, the email subject)
+ * derives it from the first line of what the person typed, in `titleFromBody`
+ * below. So a message whose title says nothing its own body has not already
+ * said has nothing to READ on the message face: it is one line of a
+ * conversation, and it opens IN that conversation. Anything carrying a subject
+ * of its own — an agent's relay, a question, a task — still opens on its own
+ * reading face, with the conversation one click away on the chip.
+ */
+
+/** Staged kinds that are agent or system output, never someone talking. */
+const NON_CHAT_KINDS = new Set([
+  "human_question",
+  "task_request",
+  "task_open",
+  "task_completed",
+  "result",
+  "share_approval",
+  "connector_reauth",
+]);
+
+/** The length a derived title is cut to before it is ellipsised. */
+const TITLE_MAX = 120;
+
+/** The first line that says something, with its Markdown marker stripped. */
+function firstLineOf(body) {
+  return (
+    String(body || "")
+      .split("\n")
+      .map((line) => line.replace(/^\s*[>#*\-\d.]+\s*/, "").trim())
+      .find(Boolean) || ""
+  );
+}
+
+/**
+ * A chat message has a body, not a subject — but a relay carries a title that
+ * Relay's lists, notifications and email subjects all read. Use the first line
+ * so a conversational message still reads as something in every one of those.
+ * This is the derivation that WRITES those titles; the recogniser below reads
+ * them back, and they live together so they cannot drift apart.
+ */
+function titleFromBody(body) {
+  const title = (firstLineOf(body) || "Reply").replace(/\s+/g, " ").trim();
+  return title.length > TITLE_MAX ? `${title.slice(0, TITLE_MAX - 1).trimEnd()}…` : title;
+}
+
+function normalize(value) {
+  return String(value == null ? "" : value)
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+/**
+ * Does this title say anything the body's first line does not? Compared
+ * loosely on purpose: a derived title is cut at TITLE_MAX while the line it
+ * came from keeps going, so a long single-line message is recognised by its
+ * stem. The stem has to be substantial before a prefix counts — a two-word
+ * subject that happens to start a longer sentence is a real subject.
+ */
+function titleIsJustTheFirstLine(title, body) {
+  const lead = normalize(firstLineOf(body));
+  if (!lead) return false; // no body to speak for itself
+  const subject = normalize(title);
+  if (!subject) return true; // nothing but a body
+  if (subject === lead) return true;
+  const stem = subject.replace(/…+$/, "").trim();
+  return stem.length >= 24 && lead.startsWith(stem);
+}
+
+/** Is this relay one line of a conversation rather than something to read? */
+function isChatMessage(row = {}) {
+  const kind = String((row && row.relayNotificationKind) || "")
+    .trim()
+    .toLowerCase();
+  if (NON_CHAT_KINDS.has(kind)) return false;
+  // A relay attached to a task, or one an agent marked as a question or a
+  // completion, is that agent's output — it belongs on the reading face.
+  if (row && row.taskId) return false;
+  const type = String((row && row.type) || "")
+    .trim()
+    .toLowerCase();
+  if (type === "question" || type === "completion") return false;
+  return titleIsJustTheFirstLine((row && (row.title || row.displayTitle)) || "", row && row.bodyMarkdown);
+}
+
+/**
+ * "chat" opens in the conversation; "message" opens on the reading face. A
+ * message with no conversation to open into always gets the reading face.
+ */
+function openingFaceFor(row = {}) {
+  if (!String((row && row.threadId) || "").trim()) return "message";
+  return isChatMessage(row) ? "chat" : "message";
+}
+
+module.exports = {
+  NON_CHAT_KINDS,
+  TITLE_MAX,
+  firstLineOf,
+  isChatMessage,
+  openingFaceFor,
+  titleFromBody,
+  titleIsJustTheFirstLine,
+};

package/overlay/preview-renderer.js

@@ -45,6 +45,8 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
   let content = {};
   /** The loaded conversation this message belongs to, or null. */
   let chat = null;
+  /** Has the reader already been placed in this conversation once? */
+  let landed = false;
   let face = "message";
   let sending = false;
   /** Replies shown before the server has confirmed them. */
@@ -155,7 +157,9 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
   }
 
   function composerPlaceholder() {
-    if (face === "chat" && chat) return `Message ${text(chat.title) || "this conversation"}…`;
+    if (face === "chat") {
+      return `Message ${text(chat && chat.title) || chatTitleHint(content) || "this conversation"}…`;
+    }
     const who = text(content.senderName).replace(/^You → /, "");
     return who && !content.outbound ? `Reply to ${who.split(" ")[0]}…` : "Write a reply…";
   }
@@ -199,19 +203,60 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
     headChatEl.classList.toggle("gone", !onChat);
     faceMessageEl.setAttribute("aria-hidden", onChat ? "true" : "false");
     faceChatEl.setAttribute("aria-hidden", onChat ? "false" : "true");
-    if (onChat) {
-      renderChat();
-      scrollChatToLatest();
-    }
+    if (onChat) paintChat();
     refreshComposer();
   }
 
+  /**
+   * Show the conversation, and put the reader where they belong in it: on the
+   * message they came in on the first time, at the live end after that.
+   */
+  function paintChat({ stick = true } = {}) {
+    renderChat();
+    if (!chat) return; // still loading — the load will place them
+    if (landed) {
+      if (stick) scrollChatToLatest();
+      return;
+    }
+    landed = true;
+    scrollChatToOpened();
+  }
+
   function scrollChatToLatest() {
     requestAnimationFrame(() => {
       chatScrollEl.scrollTop = chatScrollEl.scrollHeight;
     });
   }
 
+  const cssEscape = (value) =>
+    typeof CSS !== "undefined" && CSS.escape ? CSS.escape(value) : String(value).replace(/["\\]/g, "\\$&");
+
+  /**
+   * Land on the message the window was opened from. Opening a text message
+   * three days old should not drop the reader at the bottom of a conversation
+   * that has moved on since — but the newest message belongs where a
+   * conversation always sits, at the end.
+   *
+   * Centred by moving THIS scroller and nothing else. scrollIntoView is wrong
+   * here: it scrolls every scrollable ancestor, and the faces track is one of
+   * them (overflow:hidden still scrolls programmatically), so it slid the whole
+   * conversation sideways out of the window while every DOM check still passed.
+   */
+  function scrollChatToOpened() {
+    const id = text(content.relayId);
+    const target = id ? chatListEl.querySelector(`.bubble-row[data-relay-id="${cssEscape(id)}"]`) : null;
+    if (!target || !target.nextElementSibling) {
+      scrollChatToLatest();
+      return;
+    }
+    requestAnimationFrame(() => {
+      if (!target.isConnected) return;
+      const view = chatScrollEl.getBoundingClientRect();
+      const row = target.getBoundingClientRect();
+      chatScrollEl.scrollTop += row.top + row.height / 2 - (view.top + view.height / 2);
+    });
+  }
+
   function nearChatBottom() {
     return chatScrollEl.scrollHeight - chatScrollEl.scrollTop - chatScrollEl.clientHeight < 90;
   }
@@ -228,6 +273,8 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
     if (!threadId) {
       chat = null;
       updateChip();
+      // Nothing to open into: never strand the reader on an empty conversation.
+      if (face === "chat") showFace("message");
       return;
     }
     let result;
@@ -247,7 +294,13 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
       }
       chat = null;
       updateChip();
-      if (face === "chat") renderChatState(result && result.error, true);
+      // A message that opened straight into its conversation has nowhere to sit
+      // if that conversation will not load. Give the reader back the message
+      // they clicked, with the reason on the composer's note line.
+      if (face === "chat") {
+        showFace("message");
+        setNote(text(result && result.error) || "Could not open this conversation.", true);
+      }
       return;
     }
     chat = result.chat || null;
@@ -258,11 +311,7 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
     // the server accepted is retired here by its own local id instead.
     outgoing = outgoing.filter((o) => o.state !== "sent");
     updateChip();
-    if (face === "chat") {
-      const stick = keepScroll ? nearChatBottom() : true;
-      renderChat();
-      if (stick) scrollChatToLatest();
-    }
+    if (face === "chat") paintChat({ stick: keepScroll ? nearChatBottom() : true });
     refreshComposer();
   }
 
@@ -276,6 +325,17 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
     return `p${hash % 8}`;
   }
 
+  /**
+   * Who the conversation is with, read off the message alone. Shown while the
+   * chat loads so a window that opens straight into a conversation names it
+   * from the first frame instead of saying "Conversation" and then changing.
+   */
+  function chatTitleHint(row) {
+    return text(row && row.senderName)
+      .replace(/^From\s+/i, "")
+      .replace(/^You\s*→\s*/, "");
+  }
+
   function renderChatState(message, isError) {
     chatListEl.replaceChildren();
     chatStateEl.textContent = text(message) || "No messages here yet.";
@@ -304,6 +364,8 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
   function buildBubble(entry, { showAuthor, lastOfRun, firstOfRun }) {
     const row = document.createElement("div");
     row.className = `bubble-row ${entry.mine ? "mine" : "theirs"}`;
+    // Named so the conversation can be scrolled to one particular message.
+    if (entry.relayId) row.dataset.relayId = entry.relayId;
     if (firstOfRun) row.classList.add("first-of-run");
     if (lastOfRun) row.classList.add("last-of-run");
     if (entry.unread) row.classList.add("unread");
@@ -638,11 +700,17 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
     chat = null;
     outgoing = [];
     expanded.clear();
+    landed = false;
     chatRevision += 1;
     updateChip();
-    // A new message always opens on the message face, whichever face the reader
-    // left the last one on.
-    showFace("message", { force: true });
+    // A new message opens on the face its own content earns, whichever face the
+    // reader left the last one on: a chat message opens IN its conversation —
+    // there is nothing on the reading face the conversation does not already
+    // show — and everything else opens on the message itself. main decides;
+    // see message-face.cjs.
+    const opensInChat = text(row.openFace) === "chat" && Boolean(text(row.threadId));
+    if (opensInChat) chatNameEl.textContent = chatTitleHint(row) || "Conversation";
+    showFace(opensInChat ? "chat" : "message", { force: true });
     setNote("");
     refreshComposer();
 

package/package.json

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