@decentnetwork/beagle 0.1.55 → 0.1.57

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.55";
+window.__DK_UI_VERSION="0.1.57";
 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"/>',
@@ -1275,9 +1275,39 @@ Object.assign(window, {
   TweakButton
 });
 function RequestsBlock({ T, requests, onAct }) {
-  if (!requests.length)
+  const [acted, setActed] = React.useState({});
+  const [failed, setFailed] = React.useState({});
+  const act = (r, kind) => {
+    if (acted[r.id])
+      return;
+    setActed((a) => ({ ...a, [r.id]: kind }));
+    setFailed((f) => {
+      const n = { ...f };
+      delete n[r.id];
+      return n;
+    });
+    Promise.resolve(onAct(r.id, kind)).then((res) => {
+      if (res && res.ok === false) {
+        setActed((a) => {
+          const n = { ...a };
+          delete n[r.id];
+          return n;
+        });
+        setFailed((f) => ({ ...f, [r.id]: res.error || "failed" }));
+      }
+    }).catch((e) => {
+      setActed((a) => {
+        const n = { ...a };
+        delete n[r.id];
+        return n;
+      });
+      setFailed((f) => ({ ...f, [r.id]: String(e && e.message || e) }));
+    });
+  };
+  const visible = requests.filter((r) => !acted[r.id]);
+  if (!visible.length)
     return null;
-  return /* @__PURE__ */ React.createElement("div", { style: { padding: "4px 0 8px" } }, /* @__PURE__ */ React.createElement(Section, { label: T.requests, count: requests.length, style: { margin: "4px 4px 8px" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 6 } }, requests.map((r) => /* @__PURE__ */ React.createElement("div", { key: r.id, style: {
+  return /* @__PURE__ */ React.createElement("div", { style: { padding: "4px 0 8px" } }, /* @__PURE__ */ React.createElement(Section, { label: T.requests, count: visible.length, style: { margin: "4px 4px 8px" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 6 } }, visible.map((r) => /* @__PURE__ */ React.createElement("div", { key: r.id, style: {
     padding: "9px 10px",
     borderRadius: 8,
     background: "var(--panel-2)",
@@ -1285,7 +1315,7 @@ function RequestsBlock({ T, requests, onAct }) {
     display: "flex",
     flexDirection: "column",
     gap: 8
-  } }, /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8 } }, /* @__PURE__ */ React.createElement(DkIdenticon, { seed: r.carrier, size: 26, radius: 6 }), /* @__PURE__ */ React.createElement("div", { style: { minWidth: 0, flex: 1 } }, /* @__PURE__ */ React.createElement(Mono, { size: 12, 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))), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", gap: 6 } }, /* @__PURE__ */ React.createElement(Btn, { tone: "ok", icon: "check", size: "sm", onClick: () => onAct(r.id, "accept"), style: { flex: 1 } }, T.accept), /* @__PURE__ */ React.createElement(Btn, { tone: "danger", icon: "x", size: "sm", onClick: () => onAct(r.id, "reject"), style: { flex: 1 } }, T.reject))))));
+  } }, /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 8 } }, /* @__PURE__ */ React.createElement(DkIdenticon, { seed: r.carrier, size: 26, radius: 6 }), /* @__PURE__ */ React.createElement("div", { style: { minWidth: 0, flex: 1 } }, /* @__PURE__ */ React.createElement(Mono, { size: 12, 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))), 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 PeerRow({ peer, T, active, onClick }) {
   const name = peer.alias || peer.userId;
@@ -5031,7 +5061,10 @@ function DkApp() {
   const onAct = (id, kind) => {
     const r = requests.find((x) => x.id === id);
     const uid = r && r.userid || id;
-    (kind === "accept" ? dkApi.accept(uid) : dkApi.reject(uid)).then(data.refresh);
+    return (kind === "accept" ? dkApi.accept(uid) : dkApi.reject(uid)).then((res) => {
+      data.refresh();
+      return res;
+    });
   };
   const onRemove = (peer) => {
     dkApi.remove(peer.id).then(data.refresh);

package/dist/embedded-host.js

@@ -25,23 +25,16 @@ const OUTBOX_MAX_FILE_BYTES = 25 * 1024 * 1024;
 /** Inline envelope ceiling for a JS peer: base64 (~1.34x) inside a 16MB
  *  bulkmsg cap. */
 const INLINE_MAX_BYTES = 11 * 1024 * 1024;
-/** Inline ceiling for a NATIVE (iOS/Android) peer — tiny files only.
- *
- *  History: 11MB (the JS receiver's figure) created a dead band where
- *  multi-MB inline sends died silently in the native kernel (5.2MB failed,
- *  52MB streamed fine); 2.5MB still sat inside the band where the envelope's
- *  only confirmation — the toxcore send window draining — is structurally
- *  unreliable: an 8.5MB envelope is ~11k bulkmsg fragments on a channel with
- *  no congestion control, and three live 8.5MB sends all timed out
- *  unconfirmed at 180s.
- *
- *  Streaming (sendFile → DNFT1 for natives, peer >= 0.1.141) is the path
- *  built for size: offset acks, FEC, resume, and a real delivery verdict
- *  (verified 100MB JS→iPad, sent strictly after the receiver's disk write).
- *  Inline stays only as the one-round-trip shortcut for a thumbnail or a
- *  voice note: at 256KB (~350 fragments) the send window drains in seconds,
- *  so the transport ack actually means something. */
-const INLINE_MAX_BYTES_NATIVE = 256 * 1024;
+/** Native (iOS/Android) peers get NO inline shortcut at any size — they
+ *  stream via sendFile → DNFT1 (peer >= 0.1.141) like everyone else, because
+ *  the inline envelope has no usable confirmation against a native peer:
+ *  protoVersion is structurally 0 (no text-ack), the bare FileModel carries no
+ *  deliveryId to ack, and the transport-ack signal (our send window draining)
+ *  was FIELD-FALSIFIED at every scale — a 282-BYTE single-fragment PNG sat
+ *  unconfirmed for 20s on the same session that streamed 100MB at 0.0% loss.
+ *  Gates of 11MB and 2.5MB and 256KB all just manufactured failed chips for
+ *  files that had actually arrived. DNFT1's contiguous ack is the only true
+ *  delivery signal a native can give; the cost is one offer round trip. */
 const MEDIA_RE = /\.(jpe?g|png|gif|webp|heic|bmp|svg|mp4|mov|m4v|webm|mp3|m4a|wav|aac|ogg|flac)$/i;
 const isMediaFileName = (n) => MEDIA_RE.test(n);
 /** Strip any directory component and characters that would let a peer-supplied
@@ -69,6 +62,7 @@ export class EmbeddedHost {
      *  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();
+    #sweepTimer = null;
     /** Friend requests held for manual accept when auto-accept is off. */
     #pending = new Map();
     /** Inbound call signals as a broadcast ring: every poller reads at its own
@@ -150,6 +144,50 @@ export class EmbeddedHost {
         await this.#node.start();
         await this.#node.join();
         await mkdir(this.downloadsDir, { recursive: true }).catch(() => undefined);
+        // The sweep is what actually makes "queued" resolve.
+        //
+        // Flushing only on the connected EDGE looked right and was not: if the
+        // peer was already connected when the message was queued, that edge had
+        // long since passed and nothing ever tried again — the message sat queued
+        // while the friend showed online. Ask it the other way round on a timer:
+        // who has mail waiting, and can we reach them now. Level-triggered, so a
+        // missed or early event costs one interval instead of the message.
+        this.#sweepTimer = setInterval(() => {
+            if (this.#sweeping)
+                return;
+            this.#sweeping = true;
+            void (async () => {
+                try {
+                    for (const uid of this.#messages.queuedPeers()) {
+                        if (this.#sessionUsable(uid))
+                            await this.#chainFlush(uid);
+                    }
+                }
+                finally {
+                    this.#sweeping = false;
+                }
+            })();
+        }, 8000);
+        this.#sweepTimer.unref?.();
+    }
+    #sweeping = false;
+    /** A session that can actually carry traffic right now. */
+    #sessionUsable(pubkey) {
+        try {
+            const st = this.#node.sessionStatus(pubkey);
+            return !!(st && st.established && (st.udpRemote || st.hasTcpRoute));
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Queue a flush behind whatever that peer already has in flight, so a
+     *  sweep and a send can never interleave and reorder the outbox. */
+    #chainFlush(pubkey) {
+        const prev = this.#sendChains.get(pubkey) ?? Promise.resolve();
+        const job = prev.then(() => this.#flushOutbox(pubkey).catch(() => { }));
+        this.#sendChains.set(pubkey, job.catch(() => { }));
+        return job;
     }
     #wire() {
         this.#node.on("message", (pubkey, text, via) => {
@@ -159,6 +197,9 @@ export class EmbeddedHost {
             this.#messages.append(pubkey, "in", text, Date.now(), undefined, via);
             this.#meta.ensure(pubkey);
             this.#events.emit("event", { type: "chat", userid: pubkey, dir: "in" });
+            // Hearing from them proves the session carries traffic — better
+            // evidence than any status flag, so use it.
+            void this.#chainFlush(pubkey);
         });
         this.#node.on("friend-request", (req) => {
             const userid = req.userid ?? req.pubkey;
@@ -186,15 +227,8 @@ export class EmbeddedHost {
             // 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(() => { }));
-                });
-            }
+            if (e.status === "connected")
+                void this.#chainFlush(e.pubkey); // fast path
         });
         this.#node.on("call-signal", (evt) => {
             this.#callLog.push({
@@ -329,6 +363,10 @@ export class EmbeddedHost {
         return () => this.#events.off("event", fn);
     }
     async stop() {
+        if (this.#sweepTimer) {
+            clearInterval(this.#sweepTimer);
+            this.#sweepTimer = null;
+        }
         // Stop the peer FIRST, then release the lock. The reverse order would open
         // a window where a daemon could start while our peer is still live.
         await this.#node.stop();
@@ -412,16 +450,38 @@ export class EmbeddedHost {
                     }),
                 };
             }
-            case "friend-request":
-                await this.#node.sendFriendRequest(String(req.address ?? ""), req.hello);
+            case "friend-request": {
+                // sendFriendRequest waits for our own announce to store and then walks
+                // the DHT toward the target — tens of seconds is normal. server.ts
+                // already races this with a 2.5s timer so the HTTP layer cannot hang,
+                // but a validation error has to come back fast to be useful, so do the
+                // cheap check here and let the slow part run unattended.
+                const address = String(req.address ?? "");
+                if (!address)
+                    throw new Error("friend-request requires an address");
+                void this.#node
+                    .sendFriendRequest(address, req.hello)
+                    .catch((e) => this.#logger.info(`friend-request to ${address.slice(0, 8)} failed: ${e.message}`));
                 return {};
+            }
             case "friends-pending":
                 return { pending: [...this.#pending.values()] };
             case "friends-accept": {
                 const entry = this.#pending.get(uid);
-                if (entry) {
+                if (!entry)
+                    return {};
+                // Drop it from pending BEFORE the node call, and answer without
+                // waiting on anything the network owns. The request card is rendered
+                // from a poll, so awaiting here left the user clicking Accept with
+                // nothing happening on screen at all — the same class of bug as
+                // chat-send's, which this file already fixed for messages.
+                this.#pending.delete(uid);
+                try {
                     await this.#node.acceptFriendRequest(entry.pubkey);
-                    this.#pending.delete(uid);
+                }
+                catch (e) {
+                    this.#pending.set(uid, entry); // refused: leave state as it was
+                    throw e;
                 }
                 return {};
             }
@@ -638,29 +698,27 @@ export class EmbeddedHost {
             this.#events.emit("event", { type: "chat", userid, dir: "out" });
             return { queued: true, name: safe, size: data.length };
         }
-        // A NATIVE friend (iOS/Android/C Carrier) takes the inline envelope for
-        // small files (single blob, the Beagle apps' own fast path). Larger files
-        // go through the normal sendFile below — peer >= 0.1.141 carries those to
-        // natives as DNFT1 frames inside friend messages (offset acks, FEC,
-        // resume; verified 100MB JS→iPad). Only route to inline what fits it.
+        // Everyone streams — a native friend's packets ride DNFT1 frames inside
+        // friend messages (see the note on the deleted native inline gate above).
         const native = this.#node.isNativeFriend(userid);
-        // Per-peer ceiling: a native receiver's inline limit is far lower than a
-        // JS one's, and using the JS number for both is what created the dead
-        // band (see INLINE_MAX_BYTES_NATIVE).
-        const inlineLimit = native ? INLINE_MAX_BYTES_NATIVE : INLINE_MAX_BYTES;
-        const inlineNative = native && data.length <= inlineLimit;
         const msg = this.#messages.appendFile(userid, "out", { name: safe, size: data.length, status: "sending", sent: 0 });
         if (!msg)
             throw new Error("Could not create file message");
         await mkdir(this.outboxDir, { recursive: true });
         await writeFile(resolve(this.outboxDir, msg.id), data);
-        const fileId = inlineNative ? null : this.#node.sendFile(userid, new Uint8Array(data), safe);
+        const fileId = this.#node.sendFile(userid, new Uint8Array(data), safe);
         if (!fileId) {
-            // Native friend, or no transfer slot — the inline envelope path.
-            if (data.length > inlineLimit) {
+            // No transfer slot. The inline fallback only helps a JS friend (their
+            // text-ack makes it confirmable); to a native it is unconfirmable by
+            // construction, so fail honestly instead.
+            if (native) {
+                this.#messages.patchFile(userid, msg.id, { status: "failed" });
+                throw new Error("No free transfer slot — wait for a current transfer to finish and retry.");
+            }
+            if (data.length > INLINE_MAX_BYTES) {
                 this.#messages.patchFile(userid, msg.id, { status: "failed" });
                 throw new Error(`Could not start the transfer, and the file is too large (${(data.length / 1024 / 1024).toFixed(1)} MB) ` +
-                    `for the inline fallback (limit ${(inlineLimit / 1024 / 1024).toFixed(1)} MB).`);
+                    `for the inline fallback (limit ${(INLINE_MAX_BYTES / 1024 / 1024).toFixed(1)} MB).`);
             }
             // "sent" means the PEER CONFIRMED receipt — nothing less (the fake-sent
             // of INBOX 2026-08-21). And sends are NON-BLOCKING (the 2026-08-05

package/dist/message-store.d.ts

@@ -66,6 +66,9 @@ export declare class MessageStore {
     /** 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. */
+    /** Every peer with outgoing mail still waiting, so the outbox sweep does
+     *  not have to ask per friend. */
+    queuedPeers(): string[];
     queuedOutgoing(peer: string): ChatMessage[];
     /** Append a file-transfer entry (shown as a file chip in the UI). */
     appendFile(peer: string, dir: "in" | "out", file: {

package/dist/message-store.js

@@ -83,6 +83,16 @@ export class MessageStore {
     /** 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. */
+    /** Every peer with outgoing mail still waiting, so the outbox sweep does
+     *  not have to ask per friend. */
+    queuedPeers() {
+        const out = [];
+        for (const [peer, arr] of this.byPeer) {
+            if (arr.some((m) => m.dir === "out" && (m.status === "queued" || m.file?.status === "queued")))
+                out.push(peer);
+        }
+        return out;
+    }
     queuedOutgoing(peer) {
         const arr = this.byPeer.get(peer) ?? [];
         return arr.filter((m) => m.dir === "out" && (m.status === "queued" || m.file?.status === "queued"));

package/dist/server.js

@@ -120,13 +120,43 @@ async function ensSignAndSet(call, record) {
 // nftid=<punk id> on the beagles.eth name. Proxied server-side (browser can't
 // reach the origin's port cross-origin reliably); NOTE the upstream's TLS cert
 // must be valid — renew it when these routes start failing.
-const PUNKS_API_URL = process.env.PUNKS_API_URL || "https://app.beagle.chat:1337";
+// api.beagle.chat/punksapi, NOT app.beagle.chat:1337. That name was repointed
+// to GitHub Pages when the browser client took it over, so this default aimed
+// at a host that serves nothing on 1337 and every punk avatar in the desktop
+// app silently fell back to an identicon. The service itself never moved — it
+// is the same box, now reached through Caddy on 443 instead of its own TLS
+// listener, so there is no second certificate to keep alive.
+// Endpoint of last resort. The real one comes from bgservers.json (punksApi)
+// via punksBase() below, so the host can move without shipping a new build —
+// which is the failure this whole comment exists because of: app.beagle.chat
+// :1337 was baked in here, the name was repointed at GitHub Pages, and every
+// punk avatar in the app quietly became an identicon.
+const PUNKS_API_URL = process.env.PUNKS_API_URL || "https://api.beagle.chat/punksapi";
+const BGSERVERS_URL = process.env.BGSERVERS_URL || "https://beagle.chat/assets/bgservers.json";
+let punksBaseCache = null;
+function punksBase() {
+    if (process.env.PUNKS_API_URL)
+        return Promise.resolve(process.env.PUNKS_API_URL);
+    if (!punksBaseCache) {
+        punksBaseCache = (async () => {
+            try {
+                const cfg = (await fetchDiscoverJson(BGSERVERS_URL));
+                const u = cfg?.punksApi?.[0]?.url;
+                if (typeof u === "string" && u)
+                    return u.replace(/\/+$/, "");
+            }
+            catch { /* fall through to the built-in default */ }
+            return PUNKS_API_URL;
+        })();
+    }
+    return punksBaseCache;
+}
 const punkCache = new Map(); // punk id → JSON; immutable set
 async function punksFetch(path) {
     const ctl = new AbortController();
     const timer = setTimeout(() => ctl.abort(), 10_000);
     try {
-        const r = await fetch(`${PUNKS_API_URL}${path}`, { signal: ctl.signal });
+        const r = await fetch(`${await punksBase()}${path}`, { signal: ctl.signal });
         if (!r.ok)
             throw new Error(`punks upstream ${r.status}`);
         return await r.json();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "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 @@
   },
   "dependencies": {
     "@decentnetwork/chat-components": "^0.1.3",
-    "@decentnetwork/lan": "^0.1.282",
+    "@decentnetwork/lan": "^0.1.283",
     "@decentnetwork/peer": "^0.1.141",
     "@decentnetwork/peer-webrtc": "^0.2.16",
     "js-yaml": "^4.1.0",