@decentnetwork/beagle 0.1.9 → 0.1.11

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.9";
+window.__DK_UI_VERSION="0.1.11";
 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"/>',
@@ -509,12 +509,16 @@ function dkRtcSignalBus() {
     }
   }
   async function pollLoop() {
+    let cursor = null;
     while (!stopped) {
       let signals = [];
       try {
-        const r = await fetch("/api/call-poll", { headers: { "cache-control": "no-cache" } });
+        const u = cursor == null ? "/api/call-poll" : "/api/call-poll?since=" + cursor;
+        const r = await fetch(u, { headers: { "cache-control": "no-cache" } });
         const d = await r.json();
         signals = d && d.signals || [];
+        if (d && typeof d.cursor === "number")
+          cursor = d.cursor;
       } catch (e) {
         await new Promise((res) => setTimeout(res, 1e3));
         continue;
@@ -3145,14 +3149,19 @@ function useCallController(selfId, onCallLog) {
       alert("Could not start call: " + (e && e.message || e));
     });
   }, [waitEngine]);
+  const incomingRef = React.useRef(null);
+  React.useEffect(() => {
+    incomingRef.current = incoming;
+  }, [incoming]);
+  const activeRef = React.useRef(null);
+  React.useEffect(() => {
+    activeRef.current = active;
+  }, [active]);
   const accept = React.useCallback(() => {
-    let pending = null;
-    setIncoming((inc) => {
-      pending = inc;
-      return null;
-    });
+    const pending = incomingRef.current;
     if (!pending)
       return;
+    setIncoming(null);
     setActive({ callId: pending.callId, peerId: pending.peerId, video: pending.video, direction: "incoming", state: "connecting" });
     waitEngine().then((eng) => {
       if (!eng)
@@ -3162,19 +3171,17 @@ function useCallController(selfId, onCallLog) {
   }, [waitEngine]);
   const reject = React.useCallback(() => {
     const eng = engineRef.current;
-    setIncoming((inc) => {
-      if (eng && inc)
-        eng.reject(inc.callId);
-      return null;
-    });
+    const inc = incomingRef.current;
+    if (eng && inc)
+      eng.reject(inc.callId);
+    setIncoming(null);
   }, []);
   const hangup = React.useCallback(() => {
     const eng = engineRef.current;
-    setActive((a) => {
-      if (eng && a && a.callId)
-        eng.hangup(a.callId);
-      return null;
-    });
+    const a = activeRef.current;
+    if (eng && a && a.callId)
+      eng.hangup(a.callId);
+    setActive(null);
     setLocalStream(null);
     setRemoteStream(null);
   }, []);

package/dist/embedded-host.d.ts

@@ -36,4 +36,6 @@ export declare class EmbeddedHost implements PeerHost {
     subscribe(emit: (event: Record<string, unknown>) => void): () => void;
     stop(): Promise<void>;
     call(req: IpcRequest): Promise<IpcResponse>;
+    /** Signals older than this have no business ringing a phone. */
+    static readonly CALL_SIGNAL_TTL_MS = 90000;
 }

package/dist/embedded-host.js

@@ -8,6 +8,7 @@
 // What is deliberately NOT here, versus the daemon: virtual IPs, exits, dora,
 // ACL, packet routing. Those are decentlan's job and need privilege beagle
 // refuses to ask for.
+var _a;
 import { EventEmitter } from "node:events";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile, unlink } from "node:fs/promises";
@@ -53,8 +54,19 @@ export class EmbeddedHost {
     #sendChains = new Map();
     /** Friend requests held for manual accept when auto-accept is off. */
     #pending = new Map();
-    /** Inbound call signals waiting for the UI's long-poll to collect them. */
-    #callQueue = [];
+    /** Inbound call signals as a broadcast ring: every poller reads at its own
+     *  cursor, entries expire by AGE, never by being read. The previous shape —
+     *  a queue drained by splice(0) — handed the whole batch to whichever
+     *  poller arrived first, so with two tabs open an incoming call rang a
+     *  random one and the tab the user was looking at stayed silent
+     *  (INBOX 2026-08-05: "能打出去接不进来"). */
+    #callLog = [];
+    /** Seeded with the epoch so a cursor from a PREVIOUS process incarnation is
+     *  always smaller than any new signal's seq. Seeded at 0, a restart made
+     *  every open tab deaf: their old cursor (say 27) exceeded the fresh
+     *  counter, so `seq > since` never matched and calls stopped ringing until
+     *  a hard refresh. */
+    #callSeq = Date.now();
     #callWaiters = [];
     /** fileId -> which chat message it belongs to, so progress can patch it. */
     #activeSends = new Map();
@@ -147,8 +159,14 @@ export class EmbeddedHost {
             }
         });
         this.#node.on("call-signal", (evt) => {
-            this.#callQueue.push({ userid: evt.pubkey, data: Buffer.from(evt.data).toString("utf-8") });
-            // Release every long-poll waiting on this queue.
+            this.#callLog.push({
+                seq: ++this.#callSeq,
+                ts: Date.now(),
+                userid: evt.pubkey,
+                data: Buffer.from(evt.data).toString("utf-8"),
+            });
+            this.#pruneCallLog();
+            // Wake every long-poll; each reads from its own cursor, nobody consumes.
             const waiters = this.#callWaiters.splice(0);
             for (const w of waiters)
                 w();
