@decentnetwork/beagle 0.1.7 → 0.1.8

package/dist/desktop/app.js

@@ -1297,7 +1297,7 @@ function PeerRow({ peer, T, active, onClick }) {
     textOverflow: "ellipsis",
     flex: 1,
     minWidth: 0
-  } }, peer.lastMsg))), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", alignItems: "flex-end", gap: 4, flexShrink: 0 } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)" } }, peer.lastTime), peer.unread ? /* @__PURE__ */ React.createElement(Unread, { n: peer.unread }) : /* @__PURE__ */ React.createElement(StatusDot, { online: peer.online })));
+  } }, peer.lastMsg))), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", alignItems: "flex-end", gap: 4, flexShrink: 0 } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10.5, color: "var(--faint)" } }, peer.lastTime), peer.unread ? /* @__PURE__ */ React.createElement(Unread, { n: peer.unread }) : peer.pending ? /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--warn, #d29922)", title: "friend request pending" }) : /* @__PURE__ */ React.createElement(StatusDot, { online: peer.online })));
 }
 function PeerSidebar({ T, peers, requests, activeId, onSelect, onAct, onAdd, prefillAddr, onPrefillConsumed }) {
   const [q, setQ] = React.useState("");
@@ -2261,6 +2261,17 @@ ${peer.address}`
       setMenu(false);
       onRemove(peer);
     } }))))),
+    peer.pending && /* @__PURE__ */ React.createElement("div", { style: {
+      flexShrink: 0,
+      padding: "7px 16px",
+      display: "flex",
+      alignItems: "center",
+      gap: 8,
+      background: "color-mix(in srgb, #d29922 12%, var(--panel))",
+      borderBottom: "1px solid var(--line)",
+      fontSize: 12.5,
+      color: "var(--text)"
+    } }, /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 13, stroke: 2.2, color: "#d29922" }), /* @__PURE__ */ React.createElement("span", null, T.pendingFriend || "Waiting for them to accept your friend request \u2014 messages will queue and deliver once they do.")),
     /* @__PURE__ */ React.createElement("div", { ref: scrollRef, onScroll: updateFollowScroll, style: { flex: 1, overflow: "auto", padding: "18px 22px" } }, /* @__PURE__ */ React.createElement("div", { style: { maxWidth: 760, margin: "0 auto" } }, thread.filter((m) => m.day || !hidden.has(m.id)).map((m, i) => m.day ? /* @__PURE__ */ React.createElement("div", { key: i, style: { display: "flex", justifyContent: "center", margin: "14px 0" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10.5, fontWeight: 600, color: "var(--faint)", background: "var(--chip)", padding: "3px 10px", borderRadius: 999 } }, m.day)) : /* @__PURE__ */ React.createElement(
       Msg,
       {
@@ -3478,6 +3489,7 @@ const STR = {
     open: "open",
     retry: "Retry",
     cancel: "Cancel",
+    pendingFriend: "Waiting for them to accept your friend request \u2014 messages will queue and deliver once they do.",
     cancelling: "Cancelling\u2026",
     cancelled: "Transfer cancelled",
     retrying: "Retrying\u2026",
@@ -3573,6 +3585,7 @@ const STR = {
     open: "\u6253\u5F00",
     retry: "\u91CD\u8BD5",
     cancel: "\u53D6\u6D88",
+    pendingFriend: "\u7B49\u5F85\u5BF9\u65B9\u63A5\u53D7\u597D\u53CB\u8BF7\u6C42 \u2014 \u6D88\u606F\u4F1A\u5148\u6392\u961F\uFF0C\u5BF9\u65B9\u63A5\u53D7\u540E\u81EA\u52A8\u9001\u8FBE\u3002",
     cancelling: "\u6B63\u5728\u53D6\u6D88\u2026",
     cancelled: "\u5DF2\u53D6\u6D88\u4F20\u8F93",
     retrying: "\u6B63\u5728\u91CD\u8BD5\u2026",

package/dist/embedded-host.js

@@ -130,8 +130,21 @@ export class EmbeddedHost {
         });
         this.#node.on("friend-connection", (e) => {
             this.#events.emit("event", { type: "presence", userid: e.pubkey, status: e.status });
-            if (e.status === "connected")
-                void this.#flushOutbox(e.pubkey);
+            // The connected event can arrive a beat before the session accepts
+            // traffic — observed live: flush at connect said "friend is offline",
+            // and nothing retried until the user's next send, so a queued message
+            // sat visibly stuck despite the peer being online. One delayed retry
+            // covers that gap; the per-send chain and later reconnects cover the
+            // rest.
+            if (e.status === "connected") {
+                void this.#flushOutbox(e.pubkey)
+                    .catch(() => { })
+                    .then(() => {
+                    if (this.#messages.queuedOutgoing(e.pubkey).length === 0)
+                        return;
+                    return new Promise((r) => setTimeout(r, 4000)).then(() => this.#flushOutbox(e.pubkey).catch(() => { }));
+                });
+            }
         });
         this.#node.on("call-signal", (evt) => {
             this.#callQueue.push({ userid: evt.pubkey, data: Buffer.from(evt.data).toString("utf-8") });
@@ -312,6 +325,18 @@ export class EmbeddedHost {
                             alias: meta?.alias,
                             name: meta?.alias || f.name || f.carrierId,
                             status: f.status,
+                            // Shareable Carrier address — the SDK derives it when the
+                            // record lacks one, so this is always populated (peer ≥0.1.138).
+                            address: f.address,
+                            // Friendship established vs merely requested. acceptedAt is the
+                            // SDK's cryptographic proof (session established, or their
+                            // DHT-PK announce); an inbound message is equally conclusive
+                            // and covers records that predate acceptedAt. Without this the
+                            // UI shows a live-looking chat while every send quietly queues
+                            // (INBOX 2026-08-05: 13 messages, zero delivered, no clue why).
+                            accepted: !!f.acceptedAt ||
+                                f.status === "online" ||
+                                this.#messages.hasInbound(f.carrierId),
                             lastSeen: f.acceptedAt,
                             pinned: meta?.pinned ?? false,
                             lastMessage: lastMsg ? { dir: lastMsg.dir, text: lastMsg.text, ts: lastMsg.ts } : undefined,

package/dist/message-store.d.ts

@@ -59,6 +59,10 @@ export declare class MessageStore {
      *  Used to flip a "queued" message to delivered once it's actually sent.
      *  No-op if the id isn't found or is a file entry. Returns true if patched. */
     setStatus(peer: string, id: string, status?: "sending" | "queued" | "sent" | "failed"): boolean;
+    /** Has this peer ever sent us anything? Used as proof-of-friendship for
+     *  records that predate the SDK's acceptedAt bookkeeping — a message can
+     *  only arrive over an established session. */
+    hasInbound(peer: string): boolean;
     /** Outgoing messages still awaiting delivery (peer was offline), oldest
      *  first — both queued text and queued file chips. The daemon drains this
      *  on a friend's reconnect. */

package/dist/message-store.js

@@ -74,6 +74,12 @@ export class MessageStore {
         this.scheduleSave();
         return true;
     }
+    /** Has this peer ever sent us anything? Used as proof-of-friendship for
+     *  records that predate the SDK's acceptedAt bookkeeping — a message can
+     *  only arrive over an established session. */
+    hasInbound(peer) {
+        return (this.byPeer.get(peer) ?? []).some((m) => m.dir === "in");
+    }
     /** Outgoing messages still awaiting delivery (peer was offline), oldest
      *  first — both queued text and queued file chips. The daemon drains this
      *  on a friend's reconnect. */

package/dist/server.js

@@ -20,6 +20,7 @@ import { dirname, join } from "node:path";
 import { INSTALL_COMMAND as LAN_INSTALL_COMMAND } from "./lan-handoff.js";
 import yaml from "js-yaml";
 import { DEFAULT_EXITS } from "./exits.js";
+import * as peerAddr from "@decentnetwork/peer";
 // Directory holding the built desktop UI bundle (index.html, app.js, vendor/).
 // scripts/build-ui.mjs emits it next to this compiled module at dist/ui/desktop/.
 const DESKTOP_DIR = join(dirname(fileURLToPath(import.meta.url)), "desktop");
@@ -690,6 +691,11 @@ export function startBeagleServer(opts) {
                         // another friend (userid only works once already friends).
                         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,
                         via: online ? viaFromTransport(sess?.transport) : null,
                         ping: null,
                         ip: ipByUserid.get(uid) ?? "",
@@ -965,7 +971,18 @@ export function startBeagleServer(opts) {
                 return;
             }
             if (req.method === "POST" && url === "/api/add") {
-                const { address } = await readBody(req);
+                let { address } = await readBody(req);
+                // Accept a 44-char userid too: the address is userid's pubkey plus a
+                // derivable suffix (nospam=0 network-wide + checksum), and users
+                // frequently have only the userid — it's what every other surface
+                // shows. Deriving here beats rejecting with "not an address".
+                try {
+                    const raw = String(address ?? "").trim();
+                    const bytes = peerAddr.base58ToBytes(raw);
+                    if (bytes.length === 32)
+                        address = peerAddr.carrierAddressFromPublicKey(bytes, 0);
+                }
+                catch { /* not base58 — let the backend judge it as-is */ }
                 // A friend-request is fire-and-forget: it's delivered when the peer is
                 // online and only becomes a friend once they accept. Don't let the UI
                 // hang on the network round-trip (DHT lookup / unreachable peer) — kick

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "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",
@@ -27,7 +27,7 @@
   "dependencies": {
     "@decentnetwork/chat-components": "^0.1.3",
     "@decentnetwork/lan": "^0.1.256",
-    "@decentnetwork/peer": "^0.1.136",
+    "@decentnetwork/peer": "^0.1.138",
     "@decentnetwork/peer-webrtc": "^0.2.10",
     "js-yaml": "^4.1.0",
     "yargs": "^17.7.2"