@decentnetwork/lan 0.1.135 → 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/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.135",
+  "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",