@decentnetwork/lan 0.1.102 → 0.1.104

package/dist/console/console.js

@@ -435,10 +435,24 @@ function App({ client }) {
       }
     };
     void tick();
-    const iv = setInterval(() => void tick(), 1400);
+    let iv = setInterval(() => {
+      if (alive) void tick();
+    }, 6e3);
+    const stop = client.subscribe(
+      () => {
+        if (alive) void tick();
+      },
+      () => {
+        clearInterval(iv);
+        iv = setInterval(() => {
+          if (alive) void tick();
+        }, 2500);
+      }
+    );
     return () => {
       alive = false;
       clearInterval(iv);
+      stop();
     };
   }, [client, selId]);
   React.useEffect(() => {
@@ -909,6 +923,64 @@ var DaemonClient = class _DaemonClient {
       });
     });
   }
+  /**
+   * Open a persistent subscription to daemon push events (chat / presence /
+   * friend-request). Calls `onEvent` for each event and auto-reconnects with
+   * backoff if the socket drops. Returns a stop() to tear it down.
+   *
+   * Degrades gracefully: an older daemon that doesn't know the `subscribe`
+   * op replies `{ok:false}` and closes — we surface that via `onUnsupported`
+   * so the caller can keep its polling fallback instead of reconnecting in a
+   * tight loop. A daemon that supports it acks with `{subscribed:true}` first.
+   */
+  subscribe(onEvent, onUnsupported) {
+    let stopped = false;
+    let sock;
+    let retry;
+    const connect = () => {
+      if (stopped) return;
+      let buf = "";
+      let acked = false;
+      sock = createConnection(this.sockPath);
+      sock.on("connect", () => sock.write(JSON.stringify({ op: "subscribe" }) + "\n"));
+      sock.on("data", (c) => {
+        buf += c.toString("utf-8");
+        let nl;
+        while ((nl = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, nl);
+          buf = buf.slice(nl + 1);
+          if (!line) continue;
+          try {
+            const msg = JSON.parse(line);
+            if (!acked) {
+              acked = true;
+              if (msg.ok === false) {
+                stopped = true;
+                sock?.end();
+                onUnsupported?.();
+                return;
+              }
+              continue;
+            }
+            if (msg.event) onEvent(msg.event);
+          } catch {
+          }
+        }
+      });
+      const reconnect = () => {
+        if (stopped) return;
+        retry = setTimeout(connect, 1500);
+      };
+      sock.on("error", reconnect);
+      sock.on("close", reconnect);
+    };
+    connect();
+    return () => {
+      stopped = true;
+      if (retry) clearTimeout(retry);
+      sock?.destroy();
+    };
+  }
   static data(r) {
     return r.ok && r.data ? r.data : {};
   }

package/dist/daemon/ipc.d.ts

@@ -56,6 +56,12 @@ export interface IpcHandlers {
         name?: string;
         description?: string;
     }) => Promise<void>;
+    /** Subscribe to daemon push events (chat / presence / friend-request). The
+     *  IPC server keeps the connection open and calls `emit` for each event;
+     *  the returned function unsubscribes (called on socket close). Optional —
+     *  when absent, clients fall back to polling. Lets the TUI/UI react to new
+     *  messages instantly instead of polling on a tight interval. */
+    subscribe?: (emit: (event: Record<string, unknown>) => void) => () => void;
     /** Offer a local file (by path) to a friend over toxcore file transfer. */
     fileSend: (userid: string, path: string) => Promise<Record<string, unknown>>;
     /** Mark a conversation read up to `ts` (defaults to now) — clears unread. */
