@decentnetwork/peer 0.1.157 → 0.1.159

package/dist/peer.d.ts

@@ -97,7 +97,28 @@ export declare class Peer {
         routes: number;
         targets: number;
     } | undefined;
-    acceptFriendRequest(pubkey: string): Promise<void>;
+    /**
+     * Accept a friend request.
+     *
+     * `#pendingFriendRequests` is an in-memory cache, not the authority on what
+     * was asked. A host that remembers requests across a restart — beagle-web
+     * keeps them in IndexedDB, because a request usually arrives while the tab is
+     * closed — is doing the right thing, and refusing it here made every restored
+     * card permanently un-acceptable: click Accept, the SDK throws "no pending
+     * friend request", the card comes back, and the button reads as dead. That is
+     * the whole of the reported "Accept does not respond" on app.beagle.chat.
+     *
+     * Accepting is the host's decision. Take it, and let the host pass back what
+     * it remembered so the friend does not arrive nameless — anything missing is
+     * filled in by the userinfo exchange once the session comes up.
+     */
+    acceptFriendRequest(pubkey: string, opts?: {
+        name?: string;
+        description?: string;
+        hello?: string;
+        address?: string;
+        nospam?: number;
+    }): Promise<void>;
     /** Decline an inbound request.
      *
      *  Also drops any friend record and session the request already created.

package/dist/peer.js

@@ -103,6 +103,10 @@ const FAULT_REQUEST_HANG = process.env.DECENT_FAULT_REQUEST_HANG === "1";
 // toxcore expires announce entries on roughly this timescale, so a node that
 // acknowledged a store longer ago than this can no longer be counted on.
 const ANNOUNCE_ENTRY_TTL_MS = readEnvInt("DECENT_ANNOUNCE_ENTRY_TTL_MS", 300_000);
+// How long a partial BULKMSG may go with no new fragment before it is
+// abandoned. Refreshed on every fragment, so it bounds a STALLED transfer, not
+// a large one.
+const BULK_ASSEMBLY_IDLE_MS = readEnvInt("DECENT_BULK_ASSEMBLY_IDLE_MS", 60_000);
 const FAULT_ANNOUNCE_HANG_RUN = readEnvInt("DECENT_FAULT_ANNOUNCE_HANG", 0);
 // Classic-DHT maintenance cadence. Every tick we get_nodes toward our own key
 // (so neighbours store our address and native peers can find our UDP endpoint)
@@ -1245,20 +1249,49 @@ export class Peer {
     lastFriendRequestDispatch() {
         return this.#lastFriendRequestDispatch;
     }
-    async acceptFriendRequest(pubkey) {
+    /**
+     * Accept a friend request.
+     *
+     * `#pendingFriendRequests` is an in-memory cache, not the authority on what
+     * was asked. A host that remembers requests across a restart — beagle-web
+     * keeps them in IndexedDB, because a request usually arrives while the tab is
+     * closed — is doing the right thing, and refusing it here made every restored
+     * card permanently un-acceptable: click Accept, the SDK throws "no pending
+     * friend request", the card comes back, and the button reads as dead. That is
+     * the whole of the reported "Accept does not respond" on app.beagle.chat.
+     *
+     * Accepting is the host's decision. Take it, and let the host pass back what
+     * it remembered so the friend does not arrive nameless — anything missing is
+     * filled in by the userinfo exchange once the session comes up.
+     */
+    async acceptFriendRequest(pubkey, opts) {
         const request = this.#pendingFriendRequests.get(pubkey);
-        if (!request) {
-            throw new Error("No pending friend request from this peer");
+        if (!request && !opts) {
+            // No cached request AND the caller told us nothing: it can still be
+            // accepted, but say so, because it means the host is not passing on what
+            // it knows and the friend will start out anonymous.
+            this.#debugLog(`accepting ${pubkey} with no cached request and no details from the host`);
+        }
+        let key;
+        try {
+            key = base58ToBytes(pubkey);
+        }
+        catch {
+            throw new Error(`Not a valid peer key: ${pubkey}`);
         }
+        if (key.length !== 32) {
+            throw new Error(`Not a valid peer key: ${pubkey}`);
+        }
+        const nospam = request?.nospam ?? opts?.nospam ?? 0;
         this.#pendingFriendRequests.delete(pubkey);
         this.#friends.set(pubkey, {
             pubkey,
-            userid: request.userid,
-            address: request.address,
-            nospam: request.nospam,
-            name: request.name,
-            description: request.description,
-            hello: request.hello,
+            userid: request?.userid ?? pubkey,
+            address: request?.address ?? opts?.address ?? carrierAddressFromPublicKey(key, nospam),
+            nospam,
+            name: request?.name ?? opts?.name ?? "",
+            description: request?.description ?? opts?.description ?? "",
+            hello: request?.hello ?? opts?.hello ?? "",
             status: "offline",
             acceptedAt: Date.now()
         });
@@ -4797,10 +4830,25 @@ export class Peer {
      *  lost fragment just expires this one message after 60s, nothing else). */
     #assembleBulkMsg(friendId, frag, packetNumber) {
         const now = Date.now();
-        // Lazy expiry sweep (C uses a 60s assembly timeout).
+        // Lazy expiry sweep. The deadline is IDLE time, not total time.
+        //
+        // It used to be set once, at creation, and never extended — so an assembly
+        // was thrown away 60s after its first fragment no matter how well it was
+        // going. A phone photo is several megabytes; base64 makes it larger still,
+        // and over a TCP relay that takes well over a minute. The transfer was
+        // discarded mid-flight, with every fragment still arriving, and nothing was
+        // logged. Small files were unaffected, which is why this survived testing:
+        // a 300 KB file completes in seconds and never reaches the deadline.
+        //
+        // Idle is the right measure — give up when the SENDER stops, not when the
+        // file is big. Unbounded growth is still prevented by the 16 MB size cap
+        // that totalsz is checked against below.
         for (const [key, entry] of this.#bulkAssembly) {
-            if (entry.expireAtMs < now)
+            if (entry.expireAtMs < now) {
+                this.#debugLog(`bulkmsg ${key} abandoned: no fragment for ${Math.round(BULK_ASSEMBLY_IDLE_MS / 1000)}s ` +
+                    `(had ${entry.got}/${entry.total} bytes)`);
                 this.#bulkAssembly.delete(key);
+            }
         }
         const key = `${friendId}:${frag.tid.toString()}`;
         // A completed assembly is deleted, so a second copy of the same fragments
@@ -4823,7 +4871,7 @@ export class Peer {
         }
         let entry = this.#bulkAssembly.get(key);
         if (!entry) {
-            entry = { total: 0, frags: new Map(), got: 0, expireAtMs: now + 60_000 };
+            entry = { total: 0, frags: new Map(), got: 0, expireAtMs: now + BULK_ASSEMBLY_IDLE_MS };
             this.#bulkAssembly.set(key, entry);
         }
         // The first fragment carries totalsz; it may arrive out of order.
@@ -4837,6 +4885,9 @@ export class Peer {
         }
         // Store by packet number; a duplicate (dual-send) fragment is ignored.
         if (frag.data.length > 0 && !entry.frags.has(packetNumber)) {
+            // Progress: push the idle deadline out. This is what makes the timeout
+            // mean "the sender went away" instead of "the file was too big".
+            entry.expireAtMs = now + BULK_ASSEMBLY_IDLE_MS;
             entry.frags.set(packetNumber, frag.data);
             entry.got += frag.data.length;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.157",
+  "version": "0.1.159",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",