@decentnetwork/peer 0.1.150 → 0.1.152

package/dist/peer.d.ts

@@ -80,13 +80,31 @@ export declare class Peer {
     };
     addKnownNodes(nodes: NetworkNode[]): void;
     knownNodes(): NetworkNode[];
-    sendFriendRequest(pubkey: string, hello?: string): Promise<void>;
+    /** @param opts.force  Send even when this friend looks already-accepted.
+     *
+     *  The idempotency guard below is right for automatic retries and wrong for
+     *  a person clicking "add". If the other side REJECTED an earlier request,
+     *  their app forgets it — but a net_crypto session may already have been
+     *  established, so this side keeps acceptedAt and skips every later attempt.
+     *  Neither peer is then in the other's friend list and nothing either user
+     *  does can fix it: every add is silently dropped here. A deliberate add has
+     *  to be able to say "I mean it". */
+    sendFriendRequest(pubkey: string, hello?: string, opts?: {
+        force?: boolean;
+    }): Promise<void>;
     lastFriendRequestDispatch(): {
         transport: "onion" | "direct";
         routes: number;
         targets: number;
     } | undefined;
     acceptFriendRequest(pubkey: string): Promise<void>;
+    /** Decline an inbound request.
+     *
+     *  Also drops any friend record and session the request already created.
+     *  Clearing only the pending list left the transport half-attached: the
+     *  sender saw a session, marked us accepted, and its idempotency guard then
+     *  skipped every later attempt — so a rejected peer could never ask again,
+     *  and neither side could see why. */
     rejectFriendRequest(pubkey: string): void;
     /**
      * Drop a friend entirely: tear down any active net_crypto session, forget

package/dist/peer.js

@@ -395,6 +395,7 @@ export class Peer {
     #textHandlers = new Set();
     #pendingTextAcks = new Map();
     #deliveredTextIds = new Set();
+    #deliveredPersistTimer;
     #deliveredTextOrder = [];
     #friendStoreFile;
     #persistSeq = 0; // makes atomic friend-store temp filenames unique per write
@@ -598,6 +599,7 @@ export class Peer {
         }
         this.#cookieSymmetricKey = randomBytes(32);
         await this.#loadPersistedFriends();
+        await this.#loadDeliveredTextIds();
         if (this.#opts.expressNodes && this.#opts.expressNodes.length > 0) {
             this.#express = new LegacyExpressClient({
                 nodes: this.#opts.expressNodes,
@@ -1038,7 +1040,16 @@ export class Peer {
     knownNodes() {
         return [...this.#knownNodes];
     }
-    async sendFriendRequest(pubkey, hello) {
+    /** @param opts.force  Send even when this friend looks already-accepted.
+     *
+     *  The idempotency guard below is right for automatic retries and wrong for
+     *  a person clicking "add". If the other side REJECTED an earlier request,
+     *  their app forgets it — but a net_crypto session may already have been
+     *  established, so this side keeps acceptedAt and skips every later attempt.
+     *  Neither peer is then in the other's friend list and nothing either user
+     *  does can fix it: every add is silently dropped here. A deliberate add has
+     *  to be able to say "I mean it". */
+    async sendFriendRequest(pubkey, hello, opts) {
         if (!this.#keyPair || !this.#announceDataKey) {
             throw new Error("Peer is not started");
         }
@@ -1054,7 +1065,7 @@ export class Peer {
         const friendAddress = parseCarrierAddress(pubkey);
         const friendId = carrierIdFromPublicKey(friendAddress.publicKey);
         const existing = this.#friends.get(friendId);
-        if (existing?.acceptedAt) {
+        if (existing?.acceptedAt && !opts?.force) {
             this.#debugLog(`friend request skipped — ${friendId} already accepted at ${new Date(existing.acceptedAt).toISOString()}`);
             this.#lastFriendRequestDispatch = {
                 transport: "onion",
@@ -1235,8 +1246,17 @@ export class Peer {
             this.#debugLog(`accept friend: initiate session failed for ${pubkey}: ${error.message}`);
         });
     }
+    /** Decline an inbound request.
+     *
+     *  Also drops any friend record and session the request already created.
+     *  Clearing only the pending list left the transport half-attached: the
+     *  sender saw a session, marked us accepted, and its idempotency guard then
+     *  skipped every later attempt — so a rejected peer could never ask again,
+     *  and neither side could see why. */
     rejectFriendRequest(pubkey) {
         this.#pendingFriendRequests.delete(pubkey);
+        if (this.#friends.has(pubkey))
+            this.removeFriend(pubkey);
     }
     /**
      * Drop a friend entirely: tear down any active net_crypto session, forget
@@ -1623,6 +1643,63 @@ export class Peer {
             if (old)
                 this.#deliveredTextIds.delete(old);
         }
+        this.#persistDeliveredTextIds();
+    }
+    /** Where the delivered-id set lives between runs. Next to the friend store,
+     *  because it is the same kind of state: what this node already knows. */
+    get #deliveredStoreFile() {
+        return this.#friendStoreFile ? `${this.#friendStoreFile}.delivered.json` : undefined;
+    }
+    /** Persist the seen delivery ids.
+     *
+     *  In memory only, this set died with the process — and the moment it did,
+     *  every message the sender had retransmitted while we were down was
+     *  accepted as new. Restart the daemon during a conversation and the last
+     *  messages arrive TWICE, which is exactly what a restart-heavy evening
+     *  looked like. The sender is behaving correctly: it never got an ACK, so
+     *  it resent. Remembering is the receiver's job.
+     *
+     *  Debounced: a busy chat would otherwise write the file per message. */
+    #persistDeliveredTextIds() {
+        const file = this.#deliveredStoreFile;
+        if (!file || this.#deliveredPersistTimer)
+            return;
+        this.#deliveredPersistTimer = setTimeout(() => {
+            this.#deliveredPersistTimer = undefined;
+            const payload = JSON.stringify(this.#deliveredTextOrder);
+            const tmp = `${file}.tmp.${process.pid}.${this.#persistSeq++}`;
+            void mkdir(dirname(file), { recursive: true })
+                .then(() => writeFile(tmp, payload, "utf8"))
+                .then(() => rename(tmp, file))
+                .catch((error) => {
+                this.#debugLog(`persist delivered ids failed: ${error.message}`);
+            });
+        }, 1000);
+        this.#deliveredPersistTimer.unref?.();
+    }
+    async #loadDeliveredTextIds() {
+        const file = this.#deliveredStoreFile;
+        if (!file)
+            return;
+        try {
+            const raw = await readFile(file, "utf8");
+            const ids = JSON.parse(raw);
+            if (!Array.isArray(ids))
+                return;
+            for (const id of ids) {
+                if (typeof id !== "string")
+                    continue;
+                if (this.#deliveredTextIds.has(id))
+                    continue;
+                this.#deliveredTextIds.add(id);
+                this.#deliveredTextOrder.push(id);
+            }
+            this.#debugLog(`loaded ${this.#deliveredTextIds.size} delivered text id(s)`);
+        }
+        catch {
+            // Absent or unreadable: start empty. Worst case is the duplicate this
+            // was written to prevent, not a failure to start.
+        }
     }
     /** Files received inline over (bulk)messages — the iOS/C Carrier apps'
      *  native way of sending images/audio online (FileModel JSON envelope). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.150",
+  "version": "0.1.152",
   "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",