@decentnetwork/beagle 0.1.91 → 0.1.93

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.91";
+window.__DK_UI_VERSION="0.1.93";
 "use strict";
 (() => {
   // packages/beagle-ui/dist/beagle-ui.js
@@ -2443,7 +2443,7 @@ ${peer.address}`
     const register = () => {
       const l = label.trim();
       if (l)
-        post("/api/ens-register", { name: l, displayName: me.name });
+        post("/api/ens-register", { name: l, displayName: me.name, description: me.description || "" });
     };
     const bind = (chain, address) => post("/api/ens-bind-wallet", { chain, address });
     const bindEth = async () => {

package/dist/server.js

@@ -75,6 +75,73 @@ 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
+ *  bind. Shared by /api/ens-register and /api/set-profile; the two used to
+ *  build it separately, and only register did, which is why a status message
+ *  edited in Profile never reached https://app.beagle.chat/<name>. */
+function ensProfileRecord(identity, name, carried, displayName, description) {
+    return {
+        name,
+        owner: identity.userid,
+        addresses: carried?.addresses ?? {},
+        texts: {
+            ...(carried?.texts ?? {}),
+            description,
+            displayName,
+            carrierAddress: identity.address,
+            carrierUserId: identity.userid,
+        },
+        referee: carried?.referee ?? "",
+        nft: carried?.nft ?? "",
+        nftid: carried?.nftid ?? 0,
+    };
+}
 /** Sign a name record with the Carrier identity and POST it to the gateway.
  *  The record itself (as a JSON string) is what gets signed; the gateway
  *  re-parses `signature.message` and verifies against `owner` inside it. */
@@ -1219,24 +1286,15 @@ export function startBeagleServer(opts) {
                 const mine = existing ?? (await ensFetchJson(`/getAddress/${encodeURIComponent(identity.userid)}`));
                 const carried = mine && mine.owner === identity.userid ? mine : null;
                 const displayName = (typeof body.displayName === "string" && body.displayName.trim().slice(0, 64)) || label;
+                // The description IS the Profile status message. It used to fall
+                // through to "<name>'s Beagle Chat Profile", a placeholder that then
+                // sat on the public page as if the person had written it.
+                const node = (diag.ok ? diag.data?.node : null) ?? {};
                 const description = (typeof body.description === "string" && body.description.trim().slice(0, 200)) ||
+                    (typeof node.statusMessage === "string" && node.statusMessage.trim().slice(0, 200)) ||
                     carried?.texts?.description ||
-                    `${displayName}'s Beagle Chat Profile`;
-                const r = await ensSignAndSet(opts.call, {
-                    name: fullName,
-                    owner: identity.userid,
-                    addresses: carried?.addresses ?? {},
-                    texts: {
-                        ...(carried?.texts ?? {}),
-                        description,
-                        displayName,
-                        carrierAddress: identity.address,
-                        carrierUserId: identity.userid,
-                    },
-                    referee: carried?.referee ?? "",
-                    nft: carried?.nft ?? "",
-                    nftid: carried?.nftid ?? 0,
-                });
+                    "";
+                const r = await ensSignAndSet(opts.call, ensProfileRecord({ userid: identity.userid, address: identity.address }, fullName, carried, displayName, description));
                 sendJson(res, r.ok ? 200 : 502, r.ok ? { ok: true, name: fullName } : { ok: false, error: r.error });
                 return;
             }
@@ -1952,10 +2010,12 @@ 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 online = status === "connected" || status === "online";
                     const realName = typeof f.name === "string" && f.name !== uid ? f.name : undefined;
                     const lm = f.lastMessage;
@@ -1968,10 +2028,12 @@ 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 the SDK status "requested" that the daemon passes through
+                        // (the SDK demotes it the moment the other side proves itself).
+                        // Anything else defaults to established, so the banner can never
+                        // wrongly appear on an old backend.
+                        pending: f.accepted === false || status === "requested",
                         via: online ? viaFromTransport(sess?.transport) : null,
                         ping: null,
                         ip: ipByUserid.get(uid) ?? "",
@@ -1991,11 +2053,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: f.lastSeen ?? stamp?.acceptedAt ?? 0,
+                        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
@@ -2257,6 +2321,31 @@ export function startBeagleServer(opts) {
                 const { name, description, punkId } = await readBody(req);
                 const r = await opts.call({ op: "set-profile", name, description, punkId });
                 sendJson(res, r.ok ? 200 : 400, r);
+                // Also the public record, when this identity registered a beagles.eth
+                // name here: displayName and description on the record ARE the
+                // profile name and status message, and editing them in Profile used
+                // to change only what Carrier advertises, never the page. Best
+                // effort, after the reply: the gateway being down must not turn a
+                // profile save into a failure. A punk-only call (the avatar advertise
+                // on poll) carries neither field and leaves the record alone.
+                if (r.ok && (typeof name === "string" || typeof description === "string")) {
+                    void (async () => {
+                        const diag = await opts.call({ op: "diag" });
+                        const identity = (diag.ok ? diag.data?.identity : null) ?? {};
+                        if (!identity.userid || !identity.address)
+                            return;
+                        const mine = await ensFetchJson(`/getAddress/${encodeURIComponent(identity.userid)}`);
+                        if (!mine || mine.owner !== identity.userid)
+                            return; // not registered here — nothing to sign
+                        const displayName = (typeof name === "string" && name.trim().slice(0, 64)) ||
+                            mine.texts?.displayName ||
+                            mine.name.replace(/\.beagles\.eth$/, "");
+                        const desc = typeof description === "string" ? description.trim().slice(0, 200) : (mine.texts?.description ?? "");
+                        const w = await ensSignAndSet(opts.call, ensProfileRecord({ userid: identity.userid, address: identity.address }, mine.name, mine, displayName, desc));
+                        if (!w.ok)
+                            console.warn(`[ens] profile saved, but the ${mine.name} record was not updated: ${w.error}`);
+                    })().catch((e) => console.warn(`[ens] record update after profile save failed: ${e.message}`));
+                }
                 return;
             }
             if (req.method === "GET" && url === "/api/routes") {

package/package.json

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