@decentnetwork/lan 0.1.81 → 0.1.83

package/dist/daemon/server.d.ts

@@ -42,6 +42,15 @@ export declare class DaemonServer {
     private pidFile?;
     private configDir;
     constructor(opts: DaemonOptions);
+    /**
+     * Swap the live TUN to a new IP without restarting the daemon. Called when
+     * dora's background registration allocates an IP different from the
+     * deterministic fallback the TUN started on. Idempotent (no-op if already at
+     * newIp). ORDER MATTERS: close the TunDevice FIRST so the helper subprocess
+     * exits and releases the device — otherwise routeManager.cleanup's tuntap
+     * del races the kernel (EBUSY) and the respawn leaves the daemon TUN-less.
+     */
+    private reconfigureTunTo;
     start(): Promise<void>;
     stop(): Promise<void>;
     /**

package/dist/daemon/server.js

@@ -66,6 +66,49 @@ export class DaemonServer {
         this.configDir = opts.configDir ?? ConfigLoader.defaultConfigDir();
         this.logger = new Logger({ prefix: "Daemon" });
     }
+    /**
+     * Swap the live TUN to a new IP without restarting the daemon. Called when
+     * dora's background registration allocates an IP different from the
+     * deterministic fallback the TUN started on. Idempotent (no-op if already at
+     * newIp). ORDER MATTERS: close the TunDevice FIRST so the helper subprocess
+     * exits and releases the device — otherwise routeManager.cleanup's tuntap
+     * del races the kernel (EBUSY) and the respawn leaves the daemon TUN-less.
+     */
+    async reconfigureTunTo(newIp) {
+        if (!this.tunDevice || !this.routeManager)
+            return;
+        const currentIp = this.tunDevice.getConfig().ip;
+        if (currentIp === newIp)
+            return;
+        this.logger.info(`Reconfiguring TUN: allocated IP changed ${currentIp} -> ${newIp}`);
+        const ifname = this.tunDevice.getInterface();
+        try {
+            await this.tunDevice.close();
+            await this.routeManager.cleanup(ifname, this.config.network.subnet, currentIp);
+            this.tunDevice = new TunDevice({
+                config: {
+                    name: this.config.network.interface,
+                    ip: newIp,
+                    subnet: this.config.network.subnet,
+                },
+                mockMode: this.useMockTun,
+            });
+            await this.tunDevice.open();
+            if (!this.useMockTun) {
+                await this.routeManager.configureTun({
+                    ...this.tunDevice.getConfig(),
+                    name: this.tunDevice.getInterface(),
+                });
+            }
+            // Re-attach the packet-router's TUN listener — it was bound to the old
+            // TunDevice instance.
+            this.packetRouter?.swapTunDevice(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}`);
+        }
+    }
     async start() {
         if (this.isRunning) {
             throw new Error("Daemon already running");
@@ -340,56 +383,20 @@ export class DaemonServer {
                     // at 10.86.1.15 — other peers route to .15, our kernel
                     // doesn't recognize it as local, packets drop. Rebuild
                     // the TUN at the new IP so traffic actually reaches us.
-                    onAllocatedIpChanged: async (newIp) => {
-                        if (!this.tunDevice || !this.routeManager)
-                            return;
-                        const currentIp = this.tunDevice.getConfig().ip;
-                        if (currentIp === newIp)
-                            return;
-                        this.logger.info(`Reconfiguring TUN: dora-allocated IP changed ${currentIp} -> ${newIp}`);
-                        const ifname = this.tunDevice.getInterface();
-                        try {
-                            // ORDER MATTERS: close TunDevice FIRST so the helper
-                            // subprocess fully exits and releases agentnet0.
-                            // routeManager.cleanup's `ip tuntap del` would otherwise
-                            // fail with EBUSY and the subsequent helper spawn would
-                            // race the kernel for the device name, exit code=1, and
-                            // leave the daemon TUN-less. tunDevice.close() now waits
-                            // for actual process exit.
-                            await this.tunDevice.close();
-                            await this.routeManager.cleanup(ifname, this.config.network.subnet, currentIp);
-                            this.tunDevice = new TunDevice({
-                                config: {
-                                    name: this.config.network.interface,
-                                    ip: newIp,
-                                    subnet: this.config.network.subnet,
-                                },
-                                mockMode: this.useMockTun,
-                            });
-                            await this.tunDevice.open();
-                            if (!this.useMockTun) {
-                                await this.routeManager.configureTun({
-                                    ...this.tunDevice.getConfig(),
-                                    name: this.tunDevice.getInterface(),
-                                });
-                            }
-                            // Re-attach the packet-router's TUN listener — the
-                            // listener was bound to the old TunDevice instance.
-                            this.packetRouter?.swapTunDevice(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}`);
-                        }
-                    },
+                    onAllocatedIpChanged: (newIp) => this.reconfigureTunTo(newIp),
                 });
-                const doraIp = await this.doraIntegration.bootstrap();
-                if (doraIp && doraIp !== tunIp) {
-                    this.logger.info(`Dora-allocated IP ${doraIp} (was ${tunIp})`);
-                    tunIp = doraIp;
-                }
+                // Do NOT block the data plane on dora. The TUN opens immediately on the
+                // deterministic fallback IP (step 7 below); dora registration runs in
+                // the background (started after the TUN is up) and swaps the TUN to its
+                // allocated IP via reconfigureTunTo when/if it answers. Previously this
+                // awaited up to a 30s dora-reachability timeout BEFORE opening the TUN,
+                // so a node on a slow path (the exact China→abroad case we exist for)
+                // had no data plane for half a minute on every start.
             }
-            // 7. Setup TUN device + routing using the (possibly dora-allocated) IP.
+            // 7. Setup TUN device + routing immediately on the deterministic
+            // fallback IP — the data plane must NOT wait on dora. If dora later
+            // hands us a different IP, the backgrounded bootstrap below swaps the
+            // TUN via reconfigureTunTo.
             this.routeManager = new RouteManager();
             this.tunDevice = new TunDevice({
                 config: {
@@ -411,6 +418,21 @@ export class DaemonServer {
                     name: actualName,
                 });
             }
+            // Data plane is now LIVE on the fallback IP. Kick dora registration in
+            // the background — it never blocks startup. When it answers (initial
+            // register or a later retry), reconfigureTunTo swaps the TUN to dora's
+            // allocated IP. A slow/unreachable dora just means we keep the
+            // deterministic fallback, which is already routable.
+            if (this.doraIntegration) {
+                const fallbackIp = tunIp;
+                void this.doraIntegration
+                    .bootstrap()
+                    .then(async (doraIp) => {
+                    if (doraIp && doraIp !== fallbackIp)
+                        await this.reconfigureTunTo(doraIp);
+                })
+                    .catch((err) => this.logger.warn(`dora bootstrap (background): ${err instanceof Error ? err.message : err}`));
+            }
             // Live friend-request handling. The daemon stays up and accepts
             // (or queues) every incoming request — no `friend-accept --wait`
             // ceremony where the operator has to stop the daemon. Default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.81",
+  "version": "0.1.83",
   "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",
@@ -77,7 +77,7 @@
   },
   "dependencies": {
     "@decentnetwork/dora": "^0.1.6",
-    "@decentnetwork/peer": "^0.1.35",
+    "@decentnetwork/peer": "^0.1.37",
     "js-yaml": "^4.1.0",
     "yargs": "^17.7.2"
   },