@decentnetwork/lan 0.1.15 → 0.1.17

package/dist/carrier/peer-manager.js

@@ -159,12 +159,29 @@ export class PeerManager extends EventEmitter {
         if (!this.peer) {
             throw new Error("Peer not created. Call create() first.");
         }
-        return this.peer.friends().map((friend) => ({
-            pubkey: friend.pubkey,
-            name: friend.name,
-            status: friend.status === "online" ? "online" : "offline",
-            lastSeen: friend.acceptedAt,
-        }));
+        return this.peer.friends().map((friend) => {
+            // Preserve the SDK's three-state status ("requested" matters —
+            // collapsing it into "offline" hid the "did my friend-request
+            // make it across?" diagnostic from diag output).
+            const status = friend.status === "online"
+                ? "online"
+                : friend.status === "requested"
+                    ? "requested"
+                    : "offline";
+            // Both pubkey and userid are populated with the base58 userid in
+            // every current SDK code path, but persisted records from
+            // pre-1.7.x clients may only have pubkey. Keep both forms.
+            const carrierId = friend.userid || friend.pubkey;
+            return {
+                pubkey: friend.pubkey,
+                carrierId,
+                name: friend.name,
+                status,
+                address: friend.address,
+                lastSeen: friend.acceptedAt,
+                acceptedAt: friend.acceptedAt,
+            };
+        });
     }
     /**
      * Check if a specific friend is currently online (direct UDP path established).

package/dist/cli/commands.d.ts

@@ -96,7 +96,10 @@ export declare function cmdFriendAccept(args: {
     configDir?: string;
 }): Promise<void>;
 /**
- * List friends in the friend store.
+ * List friends in the friend store. Prefers the live daemon over IPC —
+ * opening a second Peer with the same keyfile would stomp on the
+ * daemon's Carrier session, so we only fall back to that path when the
+ * daemon isn't running. Same pattern as `peers list` and `resolve`.
  */
 export declare function cmdFriendsList(args: {
     configDir?: string;

package/dist/cli/commands.js

@@ -511,46 +511,63 @@ export async function cmdFriendAccept(args) {
     console.log(`Friend accepted: ${pubkey}`);
 }
 /**
- * List friends in the friend store.
+ * List friends in the friend store. Prefers the live daemon over IPC —
+ * opening a second Peer with the same keyfile would stomp on the
+ * daemon's Carrier session, so we only fall back to that path when the
+ * daemon isn't running. Same pattern as `peers list` and `resolve`.
  */
 export async function cmdFriendsList(args) {
     const dir = args.configDir || ConfigLoader.defaultConfigDir();
     const config = await ConfigLoader.load(resolve(dir, "config.yaml"));
-    assertDaemonNotRunning(config, "friends list");
-    const { Peer } = await import("@decentnetwork/peer");
-    const keyFile = resolve(config.carrier.dataDir, "keypair.json");
-    if (!existsSync(keyFile)) {
-        console.log("No identity yet. Start the daemon at least once to generate one.");
-        return;
+    let friends;
+    let source;
+    if (daemonPid(config) !== null) {
+        const res = await ipcCall(config, { op: "diag" });
+        if (!res.ok)
+            throw new Error(`Daemon diag failed: ${res.error}`);
+        friends = (res.data.friends ?? []);
+        source = "daemon";
+    }
+    else {
+        const { Peer } = await import("@decentnetwork/peer");
+        const keyFile = resolve(config.carrier.dataDir, "keypair.json");
+        if (!existsSync(keyFile)) {
+            console.log("No identity yet. Start the daemon at least once to generate one.");
+            return;
+        }
+        const peer = await Peer.create({
+            keyFile,
+            compatibilityMode: "legacy",
+            bootstrapNodes: config.carrier.bootstrapNodes,
+            expressNodes: config.carrier.expressNodes,
+        });
+        await peer.start();
+        friends = peer.friends().map((f) => ({
+            pubkey: f.pubkey,
+            carrierId: f.userid || f.pubkey,
+            name: f.name,
+            status: f.status,
+            address: f.address,
+            acceptedAt: f.acceptedAt,
+        }));
+        await peer.stop();
+        source = "disk";
     }
-    // Open peer and start (start() loads friends from disk)
-    const peer = await Peer.create({
-        keyFile,
-        compatibilityMode: "legacy",
-        bootstrapNodes: config.carrier.bootstrapNodes,
-        expressNodes: config.carrier.expressNodes,
-    });
-    await peer.start();
-    const friends = peer.friends();
     if (friends.length === 0) {
         console.log("No friends. Use 'agentnet friend-request --address <addr>' to add one.");
-        await peer.stop();
         return;
     }
-    console.log(`Friends (${friends.length}):`);
+    console.log(`Friends (${friends.length}) ${source === "daemon" ? "[live]" : "[disk]"}:`);
     for (const friend of friends) {
         console.log(``);
         console.log(`  ${friend.name || "(unnamed)"}  status=${friend.status}`);
-        // userid is Carrier's first-class identifier; show that, hide
-        // the raw hex pubkey unless someone explicitly needs it.
-        const userid = friend.userid && friend.userid !== friend.pubkey ? friend.userid : friend.pubkey;
+        const userid = friend.carrierId || friend.pubkey;
         console.log(`    userid:  ${userid}`);
         if (friend.address)
             console.log(`    address: ${friend.address}`);
         if (friend.acceptedAt)
             console.log(`    accepted: ${new Date(friend.acceptedAt).toISOString()}`);
     }
-    await peer.stop();
 }
 /**
  * List queued friend-requests held by the running daemon (the ones

package/dist/daemon/server.js

@@ -170,6 +170,8 @@ export class DaemonServer {
                             carrierId: f.carrierId,
                             name: f.name,
                             status: f.status,
+                            address: f.address,
+                            acceptedAt: f.acceptedAt,
                         })),
                         ipam: ipamPeers,
                     };
@@ -212,8 +214,15 @@ export class DaemonServer {
                         this.logger.info(`Reconfiguring TUN: dora-allocated IP changed ${currentIp} -> ${newIp}`);
                         const ifname = this.tunDevice.getInterface();
                         try {
-                            await this.routeManager.cleanup(ifname, this.config.network.subnet, currentIp);
+                            // 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,

package/dist/tun/tun-device.js

@@ -54,8 +54,35 @@ export class TunDevice extends EventEmitter {
         this.isOpen = false;
         this.packetQueue = [];
         if (this.helper) {
-            this.helper.kill("SIGTERM");
+            // Wait for the helper subprocess to actually exit before
+            // returning. SIGTERM is async — without this await, a caller
+            // that immediately spawns a new helper for the same device
+            // name races the kernel: the old helper still owns
+            // `agentnet0`, the new helper's TUNSETIFF ioctl returns
+            // EBUSY, the helper exits with code=1, the daemon ends up
+            // with NO TUN device at all even though `systemctl is-active`
+            // reports green. Symptom: every outbound packet routes via
+            // the default gateway instead of the daemon, 100% packet
+            // loss with no obvious error. Force-kill after 2s in case
+            // SIGTERM is swallowed.
+            const helper = this.helper;
             this.helper = undefined;
+            await new Promise((res) => {
+                if (helper.exitCode !== null || helper.signalCode !== null) {
+                    res();
+                    return;
+                }
+                const timer = setTimeout(() => {
+                    if (helper.exitCode === null && helper.signalCode === null) {
+                        helper.kill("SIGKILL");
+                    }
+                }, 2000);
+                helper.once("exit", () => {
+                    clearTimeout(timer);
+                    res();
+                });
+                helper.kill("SIGTERM");
+            });
         }
         this.emit("closed");
     }

package/dist/types.d.ts

@@ -8,11 +8,21 @@ export interface PeerIdentity {
 }
 export interface RemotePeer {
     pubkey: string;
-    status: "online" | "offline" | "connecting";
+    /**
+     * Mirrors the SDK's FriendRecord.status verbatim:
+     *  - "online":    crypto session established
+     *  - "offline":   was a friend, currently disconnected
+     *  - "requested": we sent a friend-request; peer hasn't accepted
+     * Collapsing "requested" into "offline" loses the operator signal
+     * ("did my friend-request go through?") so keep them distinct.
+     */
+    status: "online" | "offline" | "requested";
     name?: string;
     carrierId?: string;
     virtualIp?: string;
+    address?: string;
     lastSeen?: number;
+    acceptedAt?: number;
 }
 export interface FriendConnectionEvent {
     pubkey: string;

package/package.json

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