@decentnetwork/lan 0.1.269 → 0.1.271

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,20 @@ 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;
+    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,24 @@ 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 = [];
+    callSignalSeq = 0;
     /** 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 +720,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 +741,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 +1216,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/dora/dora-integration.js

@@ -413,11 +413,21 @@ export class DoraIntegration {
             try {
                 // One client per registry: this is the whole point — a merged call
                 // would hide exactly the failure we are looking for.
+                // Same channel and event as the constructor above, deliberately:
+                // dora speaks on packet 162 via sendDora / "dora-message", NOT on
+                // chat's packet 64. Reaching for sendText/"message" here sent every
+                // request down a channel the registry never reads, and produced four
+                // identical timeouts that looked exactly like four dead doras.
+                //
+                // Timeout matches too. 8s was optimistic: the comment on the
+                // constructor records that China -> overseas bootstrap -> relay ->
+                // the dora's own relay and back consistently blows past 10s, which
+                // is why the working path uses 30.
                 const one = new DoraClient({
                     registryUserids: [id],
-                    sendText: (to, text) => this.opts.peerManager.sendText(to, text),
-                    onText: (h) => this.opts.peerManager.on("message", (pubkey, text) => h(pubkey, text)),
-                    timeoutMs: 8000,
+                    sendText: (to, text) => this.opts.peerManager.sendDora(to, text),
+                    onText: (h) => this.opts.peerManager.on("dora-message", (from, text) => h(from, text)),
+                    timeoutMs: parseInt(process.env.AGENTNET_DORA_TIMEOUT_MS || "30000", 10),
                 });
                 const roster = await one.list();
                 return { userid: id, ok: Array.isArray(roster) && roster.length > 0,

package/dist/ui/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.269";
+window.__DK_UI_VERSION="0.1.271";
 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.269",
+  "version": "0.1.271",
   "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",