@decentnetwork/lan 0.1.74 → 0.1.75

package/dist/daemon/server.d.ts

@@ -51,11 +51,25 @@ export declare class DaemonServer {
      */
     private startPeerStatusSummary;
     getStatus(): DaemonStatus;
+    /** Per-peer timestamp of the last self-heal friend-request re-send, so
+     *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */
+    private reFriendAt;
+    /** How long a friend must stay non-online before we re-send the
+     *  friend-request again. Long enough not to flood express for a roster
+     *  full of genuinely-dead nodes, short enough to recover a wedged but
+     *  live peer in well under a minute. */
+    private static readonly SELF_HEAL_REFRIEND_MS;
     /**
-     * Periodically poke the SDK to (re-)initiate a session with the friend.
-     * This works around the asymmetric friendOnline issue: without this,
-     * one side may never spontaneously try to talk to the other and the
-     * friend stays perpetually offline.
+     * Periodically poke the SDK to (re-)initiate a session with the friend,
+     * and SELF-HEAL a wedged one. `kickSessionEstablishment` is the weak
+     * nudge; for a friend that's accepted but stuck `offline` (the classic
+     * NAT-to-NAT case where one side restarted, or a connection that simply
+     * died and never recovered) it isn't enough. So when a peer stays
+     * non-online, we escalate to re-sending the actual friend-request — the
+     * strong kick that forces a fresh Carrier handshake. This is the
+     * automatic version of `agentnet friend-request <addr>`, so a private or
+     * friend-invited exit recovers on its own instead of needing a human to
+     * run a command (which an invited operator never will).
      */
     private kickSessionForever;
     /**

package/dist/daemon/server.js

@@ -649,16 +649,47 @@ export class DaemonServer {
             activeSessions: this.packetRouter?.getStats().activeSessions || 0,
         };
     }
+    /** Per-peer timestamp of the last self-heal friend-request re-send, so
+     *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */
+    reFriendAt = new Map();
+    /** How long a friend must stay non-online before we re-send the
+     *  friend-request again. Long enough not to flood express for a roster
+     *  full of genuinely-dead nodes, short enough to recover a wedged but
+     *  live peer in well under a minute. */
+    static SELF_HEAL_REFRIEND_MS = 45_000;
     /**
-     * Periodically poke the SDK to (re-)initiate a session with the friend.
-     * This works around the asymmetric friendOnline issue: without this,
-     * one side may never spontaneously try to talk to the other and the
-     * friend stays perpetually offline.
+     * Periodically poke the SDK to (re-)initiate a session with the friend,
+     * and SELF-HEAL a wedged one. `kickSessionEstablishment` is the weak
+     * nudge; for a friend that's accepted but stuck `offline` (the classic
+     * NAT-to-NAT case where one side restarted, or a connection that simply
+     * died and never recovered) it isn't enough. So when a peer stays
+     * non-online, we escalate to re-sending the actual friend-request — the
+     * strong kick that forces a fresh Carrier handshake. This is the
+     * automatic version of `agentnet friend-request <addr>`, so a private or
+     * friend-invited exit recovers on its own instead of needing a human to
+     * run a command (which an invited operator never will).
      */
     async kickSessionForever(carrierId, name) {
         while (this.isRunning) {
             try {
                 await this.peerManager.kickSessionEstablishment(carrierId);
+                const f = this.peerManager
+                    .getFriends()
+                    .find((x) => x.carrierId === carrierId || x.pubkey === carrierId);
+                if (f && f.status === "online") {
+                    // Healthy — clear the timer so a future drop re-heals promptly.
+                    this.reFriendAt.delete(carrierId);
+                }
+                else if (f && f.status !== "online" && f.address) {
+                    const last = this.reFriendAt.get(carrierId) ?? 0;
+                    if (Date.now() - last >= DaemonServer.SELF_HEAL_REFRIEND_MS) {
+                        this.reFriendAt.set(carrierId, Date.now());
+                        this.logger.info(`Self-heal: ${name} is ${f.status} — re-sending friend-request to re-establish the session`);
+                        void this.peerManager
+                            .sendFriendRequest(f.address, "decentlan: self-heal")
+                            .catch((err) => this.logger.debug(`self-heal friend-request ${name}: ${err instanceof Error ? err.message : err}`));
+                    }
+                }
             }
             catch (err) {
                 this.logger.debug(`kickSessionEstablishment ${name}: ${err}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "description": "Private virtual LAN for self-hosted services and AI agents, built on Elastos Carrier. NAT-traversal, name service, ACL, all over a peer-to-peer mesh — no public IP required.",
   "type": "module",
   "main": "./dist/index.js",