@decentnetwork/peer 0.1.25 → 0.1.26

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;
@@ -3892,17 +3893,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.26",
   "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",