@decentnetwork/beagle 0.1.126 → 0.1.127

package/dist/cli.js

@@ -173,6 +173,7 @@ async function main() {
         downloadsDir: resolve(args.configDir, "downloads"),
         messagesPath: resolve(args.configDir, "messages.json"),
         servicePeersPath: resolve(args.configDir, "service-peers-local.json"),
+        greetingsPath: resolve(args.configDir, "friend-greetings.json"),
         callIce: {
             keyFile: resolve(decentlanCarrierDir(args.configDir), "keypair.json"),
             bootstrapNodes,

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.126";
+window.__DK_UI_VERSION="0.1.127";
 "use strict";
 (() => {
   // packages/beagle-ui/dist/beagle-ui.js
@@ -272,7 +272,7 @@ window.__DK_UI_VERSION="0.1.126";
     };
     (thread || []).forEach((m, i) => {
       const hit = m && !m.day ? isProto({ text: m.text, dir: m && m.from === "me" ? "out" : "in", ts: m && m.ts }) : false;
-      if (!hit || m && m.file) {
+      if (!hit || m && (m.file || m.kind === "friend-request")) {
         flush();
         out.push(m);
         return;
@@ -529,7 +529,10 @@ window.__DK_UI_VERSION="0.1.126";
       // Brief 30: a validated component form, already whitelisted host-side.
       // Passed through untouched — the renderer treats every string as text,
       // never markup.
-      components: m.components
+      components: m.components,
+      // 'friend-request': the accepted request's greeting, merged in by the
+      // host (beagle's friend-greetings.ts); chat.jsx draws its own bubble.
+      kind: m.kind
     };
   }
   var DK_TAIL_MIN = 30;
@@ -626,8 +629,16 @@ window.__DK_UI_VERSION="0.1.126";
       if (!c)
         return;
       const arr = [...c.byId.values()].sort((a, b) => a.ts - b.ts);
-      const msgs = arr.map(dkThreadMsg);
-      const withDay = msgs.length ? [{ day: dkDayLabel(arr[0].ts) }].concat(msgs) : [];
+      const withDay = [];
+      let lastDay = null;
+      for (const m of arr) {
+        const day = dkDayLabel(m.ts);
+        if (day !== lastDay) {
+          withDay.push({ day });
+          lastDay = day;
+        }
+        withDay.push(dkThreadMsg(m));
+      }
       setThreads((t) => Object.assign({}, t, { [peerId]: withDay }));
       setEarlier((e) => e[peerId] === c.more ? e : Object.assign({}, e, { [peerId]: c.more }));
     }, []);
@@ -1728,6 +1739,25 @@ ${lines}`, { assistant: { kind: "adopt", rows: fresh } }));
       return { kind: "punk", id };
     return { kind: "ens" };
   }
+  var REQUEST_TRANSPORTS = ["lan", "carrier", "direct", "relay", "express", "webrtc", "online", "offline", "tcp", "udp", "p2p"];
+  function unquote(s) {
+    const m = /^"([\s\S]*)"$/.exec(s);
+    return m ? m[1] : s;
+  }
+  function requestGreeting(r) {
+    const hello = r && typeof r.hello === "string" ? r.hello.trim() : "";
+    const via = r && typeof r.via === "string" ? r.via.trim() : "";
+    const isTransport = !!via && REQUEST_TRANSPORTS.includes(via.toLowerCase());
+    const isName = !!via && !!r && typeof r.name === "string" && r.name.trim() === via;
+    return {
+      greeting: hello || (via && !isTransport && !isName ? unquote(via).trim() : ""),
+      transport: isTransport ? via : ""
+    };
+  }
+  var GREETING_KIND = "friend-request";
+  function isGreetingItem(m) {
+    return !!m && m.kind === GREETING_KIND;
+  }
   var DK_CMD_HIST_KEY = "beagle.assistant.history";
   var DK_CMD_HIST_MAX = 50;
   function RequestsBlock({ T, requests, onAct }) {
@@ -1779,7 +1809,7 @@ ${lines}`, { assistant: { kind: "adopt", rows: fresh } }));
       overflow: "hidden",
       textOverflow: "ellipsis",
       whiteSpace: "nowrap"
-    } }, r.name) : /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 12.5, color: "var(--faint)", fontStyle: "italic" } }, T.noName || "no name given"), /* @__PURE__ */ React.createElement(Mono, { size: 11, copy: r.carrier, title: r.carrier }, shortKey(r.carrier, 8, 6)), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)", marginTop: 2 } }, "via ", r.via, " \xB7 ", r.time))), r.descr && /* @__PURE__ */ React.createElement("div", { style: {
+    } }, r.name) : /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 12.5, color: "var(--faint)", fontStyle: "italic" } }, T.noName || "no name given"), /* @__PURE__ */ React.createElement(Mono, { size: 11, copy: r.carrier, title: r.carrier }, shortKey(r.carrier, 8, 6)), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)", marginTop: 2 } }, requestGreeting(r).transport ? "via " + requestGreeting(r).transport + " \xB7 " : "", r.time))), /* @__PURE__ */ React.createElement(DkRequestGreeting, { T, text: requestGreeting(r).greeting }), r.descr && /* @__PURE__ */ React.createElement("div", { style: {
       fontFamily: "var(--ui)",
       fontSize: 12,
       color: "var(--dim, var(--faint))",
