@decentnetwork/lan 0.1.270 → 0.1.272

package/dist/daemon/ipc.d.ts

@@ -109,7 +109,7 @@ export interface IpcHandlers {
      *  signals immediately, otherwise holds the connection until one arrives or a
      *  ~20s timeout elapses (then resolves empty). The UI re-polls to get
      *  near-instant offer/answer/candidate delivery without a WebSocket. */
-    callPoll: () => Promise<Record<string, unknown>>;
+    callPoll: (since?: number) => Promise<Record<string, unknown>>;
     /** Re-read proxy allowlist from config and apply it to the running
      *  proxy WITHOUT restarting the daemon. Lets `agentnet proxy
      *  allow-host` take effect instantly instead of forcing a daemon
@@ -153,6 +153,8 @@ export interface IpcRequest {
     data?: string;
     /** Carrier custom-packet id for the "app-send" op (165-191). */
     packetId?: number;
+    /** Broadcast cursor for "call-poll": return signals with seq > since. */
+    since?: number;
 }
 export interface IpcResponseOk {
     ok: true;

package/dist/daemon/ipc.js

@@ -297,7 +297,7 @@ export class IpcServer {
             case "dora-status":
                 return await this.handlers.doraStatus();
             case "call-poll":
-                return await this.handlers.callPoll();
+                return await this.handlers.callPoll(typeof req.since === "number" ? req.since : undefined);
             case "proxy-reload":
                 return await this.handlers.proxyReload();
             case "proxy-access":

package/dist/daemon/server.d.ts

@@ -44,12 +44,25 @@ export declare class DaemonServer {
     /** Outgoing file transfers in flight: fileId → the chat message tracking it,
      *  so progress/complete/cancel events can patch its status + sent bytes. */
     private readonly activeSends;
-    /** Inbound WebRTC call-signaling payloads ({userid, data}) waiting to be
-     *  drained by the UI's /api/call-poll long-poll. Bounded so a UI that never
-     *  polls can't grow it unboundedly. */
-    private readonly callSignalQueue;
+    /** Inbound WebRTC call-signaling payloads as a broadcast ring: every poller
+     *  reads at its own cursor, entries expire by AGE (90s), never by being
+     *  read. The previous shape — splice(0) on first poll — handed the whole
+     *  batch to whichever poller arrived first, so with two tabs (or the
+     *  desktop app + a browser) open, an incoming call rang a random one and
+     *  the surface the user was looking at stayed silent (INBOX 2026-08-05).
+     *  Bounded so a UI that never polls can't grow it unboundedly. */
+    private readonly callSignalLog;
+    /** Seeded with the epoch so a cursor from a PREVIOUS daemon incarnation is
+     *  always smaller than any new signal's seq. Seeded at 0, a daemon restart
+     *  made every open tab deaf: their old cursor exceeded the fresh counter,
+     *  so `seq > since` never matched and incoming calls stopped ringing until
+     *  a hard refresh. */
+    private callSignalSeq;
     /** Resolvers for in-flight call-poll long-polls, woken when a signal lands. */
     private callSignalWaiters;
+    /** Call signals older than this have no business ringing anything. */
+    private static readonly CALL_SIGNAL_TTL_MS;
+    private pruneCallSignals;
     /** Directory holding queued (offline) outgoing file bytes: <configDir>/outbox.
      *  One file per queued message, named by its msgId. Set in start(). */
     private outboxDir;

package/dist/daemon/server.js

@@ -90,12 +90,29 @@ export class DaemonServer {
     /** Outgoing file transfers in flight: fileId → the chat message tracking it,
      *  so progress/complete/cancel events can patch its status + sent bytes. */
     activeSends = new Map();
-    /** Inbound WebRTC call-signaling payloads ({userid, data}) waiting to be
-     *  drained by the UI's /api/call-poll long-poll. Bounded so a UI that never
-     *  polls can't grow it unboundedly. */
-    callSignalQueue = [];
+    /** Inbound WebRTC call-signaling payloads as a broadcast ring: every poller
+     *  reads at its own cursor, entries expire by AGE (90s), never by being
+     *  read. The previous shape — splice(0) on first poll — handed the whole
+     *  batch to whichever poller arrived first, so with two tabs (or the
+     *  desktop app + a browser) open, an incoming call rang a random one and
+     *  the surface the user was looking at stayed silent (INBOX 2026-08-05).
+     *  Bounded so a UI that never polls can't grow it unboundedly. */
+    callSignalLog = [];
+    /** Seeded with the epoch so a cursor from a PREVIOUS daemon incarnation is
+     *  always smaller than any new signal's seq. Seeded at 0, a daemon restart
+     *  made every open tab deaf: their old cursor exceeded the fresh counter,
+     *  so `seq > since` never matched and incoming calls stopped ringing until
+     *  a hard refresh. */
+    callSignalSeq = Date.now();
     /** Resolvers for in-flight call-poll long-polls, woken when a signal lands. */
     callSignalWaiters = [];
+    /** Call signals older than this have no business ringing anything. */
+    static CALL_SIGNAL_TTL_MS = 90_000;
+    pruneCallSignals() {
+        const cutoff = Date.now() - DaemonServer.CALL_SIGNAL_TTL_MS;
+        while (this.callSignalLog.length && this.callSignalLog[0].ts < cutoff)
+            this.callSignalLog.shift();
+    }
     /** Directory holding queued (offline) outgoing file bytes: <configDir>/outbox.
      *  One file per queued message, named by its msgId. Set in start(). */
     outboxDir = "";
@@ -708,11 +725,16 @@ export class DaemonServer {
                         return { checkedAt: new Date().toISOString(), registries: [], note: "dora not enabled on this node" };
                     return await this.doraIntegration.doraStatus();
                 },
-                callPoll: async () => {
-                    // Drain immediately if signals are queued; otherwise hold up to ~20s
-                    // for one to arrive (near-instant delivery without a WebSocket). The
-                    // IPC client's timeout is 30s, so a 20s hold is safe.
-                    if (this.callSignalQueue.length === 0) {
+                callPoll: async (since) => {
+                    // Long-poll at a per-subscriber cursor: reading never consumes, so
+                    // every open tab receives every signal. A caller without a cursor
+                    // (older UI) starts at "now" and gets only future signals — the old
+                    // semantics minus the stealing. Hold up to ~20s for a new signal
+                    // (the IPC client's timeout is 30s, so a 20s hold is safe).
+                    const from = since ?? this.callSignalSeq;
+                    this.pruneCallSignals();
+                    let avail = this.callSignalLog.filter((s) => s.seq > from);
+                    if (avail.length === 0) {
                         await new Promise((resolve) => {
                             const timer = setTimeout(() => {
                                 this.callSignalWaiters = this.callSignalWaiters.filter((w) => w !== wake);
@@ -724,18 +746,19 @@ export class DaemonServer {
                             };
                             this.callSignalWaiters.push(wake);
                         });
+                        this.pruneCallSignals();
+                        avail = this.callSignalLog.filter((s) => s.seq > from);
                     }
-                    const signals = this.callSignalQueue.splice(0, this.callSignalQueue.length);
-                    if (signals.length) {
-                        const kinds = signals.map((s) => { try {
+                    if (avail.length) {
+                        const kinds = avail.map((s) => { try {
                             return JSON.parse(s.data).type;
                         }
                         catch {
                             return "?";
                         } }).join(",");
-                        this.logger.info(`call-poll -> browser: ${signals.length} signal(s) [${kinds}]`);
+                        this.logger.info(`call-poll -> browser: ${avail.length} signal(s) [${kinds}] (cursor ${from} -> ${this.callSignalSeq})`);
                     }
-                    return { signals };
+                    return { signals: avail.map(({ userid, data }) => ({ userid, data })), cursor: this.callSignalSeq };
                 },
                 subscribe: (emit) => {
                     const onEvent = (event) => emit(event);
@@ -1198,9 +1221,10 @@ export class DaemonServer {
                 if (!text)
                     return;
                 // Cap the backlog so a UI that stopped polling can't grow it forever.
-                if (this.callSignalQueue.length > 256)
-                    this.callSignalQueue.shift();
-                this.callSignalQueue.push({ userid: evt.pubkey, data: text });
+                if (this.callSignalLog.length > 256)
+                    this.callSignalLog.shift();
+                this.callSignalLog.push({ seq: ++this.callSignalSeq, ts: Date.now(), userid: evt.pubkey, data: text });
+                this.pruneCallSignals();
                 const waiters = this.callSignalWaiters;
                 this.callSignalWaiters = [];
                 for (const wake of waiters)

package/dist/ui/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.270";
+window.__DK_UI_VERSION="0.1.272";
 const ICON_PATHS = {
   // ---- tab bar (the four must feel like one set) ----
   users: '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',

package/package.json

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