@decentnetwork/beagle 0.1.54 → 0.1.55

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.54";
+window.__DK_UI_VERSION="0.1.55";
 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"/>',

package/dist/embedded-host.js

@@ -22,9 +22,26 @@ import { acquireIdentityLock } from "./identity-lock.js";
  *  on disk until they reconnect, and an unbounded queue is how you fill a
  *  user's disk by accident. Live transfers have no such limit. */
 const OUTBOX_MAX_FILE_BYTES = 25 * 1024 * 1024;
-/** Native (iOS/Android) clients receive files only as an inline envelope,
- *  which is base64 (~1.34x) inside a 16MB bulkmsg cap. */
+/** 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;
 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
@@ -79,6 +96,27 @@ export class EmbeddedHost {
         this.#messages = new MessageStore(resolve(opts.configDir, "messages.json"));
         this.#meta = new FriendMetaStore(resolve(opts.configDir, "friends-meta.json"));
     }
+    /** Friend-list order: pinned first, then most recent conversation, then
+     *  never-messaged contacts by name. Returns a new array — `friends()`
+     *  hands back the SDK's own list and sorting it in place would reorder
+     *  the friend store as a side effect of merely rendering the sidebar. */
+    #sortForList(friends, last) {
+        const rank = (f) => [
+            this.#meta.get(f.carrierId)?.pinned ? 0 : 1,
+            // Negated so a LARGER timestamp sorts first. No conversation →
+            // MAX_SAFE_INTEGER, which parks those entries after every real one.
+            // Not Infinity: two never-messaged friends would then compare
+            // Infinity - Infinity = NaN, and the tie-break would only still work
+            // by accident of NaN being falsy.
+            last.has(f.carrierId) ? -last.get(f.carrierId).ts : Number.MAX_SAFE_INTEGER,
+            (f.name || f.carrierId).toLowerCase(),
+        ];
+        return [...friends].sort((a, b) => {
+            const [ap, at, an] = rank(a);
+            const [bp, bt, bn] = rank(b);
+            return ap - bp || at - bt || an.localeCompare(bn);
+        });
+    }
     get downloadsDir() {
         return resolve(this.#opts.configDir, "downloads");
     }
@@ -338,7 +376,15 @@ export class EmbeddedHost {
             case "friends-list": {
                 const last = this.#messages.lastMessages();
                 return {
-                    friends: this.#node.friends().map((f) => {
+                    // Most-recent conversation first, pinned above everything. Without
+                    // this the list came out in friend-store insertion order — the
+                    // order contacts were ADDED, which on restart is just the order
+                    // they load from disk. lastMessages() has always been gathered
+                    // "for the friend-list preview/sort"; only the preview half was
+                    // ever wired up, so the sort silently degraded to arbitrary.
+                    // Friends you have never exchanged a message with sort last, by
+                    // name, instead of being scattered through the list.
+                    friends: this.#sortForList(this.#node.friends(), last).map((f) => {
                         const meta = this.#meta.get(f.carrierId);
                         const lastMsg = last.get(f.carrierId);
                         return {
@@ -598,7 +644,11 @@ export class EmbeddedHost {
         // natives as DNFT1 frames inside friend messages (offset acks, FEC,
         // resume; verified 100MB JS→iPad). Only route to inline what fits it.
         const native = this.#node.isNativeFriend(userid);
-        const inlineNative = native && data.length <= INLINE_MAX_BYTES;
+        // 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");
@@ -607,10 +657,10 @@ export class EmbeddedHost {
         const fileId = inlineNative ? null : this.#node.sendFile(userid, new Uint8Array(data), safe);
         if (!fileId) {
             // Native friend, or no transfer slot — the inline envelope path.
-            if (data.length > INLINE_MAX_BYTES) {
+            if (data.length > inlineLimit) {
                 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 ${(INLINE_MAX_BYTES / 1024 / 1024).toFixed(1)} MB).`);
+                    `for the inline fallback (limit ${(inlineLimit / 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
@@ -632,7 +682,8 @@ export class EmbeddedHost {
                 const status = delivery === "acked" ? "sent" : delivery === "offline" ? "queued" : "failed";
                 this.#messages.patchFile(userid, msg.id, { status, sent: delivery === "acked" ? data.length : 0 });
                 this.#events.emit("event", { type: "chat", userid, dir: "out" });
-                this.#logger.info(`inline file "${safe}" (${data.length}B) to ${userid.slice(0, 8)}: delivery=${delivery} → ${status}`);
+                this.#logger.info(`inline file "${safe}" (${data.length}B) to ${userid.slice(0, 8)}: delivery=${delivery} → ${status}` +
+                    (delivery === "accepted" ? " (unconfirmed — the bytes went out and may have arrived, but the peer never acknowledged)" : ""));
             })();
             return { inline: true, name: safe, size: data.length, pending: true };
         }

package/dist/server.js

@@ -1061,11 +1061,28 @@ export function startBeagleServer(opts) {
                 }
                 let destName = safe;
                 let destPath = join(destDir, destName);
+                // Re-sending a file the user already has must not duplicate it.
+                // The -N suffix exists so two DIFFERENT files sharing a name both
+                // survive — but an identical re-send hit it too, so every retry of
+                // the same 52 MB video wrote another full copy (observed: four
+                // byte-identical copies of one file, and a 3.9 GB downloads dir).
+                // Reuse the existing path when the size already matches, so the
+                // upload overwrites that copy instead of growing a new one. Tradeoff:
+                // a different file with the same name AND the same byte count
+                // replaces the older copy rather than sitting beside it — the same
+                // thing any "save to downloads" does, and far better than unbounded
+                // duplication. Hashing instead would mean buffering the whole upload.
+                const uploadSize = Number(req.headers["content-length"] ?? NaN);
                 if (keep) {
                     const dot = safe.lastIndexOf(".");
                     const base = dot > 0 ? safe.slice(0, dot) : safe;
                     const ext = dot > 0 ? safe.slice(dot) : "";
                     for (let i = 1; existsSync(destPath); i++) {
+                        // Same size is a cheap, reliable proxy here: these are the
+                        // sender's own files, not adversarial input, and the full
+                        // compare would mean buffering the upload to hash it.
+                        if (Number.isFinite(uploadSize) && statSync(destPath).size === uploadSize)
+                            break;
                         destName = `${base}-${i}${ext}`;
                         destPath = join(destDir, destName);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.54",
+  "version": "0.1.55",
   "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.281",
+    "@decentnetwork/lan": "^0.1.282",
     "@decentnetwork/peer": "^0.1.141",
     "@decentnetwork/peer-webrtc": "^0.2.16",
     "js-yaml": "^4.1.0",