@@ -1788,6 +1818,76 @@ ${lines}`, { assistant: { kind: "adopt", rows: fresh } }));
       paddingLeft: 8
     } }, r.descr), failed[r.id] && /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 11, color: "var(--danger)" } }, failed[r.id]), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", gap: 6 } }, /* @__PURE__ */ React.createElement(Btn, { tone: "ok", icon: "check", size: "sm", onClick: () => act(r, "accept"), style: { flex: 1 } }, T.accept), /* @__PURE__ */ React.createElement(Btn, { tone: "danger", icon: "x", size: "sm", onClick: () => act(r, "reject"), style: { flex: 1 } }, T.reject))))));
   }
+  function DkRequestGreeting({ T, text }) {
+    const [open, setOpen] = React.useState(false);
+    const [clipped, setClipped] = React.useState(false);
+    const ref = React.useRef(null);
+    React.useLayoutEffect(() => {
+      const el = ref.current;
+      if (el && !open)
+        setClipped(el.scrollHeight > el.clientHeight + 1);
+    }, [text, open]);
+    if (!text)
+      return null;
+    const toggle = () => {
+      try {
+        const sel = window.getSelection && window.getSelection();
+        if (sel && String(sel).length)
+          return;
+      } catch (e) {
+      }
+      if (clipped || open)
+        setOpen((o) => !o);
+    };
+    return /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        onClick: toggle,
+        title: !open && clipped ? T.showAll || "show all" : void 0,
+        style: { cursor: clipped || open ? "pointer" : "text" }
+      },
+      /* @__PURE__ */ React.createElement("div", { style: { background: "var(--bub-them)", border: "1px solid var(--line)", borderRadius: 8, padding: "6px 9px" } }, /* @__PURE__ */ React.createElement("div", { ref, style: {
+        fontFamily: "var(--ui)",
+        fontSize: 12.5,
+        color: "var(--text)",
+        lineHeight: 1.45,
+        whiteSpace: "pre-wrap",
+        overflowWrap: "anywhere",
+        userSelect: "text",
+        WebkitUserSelect: "text",
+        ...open ? { maxHeight: 240, overflowY: "auto" } : { display: "-webkit-box", WebkitLineClamp: 2, WebkitBoxOrient: "vertical", overflow: "hidden" }
+      } }, text)),
+      (clipped || open) && /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 11, color: "var(--accent)", marginTop: 3 } }, open ? T.showLess || "show less" : T.showAll || "show all")
+    );
+  }
+  function DkGreetingMsg({ m, peer, T }) {
+    return /* @__PURE__ */ React.createElement("div", { style: { display: "flex", justifyContent: "flex-start", alignItems: "flex-end", gap: 8, margin: "3px 0 10px" } }, /* @__PURE__ */ React.createElement(DkAvatar, { peer, size: 24, radius: 6, dot: false }), /* @__PURE__ */ React.createElement("div", { style: {
+      maxWidth: "75%",
+      padding: "8px 12px",
+      borderRadius: 12,
+      borderBottomLeftRadius: 4,
+      background: "var(--panel-2)",
+      border: "1px dashed var(--accent)",
+      color: "var(--text)"
+    } }, /* @__PURE__ */ React.createElement("div", { style: {
+      display: "flex",
+      alignItems: "center",
+      gap: 6,
+      marginBottom: 4,
+      fontFamily: "var(--mono)",
+      fontSize: 10.5,
+      color: "var(--accent)",
+      fontWeight: 600
+    } }, /* @__PURE__ */ React.createElement(Icon, { name: "userPlus", size: 12, stroke: 2.2, color: "var(--accent)" }), /* @__PURE__ */ React.createElement("span", null, T.friendRequestItem || "Friend request"), /* @__PURE__ */ React.createElement("span", { style: { color: "var(--faint)", fontWeight: 400 } }, "\xB7 ", m.time)), /* @__PURE__ */ React.createElement("div", { style: {
+      fontFamily: "var(--ui)",
+      fontSize: 13.5,
+      lineHeight: 1.5,
+      whiteSpace: "pre-wrap",
+      overflowWrap: "anywhere",
+      userSelect: "text",
+      WebkitUserSelect: "text"
+    } }, m.text)));
+  }
   function DkRequestAvatar({ r, size, radius }) {
     const [urlBroken, setUrlBroken] = React.useState(false);
     const url = requestAvatarUrl(r);
@@ -2562,7 +2662,12 @@ ${lines}`, { assistant: { kind: "adopt", rows: fresh } }));
       return null;
     }), err && /* @__PURE__ */ React.createElement("div", { style: { color: "var(--danger, #ff6b6b)", fontSize: 11.5, fontFamily: "var(--mono)" } }, err));
   }
