@decentnetwork/lan 0.1.134 → 0.1.136

package/dist/daemon/server.d.ts

@@ -46,6 +46,8 @@ export declare class DaemonServer {
     private readonly activeSends;
     private startedAt;
     private isRunning;
+    private tunRebuildInProgress;
+    private lastTunRebuildMs;
     private statusTimer?;
     private pidFile?;
     private configDir;
@@ -59,6 +61,12 @@ export declare class DaemonServer {
      * del races the kernel (EBUSY) and the respawn leaves the daemon TUN-less.
      */
     private reconfigureTunTo;
+    /** Watch a TUN device for an unexpected `closed` (the helper died — e.g. on
+     *  WSL after "write tun: invalid argument") and rebuild it, so the data plane
+     *  self-heals instead of staying down until a manual restart. Backoff-guarded
+     *  so a helper that keeps dying immediately doesn't tight-loop. */
+    private attachTunRecovery;
+    private rebuildTun;
     start(): Promise<void>;
     stop(): Promise<void>;
     /**

package/dist/daemon/server.js

@@ -82,6 +82,8 @@ export class DaemonServer {
     activeSends = new Map();
     startedAt = 0;
     isRunning = false;
+    tunRebuildInProgress = false;
+    lastTunRebuildMs = 0;
     statusTimer;
     pidFile;
     configDir;
@@ -130,12 +132,56 @@ export class DaemonServer {
             // Re-attach the packet-router's TUN listener — it was bound to the old
             // TunDevice instance.
             this.packetRouter?.swapTunDevice(this.tunDevice);
+            this.attachTunRecovery(this.tunDevice);
             this.logger.info(`TUN now at ${newIp}`);
         }
         catch (err) {
             this.logger.error(`Failed to reconfigure TUN to ${newIp}: ${err instanceof Error ? err.message : err}`);
         }
     }
+    /** Watch a TUN device for an unexpected `closed` (the helper died — e.g. on
+     *  WSL after "write tun: invalid argument") and rebuild it, so the data plane
+     *  self-heals instead of staying down until a manual restart. Backoff-guarded
+     *  so a helper that keeps dying immediately doesn't tight-loop. */
+    attachTunRecovery(device) {
+        if (this.useMockTun)
+            return;
+        device.once("closed", () => {
+            if (!this.isRunning || this.useMockTun)
+                return;
+            const delay = Date.now() - this.lastTunRebuildMs < 10_000 ? 5_000 : 1_000;
+            this.logger.warn(`TUN closed unexpectedly — rebuilding data plane in ${delay}ms`);
+            setTimeout(() => void this.rebuildTun(), delay);
+        });
+    }
+    async rebuildTun() {
+        const rm = this.routeManager;
+        if (!this.isRunning || this.useMockTun || this.tunRebuildInProgress || !this.tunDevice || !rm)
+            return;
+        this.tunRebuildInProgress = true;
+        this.lastTunRebuildMs = Date.now();
+        try {
+            const ip = this.tunDevice.getConfig().ip;
+            const dev = new TunDevice({
+                config: { name: this.config.network.interface, ip, subnet: this.config.network.subnet },
+                mockMode: false,
+            });
+            await dev.open();
+            await rm.configureTun({ ...dev.getConfig(), name: dev.getInterface() });
+            this.tunDevice = dev;
+            this.packetRouter?.swapTunDevice(dev);
+            this.attachTunRecovery(dev);
+            this.logger.info(`TUN rebuilt at ${ip} (data plane recovered)`);
+        }
+        catch (err) {
+            this.logger.error(`TUN rebuild failed: ${err instanceof Error ? err.message : err} — retrying in 5s`);
+            this.tunRebuildInProgress = false;
+            if (this.isRunning)
+                setTimeout(() => void this.rebuildTun(), 5_000);
+            return;
+        }
+        this.tunRebuildInProgress = false;
+    }
     async start() {
         if (this.isRunning) {
             throw new Error("Daemon already running");
@@ -540,6 +586,7 @@ export class DaemonServer {
             // In real mode: helper creates the TUN, then we configure IP + route on it.
             // In mock mode: just open the mock device.
             await this.tunDevice.open();
+            this.attachTunRecovery(this.tunDevice);
             if (!this.useMockTun) {
                 // Use the actual device name from the helper (e.g. utun12 on macOS,
                 // agentnet0 on Linux) — different from the configured name.

package/dist/proxy/multi-exit-router.js

@@ -83,6 +83,10 @@ const HEALTH_TIMEOUT_MS = 4000;
 // of transient jitter on a long-haul path (don't blackout a region on one blip).
 const DOWN_AFTER_FAILS = 3;
 const CONNECT_TIMEOUT_MS = 8000;
+// An exit that carried a real tunnel within this window is treated as healthy
+// regardless of what the synthetic probe says (the probe adds load and flaps on
+// a busy/jittery exit; live traffic is the truth).
+const RECENT_SUCCESS_MS = 10_000;
 /**
  * Start the multi-exit router. Returns a stop() that closes the listener.
  * Runs until stopped (the CLI command keeps the process alive).
@@ -108,6 +112,7 @@ export function startMultiExitRouter(opts) {
         active: 0,
         served: 0,
         lastRtt: null,
+        lastSuccessMs: null,
     }));
     // Per-host routing decision, logged once on first sight so the user can SEE
     // why a hostname went DIRECT vs through a region (e.g. a CCTV video CDN that
@@ -170,6 +175,13 @@ export function startMultiExitRouter(opts) {
                     }
                 }
                 else {
+                    // A probe miss does NOT mark an exit down while real tunnels are still
+                    // succeeding through it — live traffic overrides the synthetic probe.
+                    const liveTraffic = exit.lastSuccessMs !== null && Date.now() - exit.lastSuccessMs < RECENT_SUCCESS_MS;
+                    if (liveTraffic) {
+                        exit.fails = 0;
+                        continue;
+                    }
                     exit.fails++;
                     exit.oks = 0;
                     if (exit.healthy && exit.fails >= DOWN_AFTER_FAILS) {
@@ -184,8 +196,12 @@ export function startMultiExitRouter(opts) {
     }
     // ---- exit selection (scoped to one region) --------------------------------
     function pickOrder(region) {
+        const now = Date.now();
+        // An exit is usable if the probe says healthy OR it carried a real tunnel
+        // recently (live traffic beats a flapping probe).
+        const isUp = (e) => e.healthy || (e.lastSuccessMs !== null && now - e.lastSuccessMs < RECENT_SUCCESS_MS);
         const inRegion = exits.filter((e) => e.region === region);
-        const healthy = inRegion.filter((e) => e.healthy);
+        const healthy = inRegion.filter(isUp);
         // Best-effort fallback: if NO exit currently passes health checks but the
         // region HAS exits, try them anyway instead of 503-ing the user. A single
         // high-latency exit under load makes the probe flap DOWN/UP every few
@@ -230,6 +246,16 @@ export function startMultiExitRouter(opts) {
                 established = true;
                 exit.active++;
                 exit.served++;
+                // Live traffic proves the exit is up — clear any probe-driven failure
+                // and mark it healthy so a flapping probe can't take it DOWN while
+                // tunnels are flowing.
+                exit.lastSuccessMs = Date.now();
+                exit.fails = 0;
+                if (!exit.healthy) {
+                    exit.healthy = true;
+                    log(`✓ ${exit.name} [${exit.region}] UP (live traffic)`);
+                    printPool();
+                }
                 up.setTimeout(0);
                 client.write("HTTP/1.1 200 Connection Established\r\n\r\n");
                 if (head && head.length)

package/dist/tun/tun-device.js

@@ -97,8 +97,11 @@ export class TunDevice extends EventEmitter {
             });
             return;
         }
-        // Real mode: framed write to helper stdin
-        if (!this.helper || !this.helper.stdin) {
+        // Real mode: framed write to helper stdin. Bail out cleanly if the pipe is
+        // gone or no longer writable — throwing here is caught by the router's
+        // try/catch (→ recordDrop "tun-write-failed"), whereas writing into a dead
+        // pipe would emit an async EPIPE 'error' event that crashes the daemon.
+        if (!this.helper || !this.helper.stdin || this.helper.stdin.destroyed || !this.helper.stdin.writable) {
             throw new Error("Helper process not available");
         }
         const lenBuf = Buffer.alloc(4);
@@ -204,6 +207,24 @@ export class TunDevice extends EventEmitter {
                 this.emit("closed");
             }
         });
+        // Error handlers on the process AND its pipes. Without these, an EPIPE when
+        // the helper dies mid-write (observed on WSL: repeated "write tun: invalid
+        // argument" → helper exits → the next TUN write hits a broken stdin) is
+        // emitted as an UNHANDLED 'error' event on the stdin socket and crashes the
+        // entire daemon — taking the TUN and every session down. Catch them: log,
+        // and mark the device closed so the router stops writing (drops with
+        // "tun-down") and the reopen path can rebuild the TUN instead of crashing.
+        const onStreamError = (where) => (err) => {
+            this.logger.warn(`TUN helper ${where} error: ${err.message}`);
+            if (this.isOpen) {
+                this.isOpen = false;
+                this.emit("closed");
+            }
+        };
+        this.helper.on("error", onStreamError("process"));
+        this.helper.stdin.on("error", onStreamError("stdin"));
+        this.helper.stdout.on("error", onStreamError("stdout"));
+        this.helper.stderr.on("error", onStreamError("stderr"));
         this.isOpen = true;
         this.emit("ready");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.134",
+  "version": "0.1.136",
   "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",