@decentnetwork/peer 0.1.24 → 0.1.26

package/dist/compat/express.js

@@ -51,59 +51,71 @@ export class LegacyExpressClient {
         if (!this.#nodes.length) {
             return;
         }
-        let lastTimestamp = 0;
-        const { node, body } = await this.#withAnyNode(async (candidate) => ({
-            node: candidate,
-            body: await this.#http(candidate, "GET", encodeURIComponent(this.#selfUserId))
-        }));
-        const messages = parseExpressResponseFrames(body);
-        if (messages.length > 0) {
-            this.#debugLog(`pullOnce got ${messages.length} offline frame(s) from ${node.host}:${node.port}`);
-        }
-        let requestCount = 0;
-        let messageCount = 0;
-        for (const encrypted of messages) {
-            const plain = decrypt(node.sharedKey, encrypted);
-            if (!plain) {
-                continue;
+        // Pull from EVERY configured relay, not just the first reachable one. A
+        // message lives only on the relay its sender posted it to; with a mixed
+        // fleet (some peers prefer relay A, others B — e.g. during a rollout that
+        // adds a dedicated relay) the recipient must check all relays or it
+        // silently misses anything posted elsewhere. Each relay re-encrypts with
+        // its own per-recipient key, so we decrypt/ack each one independently.
+        for (const node of this.#nodes) {
+            let body;
+            try {
+                body = await this.#http(node, "GET", encodeURIComponent(this.#selfUserId));
+            }
+            catch {
+                continue; // relay unreachable right now — try the next
             }
-            const msg = decodePullMessage(plain);
-            if (!msg) {
+            const messages = parseExpressResponseFrames(body);
+            if (messages.length === 0) {
                 continue;
             }
-            lastTimestamp = Math.max(lastTimestamp, msg.timestamp);
-            if (msg.type === "R") {
-                if (!msg.address || msg.address !== this.#selfAddress) {
-                    this.#debugLog(`drop offline request with unmatched address from ${msg.from}`);
+            this.#debugLog(`pullOnce got ${messages.length} offline frame(s) from ${node.host}:${node.port}`);
+            let lastTimestamp = 0;
+            let requestCount = 0;
+            let messageCount = 0;
+            for (const encrypted of messages) {
+                const plain = decrypt(node.sharedKey, encrypted);
+                if (!plain) {
                     continue;
                 }
-                this.#callbacks.onOfflineFriendRequest(msg.from, msg.payload, msg.timestamp);
-                requestCount += 1;
-                this.#debugLog(`offline friend request from ${msg.from} ts=${msg.timestamp}`);
-            }
-            else if (msg.type === "M") {
-                try {
-                    const friendPk = base58ToBytes(msg.from);
-                    if (friendPk.length !== 32) {
-                        continue;
-                    }
-                    const friendSharedKey = nacl.box.before(friendPk, this.#selfKeyPair.secretKey);
-                    const packet = decrypt(friendSharedKey, msg.payload);
-                    if (!packet) {
+                const msg = decodePullMessage(plain);
+                if (!msg) {
+                    continue;
+                }
+                lastTimestamp = Math.max(lastTimestamp, msg.timestamp);
+                if (msg.type === "R") {
+                    if (!msg.address || msg.address !== this.#selfAddress) {
+                        this.#debugLog(`drop offline request with unmatched address from ${msg.from}`);
                         continue;
                     }
-                    this.#callbacks.onOfflineFriendMessage(msg.from, packet, msg.timestamp);
-                    messageCount += 1;
-                    this.#debugLog(`offline message from ${msg.from} ts=${msg.timestamp}`);
+                    this.#callbacks.onOfflineFriendRequest(msg.from, msg.payload, msg.timestamp);
+                    requestCount += 1;
+                    this.#debugLog(`offline friend request from ${msg.from} ts=${msg.timestamp}`);
                 }
-                catch {
-                    // Skip invalid sender ids.
+                else if (msg.type === "M") {
+                    try {
+                        const friendPk = base58ToBytes(msg.from);
+                        if (friendPk.length !== 32) {
+                            continue;
+                        }
+                        const friendSharedKey = nacl.box.before(friendPk, this.#selfKeyPair.secretKey);
+                        const packet = decrypt(friendSharedKey, msg.payload);
+                        if (!packet) {
+                            continue;
+                        }
+                        this.#callbacks.onOfflineFriendMessage(msg.from, packet, msg.timestamp);
+                        messageCount += 1;
+                        this.#debugLog(`offline message from ${msg.from} ts=${msg.timestamp}`);
+                    }
+                    catch {
+                        // Skip invalid sender ids.
+                    }
                 }
             }
-        }
-        if (lastTimestamp > 0) {
-            this.#debugLog(`pull processed: requests=${requestCount} messages=${messageCount}; ack until ts=${lastTimestamp}`);
-            await this.#deleteUntil(lastTimestamp).catch(() => { });
+            if (lastTimestamp > 0) {
+                this.#debugLog(`pull processed from ${node.host}: requests=${requestCount} messages=${messageCount}; ack until ts=${lastTimestamp}`);
+                await this.#deleteUntilOn(node, lastTimestamp).catch(() => { });
+            }
         }
     }
     async #postEncrypted(to, plainData) {
@@ -113,14 +125,12 @@ export class LegacyExpressClient {
             await this.#http(node, "POST", path, encrypted);
         });
     }
-    async #deleteUntil(timestamp) {
+    async #deleteUntilOn(node, timestamp) {
         const tsBytes = new TextEncoder().encode(String(timestamp));
-        await this.#withAnyNode(async (node) => {
-            const encrypted = encrypt(node.sharedKey, tsBytes);
-            const encoded = bytesToBase58(encrypted);
-            const path = `${encodeURIComponent(this.#selfUserId)}?until=${encodeURIComponent(encoded)}`;
-            await this.#http(node, "DELETE", path);
-        });
+        const encrypted = encrypt(node.sharedKey, tsBytes);
+        const encoded = bytesToBase58(encrypted);
+        const path = `${encodeURIComponent(this.#selfUserId)}?until=${encodeURIComponent(encoded)}`;
+        await this.#http(node, "DELETE", path);
     }
     async #withAnyNode(fn) {
         if (!this.#nodes.length) {

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.24",
+  "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",