@decentnetwork/lan 0.1.49 → 0.1.51

package/dist/carrier/peer-manager.js

@@ -180,6 +180,7 @@ export class PeerManager extends EventEmitter {
                 address: friend.address,
                 lastSeen: friend.acceptedAt,
                 acceptedAt: friend.acceptedAt,
+                requestedAt: friend.requestedAt,
             };
         });
     }

package/dist/cli/commands.js

@@ -673,6 +673,7 @@ export async function cmdFriendsList(args) {
             status: f.status,
             address: f.address,
             acceptedAt: f.acceptedAt,
+            requestedAt: f.requestedAt,
         }));
         await peer.stop();
         source = "disk";
@@ -681,16 +682,43 @@ export async function cmdFriendsList(args) {
         console.log("No friends. Use 'agentnet friend-request --address <addr>' to add one.");
         return;
     }
+    // A friend we only friend-requested (status "requested") has no name in
+    // the local SDK record yet — but the dora roster knows it. Cross-reference
+    // live IPAM so the list shows "cn", "mac-dev", … instead of "(unnamed)".
+    const ipamNames = new Map();
+    try {
+        const { peers } = await fetchLiveIpam(config);
+        for (const p of peers) {
+            if (p.carrierId && p.name)
+                ipamNames.set(p.carrierId, p.name);
+        }
+    }
+    catch {
+        // IPAM unavailable (daemon down / no dora) — fall back to (unnamed).
+    }
+    const ago = (ms) => {
+        const s = Math.max(0, Math.round((Date.now() - ms) / 1000));
+        if (s < 60)
+            return `${s}s ago`;
+        if (s < 3600)
+            return `${Math.round(s / 60)}m ago`;
+        if (s < 86400)
+            return `${Math.round(s / 3600)}h ago`;
+        return `${Math.round(s / 86400)}d ago`;
+    };
     console.log(`Friends (${friends.length}) ${source === "daemon" ? "[live]" : "[disk]"}:`);
     for (const friend of friends) {
-        console.log(``);
-        console.log(`  ${friend.name || "(unnamed)"}  status=${friend.status}`);
         const userid = friend.carrierId || friend.pubkey;
+        const name = friend.name || ipamNames.get(userid) || "(unnamed)";
+        console.log(``);
+        console.log(`  ${name}  status=${friend.status}`);
         console.log(`    userid:  ${userid}`);
         if (friend.address)
             console.log(`    address: ${friend.address}`);
+        if (friend.requestedAt)
+            console.log(`    requested: ${new Date(friend.requestedAt).toISOString()} (${ago(friend.requestedAt)})`);
         if (friend.acceptedAt)
-            console.log(`    accepted: ${new Date(friend.acceptedAt).toISOString()}`);
+            console.log(`    accepted:  ${new Date(friend.acceptedAt).toISOString()} (${ago(friend.acceptedAt)})`);
     }
 }
 /**

package/dist/daemon/server.d.ts

@@ -35,11 +35,21 @@ export declare class DaemonServer {
     private pendingFriends?;
     private startedAt;
     private isRunning;
+    private statusTimer?;
     private pidFile?;
     private configDir;
     constructor(opts: DaemonOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
+    /**
+     * Periodic one-line peer-connection summary at INFO. Between the
+     * startup block and the first friend flipping online the log is
+     * otherwise silent — which looks like the daemon is idle when it's
+     * actually retrying handshakes (those are only logged at debug). This
+     * line shows, every 30s, who's connected vs. still connecting so an
+     * operator can see it IS working without enabling DECENT_DEBUG.
+     */
+    private startPeerStatusSummary;
     getStatus(): DaemonStatus;
     /**
      * Periodically poke the SDK to (re-)initiate a session with the friend.

package/dist/daemon/server.js

@@ -52,6 +52,7 @@ export class DaemonServer {
     pendingFriends;
     startedAt = 0;
     isRunning = false;
+    statusTimer;
     pidFile;
     configDir;
     constructor(opts) {
@@ -576,6 +577,7 @@ export class DaemonServer {
             }
             this.isRunning = true;
             this.logger.info("Daemon started successfully");
+            this.startPeerStatusSummary();
         }
         catch (error) {
             this.logger.error("Failed to start daemon:", error);
@@ -591,6 +593,41 @@ export class DaemonServer {
         await this.cleanup();
         this.logger.info("Daemon stopped");
     }
+    /**
+     * Periodic one-line peer-connection summary at INFO. Between the
+     * startup block and the first friend flipping online the log is
+     * otherwise silent — which looks like the daemon is idle when it's
+     * actually retrying handshakes (those are only logged at debug). This
+     * line shows, every 30s, who's connected vs. still connecting so an
+     * operator can see it IS working without enabling DECENT_DEBUG.
+     */
+    startPeerStatusSummary() {
+        const label = (p) => {
+            const id = p.carrierId || p.pubkey;
+            return p.name || this.ipam?.resolveCarrierId(id)?.name || `${id.slice(0, 8)}…`;
+        };
+        const tick = () => {
+            if (!this.isRunning || !this.peerManager)
+                return;
+            let peers;
+            try {
+                peers = this.peerManager.getFriends();
+            }
+            catch {
+                return;
+            }
+            if (peers.length === 0)
+                return;
+            const online = peers.filter((p) => p.status === "online");
+            const connecting = peers.filter((p) => p.status !== "online");
+            const fmt = (list) => list.length === 0 ? "none" : list.map(label).join(", ");
+            this.logger.info(`Peers: ${online.length} connected (${fmt(online)}) · ` +
+                `${connecting.length} connecting (${fmt(connecting)})`);
+        };
+        // First summary shortly after startup, then every 30s.
+        setTimeout(tick, 5_000);
+        this.statusTimer = setInterval(tick, 30_000);
+    }
     getStatus() {
         return {
             isRunning: this.isRunning,
@@ -681,6 +718,10 @@ export class DaemonServer {
         return this.doraIntegration;
     }
     async cleanup() {
+        if (this.statusTimer) {
+            clearInterval(this.statusTimer);
+            this.statusTimer = undefined;
+        }
         try {
             if (this.dnsServer) {
                 await this.dnsServer.stop();

package/dist/types.d.ts

@@ -23,6 +23,8 @@ export interface RemotePeer {
     address?: string;
     lastSeen?: number;
     acceptedAt?: number;
+    /** When we sent the outbound friend-request (ms epoch). */
+    requestedAt?: number;
 }
 export interface FriendConnectionEvent {
     pubkey: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "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",
@@ -75,7 +75,7 @@
   },
   "dependencies": {
     "@decentnetwork/dora": "^0.1.6",
-    "@decentnetwork/peer": "^0.1.20",
+    "@decentnetwork/peer": "^0.1.21",
     "js-yaml": "^4.1.0",
     "yargs": "^17.7.2"
   },