@decentnetwork/beagle 0.1.6 → 0.1.8

package/dist/call-ice.js

@@ -1,13 +1,10 @@
 // Carrier bootstrap TURN credentials for browser WebRTC.
 //
 // Android online calls use CarrierExtension.getTurnServerInfo() →
-// carrier_get_turn_server(). Prefer @decentnetwork/peer getIceServers() when
-// the installed peer version exports it; otherwise fall back to
-// deriveCarrierTurnCreds via the package dist path (older peer builds).
+// carrier_get_turn_server(). We call @decentnetwork/peer getIceServers()
+// (0.1.136+) with the same credential scheme.
 import { readFileSync, existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { base58ToBytes, carrierIdFromPublicKey } from "@decentnetwork/peer";
+import { carrierIdFromPublicKey, getIceServers } from "@decentnetwork/peer";
 function hexToBytes(hex) {
     const clean = hex.trim().replace(/^0x/i, "");
     if (clean.length % 2 !== 0)
@@ -38,29 +35,11 @@ export async function buildCarrierCallIceServers(opts) {
     if (!nodes.length)
         throw new Error("no bootstrap nodes for TURN");
     const { publicKey, secretKey } = loadKeyPair(opts.keyFile);
-    const userid = carrierIdFromPublicKey(publicKey);
-    const peerRoot = dirname(fileURLToPath(import.meta.resolve("@decentnetwork/peer")));
-    const peerMod = (await import(pathToFileURL(join(peerRoot, "index.js")).href));
-    if (typeof peerMod.getIceServers === "function") {
-        return peerMod.getIceServers({
-            bootstrapNodes: nodes,
-            ourUserid: userid,
-            ourSecretKey: secretKey,
-            limit: opts.limit ?? 3,
-            includeTcpTurn: true,
-        });
-    }
-    const { deriveCarrierTurnCreds } = (await import(pathToFileURL(join(peerRoot, "turn-creds.js")).href));
-    const iceServers = [];
-    for (const n of nodes) {
-        const creds = deriveCarrierTurnCreds({
-            bootnodeHost: n.host,
-            bootnodePublicKey: base58ToBytes(n.pk),
-            ourUserid: userid,
-            ourSecretKey: secretKey,
-        });
-        const base = `${creds.host}:${creds.port}`;
-        iceServers.push({ urls: `stun:${base}`, username: creds.username, credential: creds.password }, { urls: `turn:${base}`, username: creds.username, credential: creds.password }, { urls: `turn:${base}?transport=tcp`, username: creds.username, credential: creds.password });
-    }
-    return iceServers;
+    return getIceServers({
+        bootstrapNodes: nodes,
+        ourUserid: carrierIdFromPublicKey(publicKey),
+        ourSecretKey: secretKey,
+        limit: opts.limit ?? 3,
+        includeTcpTurn: true,
+    });
 }

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.6";
+window.__DK_UI_VERSION="0.1.7";
 const ICON_PATHS = {
   // ---- tab bar (the four must feel like one set) ----
   users: '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',
@@ -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("");
@@ -1964,7 +1964,15 @@ function Msg({ m, peer, T, onTheater, onDelete, onCancel, onRetry, onReveal, onC
         style: { background: "none", border: "none", cursor: "pointer", padding: 0, marginLeft: 2, display: "inline-flex", opacity: 0.55 }
       },
       /* @__PURE__ */ React.createElement(Icon, { name: "trash", size: 11, stroke: 2, color: "var(--faint)" })
-    ), mine && m.status === "queued" ? /* @__PURE__ */ React.createElement("span", { style: { display: "inline-flex", alignItems: "center", gap: 2 }, title: "waiting for peer \u2014 will send when they're online" }, /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--faint)" }), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, T.queued || "queued")) : mine && m.status && /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 12, stroke: 2.2, color: m.status === "read" ? "var(--accent)" : "var(--faint)" })))
+    ), mine && (m.status === "queued" || m.status === "sending") ? /* @__PURE__ */ React.createElement(
+      "span",
+      {
+        style: { display: "inline-flex", alignItems: "center", gap: 2 },
+        title: m.status === "sending" ? "delivering\u2026" : "waiting for peer \u2014 will send when they're online"
+      },
+      /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--faint)" }),
+      /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, m.status === "sending" ? T.sendingMsg || "sending" : T.queued || "queued")
+    ) : mine && m.status && /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 12, stroke: 2.2, color: m.status === "read" ? "var(--accent)" : "var(--faint)" })))
   );
 }
 function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, onSendRtcFile, onAlias, onRemove, onOpenNet, onCall, onReloadThread }) {
@@ -2253,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,
       {
@@ -3466,9 +3485,11 @@ const STR = {
     send: "Send",
     pickPeer: "Select a peer to open the conversation",
     queued: "queued",
+    sendingMsg: "sending",
     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",
@@ -3560,9 +3581,11 @@ const STR = {
     send: "\u53D1\u9001",
     pickPeer: "\u9009\u62E9\u4E00\u4F4D\u597D\u53CB\u5F00\u59CB\u4F1A\u8BDD",
     queued: "\u5F85\u53D1\u9001",
+    sendingMsg: "\u53D1\u9001\u4E2D",
     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

@@ -47,6 +47,10 @@ export class EmbeddedHost {
     #logger = new Logger({ prefix: "Beagle" });
     #opts;
     #events = new EventEmitter();
+    /** Per-peer delivery chains: background sends to one peer run strictly in
+     *  order, so a new message can never overtake an older one whose ACK is
+     *  still pending. Entry removed when the chain drains. */
+    #sendChains = new Map();
     /** Friend requests held for manual accept when auto-accept is off. */
     #pending = new Map();
     /** Inbound call signals waiting for the UI's long-poll to collect them. */
@@ -126,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") });
@@ -308,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,
@@ -368,27 +397,37 @@ export class EmbeddedHost {
                 // user's own words vanish from their own thread — they watched the
                 // peer answer a question that wasn't on screen (INBOX 2026-08-02).
                 // A send failure is a delivery state ON the message, never its absence.
-                const msg = this.#messages.append(uid, "out", text, Date.now());
+                const msg = this.#messages.append(uid, "out", text, Date.now(), "sending");
                 this.#meta.ensure(uid);
                 this.#events.emit("event", { type: "chat", userid: uid, dir: "out" });
-                // Anything already queued for this peer goes first — the new message
-                // must not overtake older ones the moment the path recovers.
-                await this.#flushOutbox(uid).catch(() => { });
-                try {
-                    await this.#node.sendText(uid, text);
-                    this.#messages.setStatus(uid, msg.id, "sent");
-                    return {};
-                }
-                catch (e) {
-                    // Offline peer or failed delivery: same recovery either way — keep
-                    // the message "queued" (the UI shows the clock) and deliver it on
-                    // the friend's reconnect via #flushOutbox. This is a success from
-                    // the caller's side: the store owns the message; only its delivery
-                    // is pending.
-                    this.#logger.info(`send to ${uid.slice(0, 8)} queued: ${e.message}`);
-                    this.#messages.setStatus(uid, msg.id, "queued");
-                    return { queued: true };
-                }
+                // Return NOW. The delivery attempt runs in the background — an ACK
+                // that takes 15s per hop must cost the network 15s, never the user
+                // (INBOX 2026-08-05: a peer that never ACKed made every send block
+                // the UI for 30s, which reads as "stuck" and provokes re-sends).
+                // Per-peer chaining keeps FIFO: anything queued flushes first, and a
+                // second send waits for this one's attempt before its own.
+                const prev = this.#sendChains.get(uid) ?? Promise.resolve();
+                const job = prev.then(async () => {
+                    await this.#flushOutbox(uid).catch(() => { });
+                    try {
+                        await this.#node.sendText(uid, text);
+                        this.#messages.setStatus(uid, msg.id, "sent");
+                    }
+                    catch (e) {
+                        // Offline peer or failed delivery: same recovery either way —
+                        // "queued" (the UI shows the clock) and #flushOutbox delivers it
+                        // on the friend's reconnect. A status update, not a failure.
+                        this.#logger.info(`send to ${uid.slice(0, 8)} queued: ${e.message}`);
+                        this.#messages.setStatus(uid, msg.id, "queued");
+                    }
+                    this.#events.emit("event", { type: "chat", userid: uid, dir: "out" });
+                });
+                this.#sendChains.set(uid, job);
+                void job.finally(() => {
+                    if (this.#sendChains.get(uid) === job)
+                        this.#sendChains.delete(uid);
+                });
+                return {};
             }
             case "chat-log-local":
                 this.#messages.append(uid, req.dir ?? "in", String(req.text ?? ""), Date.now());

package/dist/message-store.d.ts

@@ -14,10 +14,12 @@ export interface ChatMessage {
     ts: number;
     /** Stable per-message id (ts + per-process sequence) for UI keys / dedup. */
     id: string;
-    /** Outgoing-text delivery state. "queued" means the peer was offline when the
-     *  user hit send, so the daemon stored it and will deliver it (in order) the
-     *  moment the friend reconnects. Cleared once actually sent. */
-    status?: "queued" | "sent" | "failed";
+    /** Outgoing-text delivery state. "sending" = the background delivery attempt
+     *  is still running (chat-send returns before the network is consulted, so
+     *  the UI never blocks on a slow peer). "queued" = that attempt gave up; the
+     *  daemon will deliver it (in order) the moment the friend reconnects.
+     *  Cleared once actually sent. */
+    status?: "sending" | "queued" | "sent" | "failed";
     /** How this message traversed the network, for the UI to distinguish at a
      *  glance (different colors). "online" = live net_crypto session (direct/relay);
      *  "offline" = express store-and-forward (the friend or we were offline). Lets
@@ -52,11 +54,15 @@ export declare class MessageStore {
     /** Append a message and schedule a flush. Returns the stored message.
      *  Pass `status: "queued"` for an outgoing text the peer wasn't online to
      *  receive — the daemon flushes it on reconnect. */
-    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "queued" | "sent" | "failed", via?: "online" | "offline"): ChatMessage;
+    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "sending" | "queued" | "sent" | "failed", via?: "online" | "offline"): ChatMessage;
     /** Set (or, with undefined, clear) the delivery status on a text message.
      *  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?: "queued" | "sent" | "failed"): boolean;
+    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

@@ -33,6 +33,11 @@ export class MessageStore {
             let total = 0;
             for (const [peer, msgs] of Object.entries(raw)) {
                 if (Array.isArray(msgs)) {
+                    // A "sending" state cannot survive a restart — the attempt it
+                    // described died with the process. Requeue so #flushOutbox owns it.
+                    for (const m of msgs)
+                        if (m.status === "sending")
+                            m.status = "queued";
                     this.byPeer.set(peer, msgs);
                     total += msgs.length;
                 }
@@ -69,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,7 +1,7 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.6",
-  "description": "Beagle \u2014 P2P chat, file transfer and calls for regular users, on the Decent Network. No admin privilege required.",
+  "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",
   "bin": {
@@ -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"