@@ -76,7 +82,7 @@ export interface IpcHandlers {
     selfRestart: () => Promise<Record<string, unknown>>;
 }
 export interface IpcRequest {
-    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "chat-send" | "chat-history" | "friends-list" | "friend-remove" | "friend-set-alias" | "set-profile" | "file-send" | "chat-mark-read" | "proxy-reload" | "self-restart";
+    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "chat-send" | "chat-history" | "friends-list" | "friend-remove" | "friend-set-alias" | "set-profile" | "file-send" | "chat-mark-read" | "subscribe" | "proxy-reload" | "self-restart";
     address?: string;
     hello?: string;
     userid?: string;

package/dist/daemon/ipc.js

@@ -109,6 +109,44 @@ export class IpcServer {
                 reply({ ok: false, error: "malformed request (not JSON)" });
                 return;
             }
+            // Streaming subscription: keep the socket OPEN and push newline-JSON
+            // events until the client disconnects. This is the one op that breaks
+            // the one-shot model — it lets the TUI/UI react to new messages and
+            // presence changes instantly instead of polling on a tight interval.
+            if (req.op === "subscribe") {
+                if (!this.handlers.subscribe) {
+                    reply({ ok: false, error: "subscribe not supported" });
+                    return;
+                }
+                // First line acks the subscription so the client knows push is live
+                // (and can distinguish an old daemon that rejects the op).
+                try {
+                    sock.write(JSON.stringify({ ok: true, data: { subscribed: true } }) + "\n");
+                }
+                catch {
+                    sock.end();
+                    return;
+                }
+                const unsubscribe = this.handlers.subscribe((event) => {
+                    try {
+                        sock.write(JSON.stringify({ event }) + "\n");
+                    }
+                    catch {
+                        // socket gone; cleanup happens via the close handler
+                    }
+                });
+                const cleanup = () => {
+                    try {
+                        unsubscribe();
+                    }
+                    catch {
+                        // best-effort
+                    }
+                };
+                sock.on("close", cleanup);
+                sock.on("end", cleanup);
+                return;
+            }
             void this.dispatch(req)
                 .then((data) => reply({ ok: true, ...(data ? { data } : {}) }))
                 .catch((err) => reply({ ok: false, error: err instanceof Error ? err.message : String(err) }));

package/dist/daemon/server.d.ts

@@ -37,6 +37,10 @@ export declare class DaemonServer {
      *  the `agentnet ui` chat window; not persisted across restarts. */
     private messageStore?;
     private friendMeta?;
+    /** Push-event fan-out for IPC subscribers (TUI/UI). Fires on inbound/outbound
+     *  chat, presence changes, and friend-requests so clients can refresh on
+     *  demand instead of polling on a tight interval. */
+    private readonly ipcEvents;
     private startedAt;
     private isRunning;
     private statusTimer?;

package/dist/daemon/server.js

@@ -2,6 +2,7 @@
  * Daemon Server — wires together all components
  */
 import { resolve } from "path";
+import { EventEmitter } from "events";
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
 import { PeerManager } from "../carrier/peer-manager.js";
 import { TunDevice } from "../tun/tun-device.js";
@@ -56,6 +57,10 @@ export class DaemonServer {
      *  the `agentnet ui` chat window; not persisted across restarts. */
     messageStore;
     friendMeta;
+    /** Push-event fan-out for IPC subscribers (TUI/UI). Fires on inbound/outbound
+     *  chat, presence changes, and friend-requests so clients can refresh on
+     *  demand instead of polling on a tight interval. */
+    ipcEvents = new EventEmitter();
     startedAt = 0;
     isRunning = false;
     statusTimer;
@@ -204,6 +209,7 @@ export class DaemonServer {
             // Start IPC as soon as the peer is up. The CLI uses it to drive
             // operations that need the daemon's Carrier identity (e.g.
             // friend-request) without spawning a competing Peer instance.
+            this.ipcEvents.setMaxListeners(50);
             this.ipcServer = new IpcServer(ipcSocketPath(this.config.carrier.dataDir), {
                 friendRequest: async (address, hello) => {
                     await this.peerManager.sendFriendRequest(address, hello);
@@ -309,6 +315,11 @@ export class DaemonServer {
                 chatMarkRead: async (userid, ts) => {
                     this.friendMeta?.markRead(userid, ts);
                 },
+                subscribe: (emit) => {
+                    const onEvent = (event) => emit(event);
+                    this.ipcEvents.on("event", onEvent);
+                    return () => this.ipcEvents.off("event", onEvent);
+                },
                 proxyReload: async () => {
                     // Re-read the proxy allowlist from disk and push it into the
                     // running proxy without a daemon restart (which would drop
@@ -555,6 +566,11 @@ export class DaemonServer {
             this.peerManager.on("message", (pubkey, text) => {
                 this.logChat(pubkey, "in", text);
             });
+            // Presence: push to IPC subscribers so the TUI/UI reflects online/offline
+            // transitions immediately instead of on the next poll tick.
+            this.peerManager.on("friend-connection", (evt) => {
+                this.ipcEvents.emit("event", { type: "presence", userid: evt?.pubkey, status: evt?.status });
+            });
             // File transfer (toxcore-standard): auto-accept offers from friends and
             // save completed files under <configDir>/downloads/.
             this.peerManager.on("file-offer", (o) => {
@@ -580,6 +596,7 @@ export class DaemonServer {
                 void pubkeyHexToUserid(req.pubkey).then((userid) => {
                     const who = `${req.name || "(unnamed)"} ${userid}`;
                     const hello = req.hello ? ` hello="${req.hello.slice(0, 60)}"` : "";
+                    this.ipcEvents.emit("event", { type: "request", userid });
                     if (autoAcceptFriends) {
                         this.logger.info(`Friend request from ${who}${hello} — auto-accepting`);
                         this.peerManager?.acceptFriendRequest(req.pubkey).catch((err) => {
@@ -802,6 +819,7 @@ export class DaemonServer {
     logChat(userid, dir, text) {
         this.messageStore?.append(userid, dir, text);
         this.friendMeta?.ensure(userid);
+        this.ipcEvents.emit("event", { type: "chat", userid, dir });
     }
     /** Per-peer timestamp of the last self-heal friend-request re-send, so
      *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */

package/dist/ui/desktop/app.js

@@ -1220,7 +1220,7 @@ const STR = {
     add: "Add",
     search: "search peers / ip\u2026",
     addSending: "sending friend-request\u2026",
-    addSent: "friend-request sent \u2014 they appear once they accept",
+    addSent: "friend-request sent \u2014 delivered when they\u2019re online; appears here once they accept",
     addFailed: "could not send",
     requests: "Friend requests",
     accept: "accept",
@@ -1295,7 +1295,7 @@ const STR = {
     add: "\u6DFB\u52A0",
     search: "\u641C\u7D22\u597D\u53CB / IP\u2026",
     addSending: "\u6B63\u5728\u53D1\u9001\u597D\u53CB\u8BF7\u6C42\u2026",
-    addSent: "\u597D\u53CB\u8BF7\u6C42\u5DF2\u53D1\u9001 \u2014 \u5BF9\u65B9\u63A5\u53D7\u540E\u4F1A\u51FA\u73B0\u5728\u5217\u8868",
+    addSent: "\u597D\u53CB\u8BF7\u6C42\u5DF2\u53D1\u9001 \u2014 \u5BF9\u65B9\u4E0A\u7EBF\u540E\u9001\u8FBE\uFF0C\u63A5\u53D7\u540E\u51FA\u73B0\u5728\u5217\u8868",
     addFailed: "\u53D1\u9001\u5931\u8D25",
     requests: "\u597D\u53CB\u8BF7\u6C42",
     accept: "\u63A5\u53D7",

package/package.json

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