-  function Msg({ m, peer, T, lang, onTheater, onDelete, onCancel, onRetry, onRetryMsg, onReveal, onOpenFile, onCall, onFormSubmit, onNameCard, onAssistantRemove, onAssistantAdopt, answered, selMode, selected, onToggleSel, busy, isGroup }) {
+  function Msg(props) {
+    if (isGreetingItem(props.m))
+      return /* @__PURE__ */ React.createElement(DkGreetingMsg, { m: props.m, peer: props.peer, T: props.T });
+    return /* @__PURE__ */ React.createElement(DkMsgBody, { ...props });
+  }
+  function DkMsgBody({ m, peer, T, lang, onTheater, onDelete, onCancel, onRetry, onRetryMsg, onReveal, onOpenFile, onCall, onFormSubmit, onNameCard, onAssistantRemove, onAssistantAdopt, answered, selMode, selected, onToggleSel, busy, isGroup }) {
     const mine = m.from === "me";
     const nativeMedia = !m.file ? dkNativeMediaFromText(m.text) : null;
     const grp = isGroup && m.dir !== "out" && !m.file && !nativeMedia ? dkGroupParse(m.text) : null;
@@ -6468,6 +6573,9 @@ ${peer.address}`
       dirSearch: "search name / userid\u2026",
       dirLoading: "loading directory\u2026",
       noName: "no name given",
+      friendRequestItem: "Friend request",
+      showAll: "show all",
+      showLess: "show less",
       dirEmpty: "nobody matches",
       dirError: "Could not load the directory:",
       bridgeEmpty: "Nobody else is listed on this bridge yet. You are the first.",
@@ -6667,6 +6775,9 @@ ${peer.address}`
       dirSearch: "\u641C\u7D22\u540D\u5B57 / userid\u2026",
       dirLoading: "\u6B63\u5728\u52A0\u8F7D\u540D\u5355\u2026",
       noName: "\u5BF9\u65B9\u6CA1\u6709\u586B\u540D\u5B57",
+      friendRequestItem: "\u597D\u53CB\u8BF7\u6C42",
+      showAll: "\u5C55\u5F00\u5168\u6587",
+      showLess: "\u6536\u8D77",
       dirEmpty: "\u6CA1\u6709\u5339\u914D\u7684\u4EBA",
       dirError: "\u540D\u5355\u52A0\u8F7D\u5931\u8D25\uFF1A",
       bridgeEmpty: "\u8FD9\u4E2A bridge \u4E0A\u8FD8\u6CA1\u6709\u522B\u4EBA\uFF0C\u4F60\u662F\u7B2C\u4E00\u4E2A\u3002",

package/dist/friend-greetings.d.ts

@@ -0,0 +1,45 @@
+export declare const GREETING_KIND = "friend-request";
+/** One greeting as stored, per friend. */
+export interface StoredGreeting {
+    text: string;
+    /** When the request arrived (ms). The item is dated here, not at accept. */
+    ts: number;
+}
+/** The shape merged into a /api/chat-history page — a raw store record with
+ *  `kind` so beagle-ui draws the distinct bubble. */
+export interface GreetingItem {
+    id: string;
+    dir: "in";
+    text: string;
+    ts: number;
+    kind: typeof GREETING_KIND;
+}
+/** A request's arrival time in ms. The embedded host stores a number, the lan
+ *  daemon an ISO string. Undefined when neither parses. */
+export declare function arrivalMs(v: unknown): number | undefined;
+export declare class GreetingStore {
+    #private;
+    constructor(path: string);
+    /** Keep the greeting of an accepted request. Skips an empty / whitespace
+     *  greeting, and a repeat request carrying the same text (one item per
+     *  request, not one per click). Returns whether an item was added. */
+    record(peer: string, hello: unknown, arrivedAt: unknown, now?: number): boolean;
+    /** The items for one conversation, oldest first. */
+    items(peer: string): GreetingItem[];
+    /** Forget a friend's greetings (friend removed together with the chat). */
+    remove(peer: string): void;
+}
+/** Merge greeting items into one /api/chat-history page (oldest first).
+ *
+ *  A greeting belongs on a page when it is older than `before` (if given)
+ *  and, when the page is full (`limit` records — there are older ones the
+ *  page left out), no older than the page's oldest record; otherwise it is
+ *  shown when the user loads earlier and reaches it. Already-present ids are
+ *  not added twice. Returns a new array. */
+export declare function mergeGreetings<M extends {
+    ts?: number;
+    id?: string;
+}>(page: readonly M[], greetings: readonly GreetingItem[], opts?: {
+    before?: number;
+    limit?: number;
+}): Array<M | GreetingItem>;

package/dist/friend-greetings.js

@@ -0,0 +1,119 @@
+// The greeting a requester typed into a friend request, kept after accept.
+//
+// Before this, the greeting lived only in the pending list: readable while the
+// request was open (and drawn as "via <greeting>"), gone the moment it was
+// accepted. On accept beagle now writes it into that friend's conversation as
+// an incoming "friend request" item, dated at the request time.
+//
+// Local only — nothing is sent. Stored in beagle's own file, not in
+// messages.json: with the daemon backend that file belongs to the agentnet
+// daemon, which holds it in memory and would overwrite anything we wrote.
+// /api/chat-history merges these items into the page it returns, so the
+// daemon's unread counts and last-message preview never see them (spec:
+// not unread, no notification, not the "last message" over newer ones).
+// See decent-hq docs/tasks/TASK-2026-11-04-friend-request-greeting.md.
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+export const GREETING_KIND = "friend-request";
+/** A request's arrival time in ms. The embedded host stores a number, the lan
+ *  daemon an ISO string. Undefined when neither parses. */
+export function arrivalMs(v) {
+    if (typeof v === "number" && Number.isFinite(v) && v > 0)
+        return v;
+    if (typeof v === "string" && v) {
+        const n = Date.parse(v);
+        if (Number.isFinite(n) && n > 0)
+            return n;
+    }
+    return undefined;
+}
+export class GreetingStore {
+    #path;
+    #byPeer = {};
+    constructor(path) {
+        this.#path = path;
+        try {
+            if (existsSync(path)) {
+                const raw = JSON.parse(readFileSync(path, "utf-8"));
+                for (const [peer, list] of Object.entries(raw?.byPeer ?? {})) {
+                    if (!Array.isArray(list))
+                        continue;
+                    const ok = list.filter((g) => !!g && typeof g.text === "string" && typeof g.ts === "number");
+                    if (ok.length)
+                        this.#byPeer[peer] = ok;
+                }
+            }
+        }
+        catch {
+            // A corrupt file loses the greetings, never the chat: start empty.
+            this.#byPeer = {};
+        }
+    }
+    /** Keep the greeting of an accepted request. Skips an empty / whitespace
+     *  greeting, and a repeat request carrying the same text (one item per
+     *  request, not one per click). Returns whether an item was added. */
+    record(peer, hello, arrivedAt, now = Date.now()) {
+        if (!peer || typeof hello !== "string")
+            return false;
+        const text = hello.trim();
+        if (!text)
+            return false;
+        const list = this.#byPeer[peer] ?? [];
+        if (list.some((g) => g.text.trim() === text))
+            return false;
+        list.push({ text, ts: arrivalMs(arrivedAt) ?? now });
+        list.sort((a, b) => a.ts - b.ts);
+        this.#byPeer[peer] = list;
+        this.#save();
+        return true;
+    }
+    /** The items for one conversation, oldest first. */
+    items(peer) {
+        return (this.#byPeer[peer] ?? []).map((g) => ({
+            id: `${GREETING_KIND}:${g.ts}`,
+            dir: "in",
+            text: g.text,
+            ts: g.ts,
+            kind: GREETING_KIND,
+        }));
+    }
+    /** Forget a friend's greetings (friend removed together with the chat). */
+    remove(peer) {
+        if (!this.#byPeer[peer])
+            return;
+        delete this.#byPeer[peer];
+        this.#save();
+    }
+    #save() {
+        try {
+            mkdirSync(dirname(this.#path), { recursive: true });
+            const tmp = `${this.#path}.${process.pid}.tmp`;
+            writeFileSync(tmp, JSON.stringify({ version: 1, byPeer: this.#byPeer }, null, 2), "utf-8");
+            renameSync(tmp, this.#path);
+        }
+        catch {
+            // Not fatal: the greeting stays for this run and the chat is unaffected.
+        }
+    }
+}
+/** Merge greeting items into one /api/chat-history page (oldest first).
+ *
+ *  A greeting belongs on a page when it is older than `before` (if given)
+ *  and, when the page is full (`limit` records — there are older ones the
+ *  page left out), no older than the page's oldest record; otherwise it is
+ *  shown when the user loads earlier and reaches it. Already-present ids are
+ *  not added twice. Returns a new array. */
+export function mergeGreetings(page, greetings, opts = {}) {
+    if (!greetings.length)
+        return page.slice();
+    const full = opts.limit !== undefined && page.length >= opts.limit;
+    const oldest = page.length ? Math.min(...page.map((m) => (typeof m.ts === "number" ? m.ts : Infinity))) : Infinity;
+    const have = new Set(page.map((m) => m.id).filter(Boolean));
+    const add = greetings.filter((g) => !have.has(g.id) &&
+        (opts.before === undefined || g.ts < opts.before) &&
+        (!full || g.ts >= oldest));
+    if (!add.length)
+        return page.slice();
+    // Stable: a greeting sorts before a message with the same timestamp.
+    return [...add, ...page].sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+}

package/dist/pending-requests.d.ts

@@ -26,3 +26,6 @@ export declare function refreshPendingAvatars<E extends {
  *  the same convention as `peers[]` — and the card then falls back to the
  *  beagles.eth lookup and a generated picture. */
 export declare function desktopRequestRow(p: Record<string, unknown>, i: number, fmtTime: (ts?: number) => string): Record<string, unknown>;
+/** The pending entry the UI's Accept refers to: the card's id is the userid,
+ *  or the address when the request carried no userid. */
+export declare function findPending(pending: ReadonlyArray<Record<string, unknown>>, id: unknown): Record<string, unknown> | undefined;

package/dist/pending-requests.js

@@ -60,10 +60,22 @@ export function desktopRequestRow(p, i, fmtTime) {
         // was nothing to decide on.
         name: p.name || "",
         descr: p.descr || "",
-        via: p.hello || "lan",
+        // The greeting the requester typed. It used to ride in `via`, so the card
+        // drew it as "via <greeting>" — mislabeled, and gone after accept.
+        // beagle-ui >= 0.2.36 reads `hello`; for an older UI, `via` stays the
+        // transport word it always fell back to.
+        hello: typeof p.hello === "string" ? p.hello : "",
+        via: p.via || "lan",
         time: fmtTime(p.arrivedAt),
         // The requester's avatar, drawn before accept: URL first, then punk.
         punkId: a.punkId ?? null,
         avatarUrl: a.avatarUrl ?? null,
     };
 }
+/** The pending entry the UI's Accept refers to: the card's id is the userid,
+ *  or the address when the request carried no userid. */
+export function findPending(pending, id) {
+    if (typeof id !== "string" || !id)
+        return undefined;
+    return pending.find((p) => p.userid === id || p.address === id || p.pubkey === id);
+}

package/dist/server.d.ts

@@ -32,6 +32,10 @@ export interface BeagleServerOptions {
      *  service peers on top of the list shipped in the app. Written only by the
      *  Assistant's `/nodes refresh`, and only after the user ticks the rows. */
     servicePeersPath?: string;
+    /** <configDir>/friend-greetings.json — the greetings of accepted friend
+     *  requests, shown as the first item of that chat. Beagle's own file (see
+     *  friend-greetings.ts). Undefined = greetings are not kept. */
+    greetingsPath?: string;
     /** The swappable backend, so the UI can show which one is live and drive the
      *  LAN handoff. Optional: a caller that pins one backend just omits it and
      *  the network panel falls back to "no virtual LAN here". */

package/dist/server.js

@@ -26,7 +26,8 @@ import { bridgeRoster } from "./bridge-roster.js";
 import { isSupervised } from "./relaunch.js";
 import { historyStats } from "./assistant-stats.js";
 import { readFriendStore, pickPunk } from "./friend-store.js";
-import { desktopRequestRow } from "./pending-requests.js";
+import { desktopRequestRow, findPending } from "./pending-requests.js";
+import { GreetingStore, mergeGreetings } from "./friend-greetings.js";
 import { createDiscoverFetch } from "./discover-cache.js";
 import { applyWalletBind } from "@decentnetwork/beagle-ui/wallet-proof";
 import { settleUpload } from "./upload-settle.js";
@@ -947,6 +948,7 @@ export function startBeagleServer(opts) {
     const host = opts.listenHost ?? "127.0.0.1";
     const port = opts.listenPort ?? 8765;
     const log = opts.log ?? ((s) => console.log(s));
+    const greetings = opts.greetingsPath ? new GreetingStore(opts.greetingsPath) : null;
     const sendJson = (res, code, body) => {
         res.writeHead(code, { "content-type": "application/json" });
         res.end(JSON.stringify(body));
@@ -2436,7 +2438,18 @@ export function startBeagleServer(opts) {
                 const bef = Number(q.get("before"));
                 const before = Number.isFinite(bef) && bef > 0 ? bef : undefined;
                 const r = await opts.call({ op: "chat-history", userid: peer, peer, before, limit });
-                sendJson(res, 200, r.ok ? (r.data ?? { chats: {} }) : { chats: {} });
+                const data = (r.ok ? (r.data ?? { chats: {} }) : { chats: {} });
+                // The greeting of the accepted friend request, as the chat's first
+                // item (friend-greetings.ts). Merged here, never written to the
+                // daemon's store, so it is not unread and not the roster preview.
+                if (greetings && peer) {
+                    const items = greetings.items(peer);
+                    if (items.length) {
+                        data.chats = data.chats ?? {};
+                        data.chats[peer] = mergeGreetings(data.chats[peer] ?? [], items, { before, limit });
+                    }
+                }
+                sendJson(res, 200, data);
                 return;
             }
             // Brief 30: submit a rendered form. The values are the user's own input;
@@ -2556,6 +2569,8 @@ export function startBeagleServer(opts) {
             if (req.method === "POST" && url === "/api/friend-remove") {
                 const { userid } = await readBody(req);
                 const r = await opts.call({ op: "friend-remove", userid });
+                if (r.ok)
+                    greetings?.remove(userid);
                 sendJson(res, r.ok ? 200 : 400, r);
                 return;
             }
@@ -2637,7 +2652,21 @@ export function startBeagleServer(opts) {
             }
             if (req.method === "POST" && url === "/api/accept") {
                 const { userid } = await readBody(req);
+                // Read the request BEFORE accepting: accept drops it from pending, and
+                // with it the greeting the requester typed.
+                let entry;
+                if (greetings) {
+                    try {
+                        const pend = await opts.call({ op: "friends-pending" });
+                        if (pend.ok)
+                            entry = findPending(pend.data?.pending ?? [], userid);
+                    }
+                    catch { /* no greeting then; the accept still goes through */ }
+                }
                 const r = await opts.call({ op: "friends-accept", userid });
+                if (r.ok && greetings && entry) {
+                    greetings.record(entry.userid || userid, entry.hello, entry.arrivedAt);
+                }
                 sendJson(res, r.ok ? 200 : 400, r);
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.126",
+  "version": "0.1.127",
   "description": "Beagle — P2P chat, file transfer and calls for regular users, on the Decent Network. No admin privilege required.",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,7 +26,7 @@
     "start": "node dist/cli.js"
   },
   "dependencies": {
-    "@decentnetwork/beagle-ui": "^0.2.35",
+    "@decentnetwork/beagle-ui": "^0.2.36",
     "@decentnetwork/chat-components": "^0.1.3",
     "@decentnetwork/lan": "^0.1.313",
     "@decentnetwork/peer": "^0.1.170",