@decentnetwork/peer 0.1.25 → 0.1.27

package/dist/peer.js

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile, rename } from "node:fs/promises";
 import { networkInterfaces } from "node:os";
 import { dirname } from "node:path";
 import nacl from "tweetnacl";
@@ -168,6 +168,7 @@ export class Peer {
     #pendingFriendRequests = new Map();
     #friends = new Map();
     #friendStoreFile;
+    #persistSeq = 0; // makes atomic friend-store temp filenames unique per write
     #cookieSymmetricKey;
     #friendSessions = new Map();
     #express;
@@ -610,20 +611,33 @@ export class Peer {
                     errors.push(`${route.node.host}:${route.node.port} ${error.message}`);
                 }
             }
-            if (sent === 0) {
+            // Record locally so the connection loop keeps retrying, then ALWAYS
+            // queue via express — even when every onion send failed. Onion delivery
+            // is unreliable (broken DHT onion-announce), and the old code threw on
+            // `sent === 0` BEFORE this express fallback ran, so a friend-request to
+            // a peer with stale-but-dead onion routes was silently dropped: the node
+            // "sent" it, nothing reached the relay, the recipient never friended
+            // back, and the session could never bridge. That stranded 2nd/3rd exits.
+            this.#recordOutgoingFriendRequest(friendId, pubkey, friendAddress.nospam, hello);
+            let expressOk = false;
+            if (this.#express?.hasNodes()) {
+                try {
+                    await this.#express.sendOfflineFriendRequest(pubkey, appPayload);
+                    expressOk = true;
+                }
+                catch (error) {
+                    this.#debugLog(`offline friend request dispatch failed: ${error.message}`);
+                }
+            }
+            // Only a true failure if BOTH transports got nothing out.
+            if (sent === 0 && !expressOk) {
                 throw new Error(`friend request dispatch failed: ${errors.join("; ")}`);
             }
             this.#lastFriendRequestDispatch = {
-                transport: "onion",
+                transport: sent > 0 ? "onion" : "express",
                 routes: routes.length,
                 targets: sent
             };
-            this.#recordOutgoingFriendRequest(friendId, pubkey, friendAddress.nospam, hello);
-            if (this.#express?.hasNodes()) {
-                void this.#express.sendOfflineFriendRequest(pubkey, appPayload).catch((error) => {
-                    this.#debugLog(`offline friend request dispatch failed: ${error.message}`);
-                });
-            }
         }
         finally {
             resumeSelfAnnounce();
@@ -3892,17 +3906,55 @@ export class Peer {
             }
             this.#debugLog(`loaded ${this.#friends.size} persisted friends`);
         }
-        catch {
-            // Ignore missing/invalid friend store on startup.
+        catch (error) {
+            // A missing file is normal (fresh node). A PARSE error is not — it
+            // means the store is corrupt (historically: concatenated JSON from a
+            // write race, now prevented by atomic persistFriends). Swallowing it
+            // silently left the node with zero friends and unable to register, with
+            // no clue why — so surface it loudly. Try to recover the first valid
+            // JSON array so a corrupt store self-heals instead of stranding the node.
+            const isParse = error instanceof SyntaxError;
+            if (isParse) {
+                try {
+                    const raw = await readFile(this.#friendStoreFile, "utf8");
+                    const end = raw.indexOf("]");
+                    if (end !== -1) {
+                        const recovered = JSON.parse(raw.slice(0, end + 1));
+                        if (Array.isArray(recovered)) {
+                            for (const record of recovered) {
+                                if (record && typeof record.pubkey === "string" && record.pubkey) {
+                                    this.#friends.set(record.pubkey, record);
+                                }
+                            }
+                            // Rewrite cleanly (atomic) so the corruption is gone for good.
+                            this.#persistFriends();
+                        }
+                    }
+                }
+                catch { /* unrecoverable — fall through with whatever we have */ }
+                // eslint-disable-next-line no-console
+                console.error(`[peer] friend store ${this.#friendStoreFile} was corrupt (${error.message}); ` +
+                    `recovered ${this.#friends.size} friend(s).`);
+            }
         }
     }
     #persistFriends() {
         if (!this.#friendStoreFile) {
             return;
         }
+        const file = this.#friendStoreFile;
         const payload = JSON.stringify([...this.#friends.values()], null, 2);
-        void mkdir(dirname(this.#friendStoreFile), { recursive: true })
-            .then(() => writeFile(this.#friendStoreFile, payload, "utf8"))
+        // Write to a unique temp file then atomically rename over the target.
+        // A plain writeFile can interleave when two writers race — observed: the
+        // `agentnet init` friend-request flow (a short-lived standalone peer) and
+        // the daemon both persisting produced a file with two CONCATENATED JSON
+        // arrays, so JSON.parse threw, the loader's catch swallowed it, the node
+        // loaded ZERO friends, and could never sendText/register again. rename()
+        // is atomic on POSIX, so a reader always sees a complete old-or-new file.
+        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 friends failed: ${error.message}`);
         });

package/package.json

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