@decentnetwork/beagle 0.1.92 → 0.1.94

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.92";
+window.__DK_UI_VERSION="0.1.94";
 "use strict";
 (() => {
   // packages/beagle-ui/dist/beagle-ui.js

package/dist/server.js

@@ -75,6 +75,50 @@ async function ensFetchJson(path) {
         clearTimeout(timer);
     }
 }
+/** requestedAt / acceptedAt per friend, read from the SDK's own friend store
+ *  (`<keyFile>.friends.json`, next to the identity). The daemon's friends-list
+ *  reports neither for a request we sent and only acceptedAt (as lastSeen)
+ *  otherwise, so a friend just added had no stamp at all and sorted to the
+ *  bottom — the third time this was reported. The store is the source of
+ *  truth both backends write, and it is a file in our own config dir, so
+ *  read it. Cached by mtime: the list is polled every 2.5s per tab. */
+let friendStampsCache = null;
+function friendStoreStamps(keyFile) {
+    const empty = new Map();
+    if (!keyFile)
+        return empty;
+    const path = `${keyFile}.friends.json`;
+    try {
+        const st = statSync(path);
+        if (friendStampsCache && friendStampsCache.mtimeMs === st.mtimeMs)
+            return friendStampsCache.map;
+        const raw = JSON.parse(readFileSync(path, "utf-8"));
+        const recs = Array.isArray(raw)
+            ? raw
+            : raw && typeof raw === "object" && Array.isArray(raw.friends)
+                ? raw.friends
+                : Object.values(raw ?? {});
+        const map = new Map();
+        for (const r of recs) {
+            if (!r || typeof r !== "object")
+                continue;
+            const id = r.userid || r.pubkey;
+            if (!id)
+                continue;
+            map.set(id, {
+                requestedAt: typeof r.requestedAt === "number" ? r.requestedAt : undefined,
+                acceptedAt: typeof r.acceptedAt === "number" ? r.acceptedAt : undefined,
+            });
+        }
+        friendStampsCache = { mtimeMs: st.mtimeMs, map };
+        return map;
+    }
+    catch {
+        // Unreadable or absent (a fresh install has no friends yet): whatever we
+        // last read, else nothing — the list still renders, just without stamps.
+        return friendStampsCache?.map ?? empty;
+    }
+}
 /** The record beagle writes for its own name: what the profile page shows
  *  (displayName, description) on top of whatever the record already held —
  *  wallet binds, socials, avatar, referee — so a profile edit never strips a
@@ -1966,10 +2010,13 @@ export function startBeagleServer(opts) {
                     beagleVer: beagleVersion(),
                 };
                 const fl = (flist.ok ? (flist.data?.friends ?? []) : []);
+                const stamps = friendStoreStamps(opts.callIce?.keyFile);
                 const peers = fl.map((f) => {
                     const uid = f.userid ?? "";
                     const sess = sessByUserid.get(uid);
                     const status = f.status;
+                    const stamp = stamps.get(uid);
+                    const acceptedAt = f.lastSeen ?? stamp?.acceptedAt ?? 0;
                     const online = status === "connected" || status === "online";
                     const realName = typeof f.name === "string" && f.name !== uid ? f.name : undefined;
                     const lm = f.lastMessage;
@@ -1982,10 +2029,14 @@ export function startBeagleServer(opts) {
                         address: f.address || "",
                         online,
                         // Friendship not yet accepted by the other side. Only trusted when
-                        // the backend states it explicitly (embedded does); a daemon
-                        // backend that doesn't report it defaults to established, so the
-                        // banner can never wrongly appear on an old backend.
-                        pending: f.accepted === false,
+                        // the backend states it explicitly: the embedded host's `accepted`,
+                        // or — on the daemon — SDK status "requested" WITH no acceptedAt.
+                        // Status alone is not enough: the daemon keeps "requested" on a
+                        // friend who accepted but has never connected since, and reading
+                        // it as pending put the waiting banner on 22 of 65 friends.
+                        // Anything else defaults to established, so the banner can never
+                        // wrongly appear on an old backend.
+                        pending: f.accepted === false || (status === "requested" && !acceptedAt),
                         via: online ? viaFromTransport(sess?.transport) : null,
                         ping: null,
                         ip: ipByUserid.get(uid) ?? "",
@@ -2005,11 +2056,13 @@ export function startBeagleServer(opts) {
                         // The sidebar ranks a friend by the newest of these and the last
                         // message, so someone you just accepted — or just added — lands
                         // at the top like a fresh message would, not in a no-history
-                        // group at the bottom. A daemon backend reports only lastSeen
-                        // (its acceptedAt); requestedAt is embedded-only and reads 0
-                        // elsewhere.
-                        acceptedAt: f.lastSeen ?? 0,
-                        requestedAt: f.requestedAt ?? 0,
+                        // group at the bottom. The backend's own fields first; the SDK's
+                        // friend store on disk fills what the backend does not report — a
+                        // daemon backend gives only lastSeen (its acceptedAt) and nothing
+                        // for a request we sent, which left a just-added friend with no
+                        // stamp at all.
+                        acceptedAt,
+                        requestedAt: f.requestedAt ?? stamp?.requestedAt ?? 0,
                         wire: "163",
                         avatarUrl: ensPub.get(uid)?.avatarUrl ?? null,
                         // What they advertised over Carrier wins over the directory: it is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.92",
+  "version": "0.1.94",
   "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",