@@ -495,32 +513,46 @@ export class EmbeddedHost {
                 await this.#node.sendCallSignal(uid, String(req.text ?? req.data ?? ""));
                 return {};
             case "call-poll":
-                return { signals: await this.#pollCalls() };
+                return this.#pollCalls(typeof req.since === "number" ? req.since : undefined);
             default:
                 throw new Error(`Unsupported op in embedded backend: ${req.op}`);
         }
     }
-    /** Long-poll: return immediately if signals are queued, else hold ~20s. The
-     *  UI re-polls, which gives near-instant offer/answer delivery without a
-     *  WebSocket. Matches the daemon's behaviour exactly so call.jsx is unchanged. */
-    async #pollCalls() {
-        if (this.#callQueue.length)
-            return this.#callQueue.splice(0);
-        await new Promise((res) => {
-            const done = () => {
-                clearTimeout(timer);
-                res();
-            };
-            const timer = setTimeout(() => {
-                const i = this.#callWaiters.indexOf(done);
-                if (i >= 0)
-                    this.#callWaiters.splice(i, 1);
-                res();
-            }, 20_000);
-            timer.unref?.();
-            this.#callWaiters.push(done);
-        });
-        return this.#callQueue.splice(0);
+    /** Signals older than this have no business ringing a phone. */
+    static CALL_SIGNAL_TTL_MS = 90_000;
+    #pruneCallLog() {
+        const cutoff = Date.now() - _a.CALL_SIGNAL_TTL_MS;
+        while (this.#callLog.length && this.#callLog[0].ts < cutoff)
+            this.#callLog.shift();
+    }
+    /** Long-poll at a cursor: every subscriber sees every signal (broadcast),
+     *  reading never consumes. `since` is the cursor from the previous
+     *  response; a caller without one (older UI) starts at "now" and gets only
+     *  future signals — exactly the old semantics minus the stealing. Returns
+     *  immediately when the log has anything past the cursor, else holds ~20s. */
+    async #pollCalls(since) {
+        const from = since ?? this.#callSeq;
+        this.#pruneCallLog();
+        let avail = this.#callLog.filter((s) => s.seq > from);
+        if (!avail.length) {
+            await new Promise((res) => {
+                const done = () => {
+                    clearTimeout(timer);
+                    res();
+                };
+                const timer = setTimeout(() => {
+                    const i = this.#callWaiters.indexOf(done);
+                    if (i >= 0)
+                        this.#callWaiters.splice(i, 1);
+                    res();
+                }, 20_000);
+                timer.unref?.();
+                this.#callWaiters.push(done);
+            });
+            this.#pruneCallLog();
+            avail = this.#callLog.filter((s) => s.seq > from);
+        }
+        return { signals: avail.map(({ userid, data }) => ({ userid, data })), cursor: this.#callSeq };
     }
     async #fileSend(userid, path) {
         const data = await readFile(path);
@@ -578,3 +610,4 @@ export class EmbeddedHost {
         return { fileId, name: safe, size: data.length };
     }
 }
+_a = EmbeddedHost;

package/dist/server.js

@@ -900,8 +900,17 @@ export function startBeagleServer(opts) {
                 // The daemon holds this up to ~20s (long-poll). opts.call's own IPC
                 // timeout is 30s, so it returns before that; on any error, resolve
                 // empty so the browser simply re-polls.
+                //
+                // `since` is the caller's broadcast cursor: signal delivery is
+                // per-subscriber, so two open tabs BOTH ring on an incoming call.
+                // Without it (older UI) the backend serves only future signals.
+                const sinceRaw = new URL(req.url || "/", "http://x").searchParams.get("since");
+                const since = sinceRaw !== null && sinceRaw !== "" ? Number(sinceRaw) : undefined;
                 try {
-                    const r = await opts.call({ op: "call-poll" });
+                    const r = await opts.call({
+                        op: "call-poll",
+                        ...(Number.isFinite(since) ? { since } : {}),
+                    });
                     sendJson(res, 200, r.ok ? r.data ?? { signals: [] } : { signals: [] });
                 }
                 catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Beagle — P2P chat, file transfer and calls for regular users, on the Decent Network. No admin privilege required.",
   "type": "module",
   "main": "./dist/index.js",