@decentnetwork/lan 0.1.101 → 0.1.103

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

@@ -942,11 +942,20 @@ function PeerRow({ peer, T, active, onClick }) {
 function PeerSidebar({ T, peers, requests, activeId, onSelect, onAct, onAdd }) {
   const [q, setQ] = React.useState("");
   const [addr, setAddr] = React.useState("");
+  const [addState, setAddState] = React.useState(null);
   const submitAddr = () => {
-    if (addr.trim()) {
-      onAdd(addr);
-      setAddr("");
-    }
+    const v = addr.trim();
+    if (!v || addState && addState.kind === "sending") return;
+    setAddState({ kind: "sending", msg: T.addSending });
+    Promise.resolve(onAdd(v)).then((r) => {
+      if (r && r.ok) {
+        setAddr("");
+        setAddState({ kind: "ok", msg: T.addSent });
+      } else {
+        setAddState({ kind: "err", msg: r && r.error ? `${T.addFailed}: ${r.error}` : T.addFailed });
+      }
+      setTimeout(() => setAddState((s) => s && s.kind !== "sending" ? null : s), 6e3);
+    });
   };
   const filtered = peers.filter((p) => {
     if (!q) return true;
@@ -956,7 +965,12 @@ function PeerSidebar({ T, peers, requests, activeId, onSelect, onAct, onAdd }) {
   const online = peers.filter((p) => p.online).length;
   return /* @__PURE__ */ React.createElement("div", { style: { width: 320, flexShrink: 0, borderRight: "1px solid var(--line)", display: "flex", flexDirection: "column", background: "var(--panel)" } }, /* @__PURE__ */ React.createElement("div", { style: { padding: "12px 12px 10px", borderBottom: "1px solid var(--line)", display: "flex", flexDirection: "column", gap: 8 } }, /* @__PURE__ */ React.createElement("div", { style: { display: "flex", gap: 7 } }, /* @__PURE__ */ React.createElement("input", { value: addr, onChange: (e) => setAddr(e.target.value), onKeyDown: (e) => {
     if (e.key === "Enter") submitAddr();
-  }, placeholder: T.addPlaceholder, style: inputStyle }), /* @__PURE__ */ React.createElement(Btn, { tone: "solid", icon: "userPlus", onClick: submitAddr }, T.add)), /* @__PURE__ */ React.createElement("div", { style: { position: "relative", display: "flex", alignItems: "center" } }, /* @__PURE__ */ React.createElement(Icon, { name: "search", size: 15, color: "var(--faint)", stroke: 2, style: { position: "absolute", left: 9 } }), /* @__PURE__ */ React.createElement("input", { value: q, onChange: (e) => setQ(e.target.value), placeholder: T.search, style: { ...inputStyle, paddingLeft: 30 } }))), /* @__PURE__ */ React.createElement("div", { style: { flex: 1, overflow: "auto", padding: "10px 8px 16px" } }, /* @__PURE__ */ React.createElement(RequestsBlock, { T, requests, onAct }), /* @__PURE__ */ React.createElement(Section, { label: T.peers, count: `${online}/${peers.length}`, style: { margin: "6px 4px 8px" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 2 } }, filtered.map((p) => /* @__PURE__ */ React.createElement(PeerRow, { key: p.id, peer: p, T, active: p.id === activeId, onClick: () => onSelect(p.id) })), !filtered.length && /* @__PURE__ */ React.createElement("div", { style: { padding: 16, textAlign: "center", fontFamily: "var(--mono)", fontSize: 12, color: "var(--faint)" } }, "no matches"))));
+  }, placeholder: T.addPlaceholder, style: inputStyle }), /* @__PURE__ */ React.createElement(Btn, { tone: "solid", icon: "userPlus", onClick: submitAddr }, T.add)), addState && /* @__PURE__ */ React.createElement("div", { style: {
+    fontFamily: "var(--mono)",
+    fontSize: 11.5,
+    lineHeight: 1.35,
+    color: addState.kind === "err" ? "var(--bad, #e5484d)" : addState.kind === "ok" ? "var(--good, #46a758)" : "var(--faint)"
+  } }, addState.msg), /* @__PURE__ */ React.createElement("div", { style: { position: "relative", display: "flex", alignItems: "center" } }, /* @__PURE__ */ React.createElement(Icon, { name: "search", size: 15, color: "var(--faint)", stroke: 2, style: { position: "absolute", left: 9 } }), /* @__PURE__ */ React.createElement("input", { value: q, onChange: (e) => setQ(e.target.value), placeholder: T.search, style: { ...inputStyle, paddingLeft: 30 } }))), /* @__PURE__ */ React.createElement("div", { style: { flex: 1, overflow: "auto", padding: "10px 8px 16px" } }, /* @__PURE__ */ React.createElement(RequestsBlock, { T, requests, onAct }), /* @__PURE__ */ React.createElement(Section, { label: T.peers, count: `${online}/${peers.length}`, style: { margin: "6px 4px 8px" } }), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", flexDirection: "column", gap: 2 } }, filtered.map((p) => /* @__PURE__ */ React.createElement(PeerRow, { key: p.id, peer: p, T, active: p.id === activeId, onClick: () => onSelect(p.id) })), !filtered.length && /* @__PURE__ */ React.createElement("div", { style: { padding: 16, textAlign: "center", fontFamily: "var(--mono)", fontSize: 12, color: "var(--faint)" } }, "no matches"))));
 }
 const inputStyle = {
   flex: 1,
@@ -1205,6 +1219,9 @@ const STR = {
     addPlaceholder: "paste a friend's carrier address\u2026",
     add: "Add",
     search: "search peers / ip\u2026",
+    addSending: "sending friend-request\u2026",
+    addSent: "friend-request sent \u2014 they appear once they accept",
+    addFailed: "could not send",
     requests: "Friend requests",
     accept: "accept",
     reject: "reject",
@@ -1277,6 +1294,9 @@ const STR = {
     addPlaceholder: "\u7C98\u8D34\u597D\u53CB\u7684 carrier \u5730\u5740\u2026",
     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",
+    addFailed: "\u53D1\u9001\u5931\u8D25",
     requests: "\u597D\u53CB\u8BF7\u6C42",
     accept: "\u63A5\u53D7",
     reject: "\u62D2\u7EDD",
@@ -1397,7 +1417,11 @@ function DkApp() {
     if (peer.id === activeId) setActiveId(null);
   };
   const onAdd = (address) => {
-    if (address && address.trim()) dkApi.add(address.trim()).then(data.refresh);
+    if (!address || !address.trim()) return Promise.resolve({ ok: false, error: "empty address" });
+    return dkApi.add(address.trim()).then((r) => {
+      data.refresh();
+      return r;
+    });
   };
   const onSend = (text) => {
     if (!activeId || !text || !text.trim()) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.101",
+  "version": "0.1.103",
   "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",
@@ -79,7 +79,7 @@
   },
   "dependencies": {
     "@decentnetwork/dora": "^0.1.6",
-    "@decentnetwork/peer": "^0.1.44",
+    "@decentnetwork/peer": "^0.1.45",
     "ink": "^5.2.1",
     "js-yaml": "^4.1.0",
     "react": "^18.3.1",