@decentnetwork/beagle 0.1.5 → 0.1.7

package/README.md

@@ -28,6 +28,12 @@ Then open <http://localhost:8766>.
 Port 8766 rather than decentlan's 8765, so during the transition the old
 `agentnet ui` and Beagle can run side by side on one machine.
 
+## Calls (web ↔ Android)
+
+Online WebRTC with the Android app uses **Carrier bootstrap TURN**, not the
+tokyo messaging relay. See [docs/webrtc-android-interop.md](docs/webrtc-android-interop.md)
+for the failure modes and how the first-call cold-start was fixed.
+
 ## Status: Phase 1
 
 Beagle picks a **backend** for its Carrier identity. Exactly one is ever live,

package/dist/call-ice.d.ts

@@ -0,0 +1,14 @@
+import type { BootstrapNode } from "./node-config.js";
+export interface RtcIceServer {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+}
+/**
+ * Build RTCIceServer entries matching Android WebrtcClient.getIceServers().
+ */
+export declare function buildCarrierCallIceServers(opts: {
+    keyFile: string;
+    bootstrapNodes: BootstrapNode[];
+    limit?: number;
+}): Promise<RtcIceServer[]>;

package/dist/call-ice.js

@@ -0,0 +1,45 @@
+// Carrier bootstrap TURN credentials for browser WebRTC.
+//
+// Android online calls use CarrierExtension.getTurnServerInfo() →
+// carrier_get_turn_server(). We call @decentnetwork/peer getIceServers()
+// (0.1.136+) with the same credential scheme.
+import { readFileSync, existsSync } from "node:fs";
+import { carrierIdFromPublicKey, getIceServers } from "@decentnetwork/peer";
+function hexToBytes(hex) {
+    const clean = hex.trim().replace(/^0x/i, "");
+    if (clean.length % 2 !== 0)
+        throw new Error("odd hex length");
+    const out = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+}
+function loadKeyPair(keyFile) {
+    if (!existsSync(keyFile))
+        throw new Error(`key file missing: ${keyFile}`);
+    const parsed = JSON.parse(readFileSync(keyFile, "utf-8"));
+    if (parsed.format !== "decent-peer-tox-keypair-v1" || !parsed.publicKey || !parsed.secretKey) {
+        throw new Error(`unsupported key file: ${keyFile}`);
+    }
+    return {
+        publicKey: hexToBytes(parsed.publicKey),
+        secretKey: hexToBytes(parsed.secretKey),
+    };
+}
+/**
+ * Build RTCIceServer entries matching Android WebrtcClient.getIceServers().
+ */
+export async function buildCarrierCallIceServers(opts) {
+    const nodes = opts.bootstrapNodes.filter((n) => n?.host && n?.pk).slice(0, opts.limit ?? 3);
+    if (!nodes.length)
+        throw new Error("no bootstrap nodes for TURN");
+    const { publicKey, secretKey } = loadKeyPair(opts.keyFile);
+    return getIceServers({
+        bootstrapNodes: nodes,
+        ourUserid: carrierIdFromPublicKey(publicKey),
+        ourSecretKey: secretKey,
+        limit: opts.limit ?? 3,
+        includeTcpTurn: true,
+    });
+}

package/dist/cli.js

@@ -147,6 +147,10 @@ async function main() {
         routesPath: resolve(args.configDir, "routes.yaml"),
         doraRosterPath,
         downloadsDir: resolve(args.configDir, "downloads"),
+        callIce: {
+            keyFile: resolve(decentlanCarrierDir(args.configDir), "keypair.json"),
+            bootstrapNodes,
+        },
         meExtra: {
             // The panel reads "lan <x> · peer <y>". Report the real decentlan version
             // powering this backend, not beagle's own — conflating them made the

package/dist/desktop/app.js

@@ -1,4 +1,4 @@
-window.__DK_UI_VERSION="0.1.4";
+window.__DK_UI_VERSION="0.1.7";
 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"/>',
@@ -377,6 +377,98 @@ Object.assign(window, {
   DK_ME_FALLBACK,
   dkCopy
 });
+const DK_FALLBACK_ICE_SERVERS = [
+  { urls: "stun:stun.l.google.com:19302" },
+  { urls: "turn:tokyo.fi.chat:3478", username: "allcom", credential: "allcompass" },
+  { urls: "turn:tokyo.fi.chat:3478?transport=tcp", username: "allcom", credential: "allcompass" }
+];
+const DK_LIVE_ICE_SERVERS = [];
+let _dkIcePromise = null;
+let _dkIceWarmPromise = null;
+function dkWarmCallIce(iceServers) {
+  if (_dkIceWarmPromise)
+    return _dkIceWarmPromise;
+  if (!window.RTCPeerConnection || !iceServers || !iceServers.length) {
+    _dkIceWarmPromise = Promise.resolve();
+    return _dkIceWarmPromise;
+  }
+  _dkIceWarmPromise = new Promise((resolve) => {
+    let pc;
+    let finished = false;
+    const done = (why) => {
+      if (finished)
+        return;
+      finished = true;
+      try {
+        if (pc)
+          pc.close();
+      } catch (e) {
+      }
+      console.log("[rtc] ICE warmup done (" + why + ")");
+      resolve();
+    };
+    try {
+      pc = new RTCPeerConnection({ iceServers, iceTransportPolicy: "all" });
+      const timer = setTimeout(() => done("timeout"), 5e3);
+      pc.onicecandidate = (ev) => {
+        const c = ev.candidate && ev.candidate.candidate;
+        if (c && /typ relay/.test(c)) {
+          clearTimeout(timer);
+          done("relay");
+        }
+      };
+      pc.onicegatheringstatechange = () => {
+        if (pc.iceGatheringState === "complete") {
+          clearTimeout(timer);
+          done("gather-complete");
+        }
+      };
+      pc.createDataChannel("ice-warm");
+      pc.createOffer().then((o) => pc.setLocalDescription(o)).catch(() => done("offer-fail"));
+    } catch (e) {
+      done("error");
+    }
+  });
+  return _dkIceWarmPromise;
+}
+function dkLoadCallIceServers() {
+  if (_dkIcePromise)
+    return _dkIcePromise;
+  _dkIcePromise = (async () => {
+    try {
+      const r = await fetch("/api/call-ice-servers", { headers: { "cache-control": "no-cache" } });
+      const d = await r.json();
+      if (d && d.ok && Array.isArray(d.iceServers) && d.iceServers.length) {
+        DK_LIVE_ICE_SERVERS.splice(0, DK_LIVE_ICE_SERVERS.length, ...d.iceServers);
+        console.log("[rtc] Carrier bootstrap ICE servers:", DK_LIVE_ICE_SERVERS.map((s) => s.urls));
+        await dkWarmCallIce(DK_LIVE_ICE_SERVERS);
+        return DK_LIVE_ICE_SERVERS;
+      }
+      console.warn("[rtc] call-ice-servers unavailable:", d && d.error);
+    } catch (e) {
+      console.warn("[rtc] call-ice-servers fetch failed", e);
+    }
+    console.warn("[rtc] falling back to tokyo TURN \u2014 web\u2194Android online ICE may fail");
+    DK_LIVE_ICE_SERVERS.splice(0, DK_LIVE_ICE_SERVERS.length, ...DK_FALLBACK_ICE_SERVERS.map((s) => ({ ...s })));
+    await dkWarmCallIce(DK_LIVE_ICE_SERVERS);
+    return DK_LIVE_ICE_SERVERS;
+  })();
+  return _dkIcePromise;
+}
+function dkAwaitCallIceServers(ms) {
+  const budget = typeof ms === "number" ? ms : 1e4;
+  return Promise.race([
+    dkLoadCallIceServers(),
+    new Promise((resolve) => setTimeout(() => {
+      if (!DK_LIVE_ICE_SERVERS.length) {
+        DK_LIVE_ICE_SERVERS.splice(0, DK_LIVE_ICE_SERVERS.length, ...DK_FALLBACK_ICE_SERVERS.map((s) => ({ ...s })));
+        console.warn("[rtc] ICE wait timed out \u2014 using fallback");
+      }
+      resolve(DK_LIVE_ICE_SERVERS);
+    }, budget))
+  ]).then(() => DK_LIVE_ICE_SERVERS);
+}
+dkLoadCallIceServers();
 function dkRtcParseEnvelope(data) {
   const text = String(data || "").replace(/\0+$/u, "").trim();
   if (!text)
@@ -394,12 +486,20 @@ function dkRtcSignalBus() {
     return window.__dkRtcSignalBus;
   const PW = window.PeerWebRTC;
   const handlers = /* @__PURE__ */ new Map();
+  const pendingCalls = [];
+  const PENDING_CALL_CAP = 16;
   let started = false;
   let stopped = false;
   function emit(kind, userid, payload) {
     const set = handlers.get(kind);
-    if (!set)
+    if (!set || !set.size) {
+      if (kind === "call") {
+        pendingCalls.push({ userid, payload });
+        if (pendingCalls.length > PENDING_CALL_CAP)
+          pendingCalls.shift();
+      }
       return;
+    }
     for (const h of Array.from(set)) {
       try {
         h(userid, payload);
@@ -447,6 +547,17 @@ function dkRtcSignalBus() {
         handlers.set(kind, /* @__PURE__ */ new Set());
       handlers.get(kind).add(cb);
       this.start();
+      if (kind === "call" && pendingCalls.length) {
+        const queued = pendingCalls.splice(0);
+        console.log("[rtc] flushing " + queued.length + " buffered call signal(s)");
+        for (const q of queued) {
+          try {
+            cb(q.userid, q.payload);
+          } catch (e) {
+            console.warn("[rtc] buffered call handler failed", e);
+          }
+        }
+      }
       return () => {
         var _a;
         return (_a = handlers.get(kind)) == null ? void 0 : _a.delete(cb);
@@ -1853,7 +1964,15 @@ function Msg({ m, peer, T, onTheater, onDelete, onCancel, onRetry, onReveal, onC
         style: { background: "none", border: "none", cursor: "pointer", padding: 0, marginLeft: 2, display: "inline-flex", opacity: 0.55 }
       },
       /* @__PURE__ */ React.createElement(Icon, { name: "trash", size: 11, stroke: 2, color: "var(--faint)" })
-    ), mine && m.status === "queued" ? /* @__PURE__ */ React.createElement("span", { style: { display: "inline-flex", alignItems: "center", gap: 2 }, title: "waiting for peer \u2014 will send when they're online" }, /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--faint)" }), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, T.queued || "queued")) : mine && m.status && /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 12, stroke: 2.2, color: m.status === "read" ? "var(--accent)" : "var(--faint)" })))
+    ), mine && (m.status === "queued" || m.status === "sending") ? /* @__PURE__ */ React.createElement(
+      "span",
+      {
+        style: { display: "inline-flex", alignItems: "center", gap: 2 },
+        title: m.status === "sending" ? "delivering\u2026" : "waiting for peer \u2014 will send when they're online"
+      },
+      /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 11, stroke: 2.2, color: "var(--faint)" }),
+      /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, m.status === "sending" ? T.sendingMsg || "sending" : T.queued || "queued")
+    ) : mine && m.status && /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 12, stroke: 2.2, color: m.status === "read" ? "var(--accent)" : "var(--faint)" })))
   );
 }
 function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, onSendRtcFile, onAlias, onRemove, onOpenNet, onCall, onReloadThread }) {
@@ -2515,6 +2634,12 @@ const DK_FILE_RTC_KIND = "file";
 const DK_FILE_RTC_CHUNK = 16 * 1024;
 const DK_FILE_RTC_OPEN_TIMEOUT_MS = 2e4;
 const DK_FILE_RTC_SIGNAL_TTL_MS = 10 * 60 * 1e3;
+let _dkFileIcePromise = null;
+function dkFileIceServers() {
+  if (!_dkFileIcePromise)
+    _dkFileIcePromise = dkLoadCallIceServers();
+  return _dkFileIcePromise;
+}
 function dkFileRtcId() {
   if (window.crypto && window.crypto.randomUUID)
     return window.crypto.randomUUID();
@@ -2700,7 +2825,7 @@ function useRtcFileController(selfId, onReceivedFile) {
             console.warn("[file-rtc] duplicate offer ignored for " + fileId);
             return;
           }
-          const pc = new RTCPeerConnection({ iceServers: CALL_ICE_SERVERS });
+          const pc = new RTCPeerConnection({ iceServers: await dkFileIceServers() });
           pc.oniceconnectionstatechange = () => console.warn("[file-rtc] receiver ice=" + pc.iceConnectionState + " conn=" + pc.connectionState);
           pc.onconnectionstatechange = () => console.warn("[file-rtc] receiver conn=" + pc.connectionState + " ice=" + pc.iceConnectionState);
           pc.onicecandidate = (ev) => {
@@ -2768,7 +2893,7 @@ function useRtcFileController(selfId, onReceivedFile) {
     }
     const bus = dkRtcSignalBus();
     const fileId = dkFileRtcId();
-    const pc = new RTCPeerConnection({ iceServers: CALL_ICE_SERVERS });
+    const pc = new RTCPeerConnection({ iceServers: await dkFileIceServers() });
     const dc = pc.createDataChannel("agentnet-file", { ordered: true });
     const sess = { pc, dc, peerId, chunks: [], meta: null, pendingCandidates: [] };
     peersRef.current.set(fileId, sess);
@@ -2869,11 +2994,6 @@ function RtcFileInbox({ T, peers, ctl }) {
   }));
 }
 Object.assign(window, { useRtcFileController, RtcFileInbox });
-const CALL_ICE_SERVERS = [
-  { urls: "stun:stun.l.google.com:19302" },
-  { urls: "turn:tokyo.fi.chat:3478", username: "allcom", credential: "allcompass" },
-  { urls: "turn:tokyo.fi.chat:3478?transport=tcp", username: "allcom", credential: "allcompass" }
-];
 const VIDEO_CODEC_KEEP = /^video\/(H264|VP8|rtx|red|ulpfec)$/i;
 const SDP_BUDGET = 8192;
 function trimVideoCodecs(pc) {
@@ -2929,71 +3049,106 @@ function useCallController(selfId, onCallLog) {
       console.warn("[call] WebRTC or peer-webrtc unavailable \u2014 calls disabled");
       return;
     }
-    const { CallEngine } = window.PeerWebRTC;
-    const signaling = makeDaemonSignaling();
-    const engine = new CallEngine({
-      selfId,
-      signaling,
-      createPeerConnection: (c) => createLeanPeerConnection(c),
-      getLocalMedia: (k) => navigator.mediaDevices.getUserMedia({ audio: k.audio, video: k.video }),
-      getDisplayMedia: (c) => navigator.mediaDevices.getDisplayMedia(c || { video: true, audio: false }),
-      iceServers: CALL_ICE_SERVERS,
-      logger: (m) => console.log(m)
-    });
-    engine.on("incomingCall", (info) => {
-      setIncoming(info);
-      if (onCallLogRef.current)
-        onCallLogRef.current(info.peerId, !!info.video, "incoming");
-    });
-    engine.on("stateChanged", (info, state) => setActive((a) => a && a.callId === info.callId ? { ...a, state } : a));
-    engine.on("localStream", (id, s) => {
-      setLocalStream(s);
-      try {
-        setSharing(engine.isSharingScreen(id));
-      } catch (e) {
+    dkRtcSignalBus().start();
+    let cancelled = false;
+    let signaling = null;
+    (async () => {
+      await dkAwaitCallIceServers(1e4);
+      if (cancelled || engineRef.current)
+        return;
+      if (!DK_LIVE_ICE_SERVERS.length) {
+        console.warn("[call] no ICE servers after wait \u2014 calls will likely fail NAT");
       }
-    });
-    engine.on("remoteStream", (id, s) => setRemoteStream(s));
-    engine.on("ended", (id) => {
-      setActive((a) => a && a.callId === id ? null : a);
-      setIncoming((i) => i && i.callId === id ? null : i);
-      setLocalStream(null);
-      setRemoteStream(null);
-    });
-    engineRef.current = engine;
+      const { CallEngine } = window.PeerWebRTC;
+      signaling = makeDaemonSignaling();
+      const engine = new CallEngine({
+        selfId,
+        signaling,
+        createPeerConnection: (c) => createLeanPeerConnection(c),
+        getLocalMedia: (k) => navigator.mediaDevices.getUserMedia({ audio: k.audio, video: k.video }),
+        getDisplayMedia: (c) => navigator.mediaDevices.getDisplayMedia(c || { video: true, audio: false }),
+        iceServers: DK_LIVE_ICE_SERVERS,
+        logger: (m) => console.log(m)
+      });
+      if (cancelled) {
+        try {
+          signaling.stop();
+          engine.dispose();
+        } catch (e) {
+        }
+        return;
+      }
+      engine.on("incomingCall", (info) => {
+        setIncoming(info);
+        if (onCallLogRef.current)
+          onCallLogRef.current(info.peerId, !!info.video, "incoming");
+      });
+      engine.on("stateChanged", (info, state) => setActive((a) => a && a.callId === info.callId ? { ...a, state } : a));
+      engine.on("localStream", (id, s) => {
+        setLocalStream(s);
+        try {
+          setSharing(engine.isSharingScreen(id));
+        } catch (e) {
+        }
+      });
+      engine.on("remoteStream", (id, s) => setRemoteStream(s));
+      engine.on("ended", (id) => {
+        setActive((a) => a && a.callId === id ? null : a);
+        setIncoming((i) => i && i.callId === id ? null : i);
+        setLocalStream(null);
+        setRemoteStream(null);
+      });
+      engineRef.current = engine;
+      console.log("[call] CallEngine ready with ICE:", DK_LIVE_ICE_SERVERS.map((s) => s.urls));
+    })().catch((e) => console.warn("[call] engine init failed", e));
     return () => {
+      cancelled = true;
       try {
-        signaling.stop();
-        engine.dispose();
+        if (signaling)
+          signaling.stop();
+        if (engineRef.current)
+          engineRef.current.dispose();
       } catch (e) {
       }
       engineRef.current = null;
     };
   }, [selfId]);
-  const start = React.useCallback((peerId, video) => {
-    const eng = engineRef.current;
-    if (!eng) {
-      alert("Calls unavailable (WebRTC not supported here)");
-      return;
+  const waitEngine = React.useCallback(async () => {
+    for (let i = 0; i < 100; i++) {
+      if (engineRef.current)
+        return engineRef.current;
+      await new Promise((r) => setTimeout(r, 100));
     }
+    return null;
+  }, []);
+  const start = React.useCallback((peerId, video) => {
     setActive({ callId: null, peerId, video: !!video, direction: "outgoing", state: "ringing" });
     if (onCallLogRef.current)
       onCallLogRef.current(peerId, !!video, "outgoing");
-    eng.call(peerId, { audio: true, video: !!video }).then((callId) => setActive((a) => a && a.peerId === peerId && a.callId === null ? { ...a, callId } : a)).catch((e) => {
+    waitEngine().then((eng) => {
+      if (!eng)
+        throw new Error("Calls unavailable (engine not ready)");
+      return eng.call(peerId, { audio: true, video: !!video });
+    }).then((callId) => setActive((a) => a && a.peerId === peerId && a.callId === null ? { ...a, callId } : a)).catch((e) => {
       setActive((a) => a && a.peerId === peerId ? null : a);
       alert("Could not start call: " + (e && e.message || e));
     });
-  }, []);
-  const accept = React.useCallback(async () => {
-    const eng = engineRef.current;
+  }, [waitEngine]);
+  const accept = React.useCallback(() => {
+    let pending = null;
     setIncoming((inc) => {
-      if (eng && inc) {
-        setActive({ callId: inc.callId, peerId: inc.peerId, video: inc.video, direction: "incoming", state: "connecting" });
-        eng.accept(inc.callId).catch((e) => alert("Accept failed: " + (e && e.message || e)));
-      }
+      pending = inc;
       return null;
     });
-  }, []);
+    if (!pending)
+      return;
+    setActive({ callId: pending.callId, peerId: pending.peerId, video: pending.video, direction: "incoming", state: "connecting" });
+    waitEngine().then((eng) => {
+      if (!eng)
+        throw new Error("Calls unavailable (engine not ready)");
+      return eng.accept(pending.callId);
+    }).catch((e) => alert("Accept failed: " + (e && e.message || e)));
+  }, [waitEngine]);
   const reject = React.useCallback(() => {
     const eng = engineRef.current;
     setIncoming((inc) => {
@@ -3068,6 +3223,16 @@ function useRingtone(active) {
     }
     let stopped = false;
     const timers = [];
+    const stop = () => {
+      if (stopped)
+        return;
+      stopped = true;
+      timers.forEach(clearTimeout);
+      try {
+        ctx.close();
+      } catch (e) {
+      }
+    };
     const burst = () => {
       if (stopped || ctx.state === "closed")
         return;
@@ -3088,13 +3253,12 @@ function useRingtone(active) {
       timers.push(setTimeout(burst, 3e3));
     };
     burst();
+    window.addEventListener("pagehide", stop);
+    window.addEventListener("beforeunload", stop);
     return () => {
-      stopped = true;
-      timers.forEach(clearTimeout);
-      try {
-        ctx.close();
-      } catch (e) {
-      }
+      window.removeEventListener("pagehide", stop);
+      window.removeEventListener("beforeunload", stop);
+      stop();
     };
   }, [active]);
 }
@@ -3310,6 +3474,7 @@ const STR = {
     send: "Send",
     pickPeer: "Select a peer to open the conversation",
     queued: "queued",
+    sendingMsg: "sending",
     open: "open",
     retry: "Retry",
     cancel: "Cancel",
@@ -3404,6 +3569,7 @@ const STR = {
     send: "\u53D1\u9001",
     pickPeer: "\u9009\u62E9\u4E00\u4F4D\u597D\u53CB\u5F00\u59CB\u4F1A\u8BDD",
     queued: "\u5F85\u53D1\u9001",
+    sendingMsg: "\u53D1\u9001\u4E2D",
     open: "\u6253\u5F00",
     retry: "\u91CD\u8BD5",
     cancel: "\u53D6\u6D88",

package/dist/embedded-host.js

@@ -47,6 +47,10 @@ export class EmbeddedHost {
     #logger = new Logger({ prefix: "Beagle" });
     #opts;
     #events = new EventEmitter();
+    /** Per-peer delivery chains: background sends to one peer run strictly in
+     *  order, so a new message can never overtake an older one whose ACK is
+     *  still pending. Entry removed when the chain drains. */
+    #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. */
@@ -207,8 +211,22 @@ export class EmbeddedHost {
         // file chips oldest-first. Reading history() and pattern-matching its shape
         // would couple this to the store's serialization format for no reason.
         for (const msg of this.#messages.queuedOutgoing(pubkey)) {
-            if (!msg.file)
+            // Queued TEXT delivers here too — it used to be skipped, which made
+            // "queued" a terminal state for text: the clock icon never resolved.
+            if (!msg.file) {
+                try {
+                    await this.#node.sendText(pubkey, msg.text);
+                    this.#messages.setStatus(pubkey, msg.id, "sent");
+                    this.#events.emit("event", { type: "chat", userid: pubkey, dir: "out" });
+                }
+                catch (e) {
+                    // Still unreachable — stays queued for the next reconnect. Stop
+                    // flushing so later messages can't overtake this one.
+                    this.#logger.warn(`queued text flush failed: ${e.message}`);
+                    break;
+                }
                 continue;
+            }
             const path = resolve(this.outboxDir, msg.id);
             if (!existsSync(path))
                 continue;
@@ -347,10 +365,43 @@ export class EmbeddedHost {
             }
             case "chat-send": {
                 const text = String(req.text ?? "");
-                await this.#node.sendText(uid, text);
-                this.#messages.append(uid, "out", text, Date.now(), "sent");
+                if (!text)
+                    return {};
+                // Record the user's message BEFORE any network attempt. It used to be
+                // appended only after sendText resolved, so an ACK timeout made the
+                // user's own words vanish from their own thread — they watched the
+                // peer answer a question that wasn't on screen (INBOX 2026-08-02).
+                // A send failure is a delivery state ON the message, never its absence.
+                const msg = this.#messages.append(uid, "out", text, Date.now(), "sending");
                 this.#meta.ensure(uid);
                 this.#events.emit("event", { type: "chat", userid: uid, dir: "out" });
+                // Return NOW. The delivery attempt runs in the background — an ACK
+                // that takes 15s per hop must cost the network 15s, never the user
+                // (INBOX 2026-08-05: a peer that never ACKed made every send block
+                // the UI for 30s, which reads as "stuck" and provokes re-sends).
+                // Per-peer chaining keeps FIFO: anything queued flushes first, and a
+                // second send waits for this one's attempt before its own.
+                const prev = this.#sendChains.get(uid) ?? Promise.resolve();
+                const job = prev.then(async () => {
+                    await this.#flushOutbox(uid).catch(() => { });
+                    try {
+                        await this.#node.sendText(uid, text);
+                        this.#messages.setStatus(uid, msg.id, "sent");
+                    }
+                    catch (e) {
+                        // Offline peer or failed delivery: same recovery either way —
+                        // "queued" (the UI shows the clock) and #flushOutbox delivers it
+                        // on the friend's reconnect. A status update, not a failure.
+                        this.#logger.info(`send to ${uid.slice(0, 8)} queued: ${e.message}`);
+                        this.#messages.setStatus(uid, msg.id, "queued");
+                    }
+                    this.#events.emit("event", { type: "chat", userid: uid, dir: "out" });
+                });
+                this.#sendChains.set(uid, job);
+                void job.finally(() => {
+                    if (this.#sendChains.get(uid) === job)
+                        this.#sendChains.delete(uid);
+                });
                 return {};
             }
             case "chat-log-local":

package/dist/message-store.d.ts

@@ -14,10 +14,12 @@ export interface ChatMessage {
     ts: number;
     /** Stable per-message id (ts + per-process sequence) for UI keys / dedup. */
     id: string;
-    /** Outgoing-text delivery state. "queued" means the peer was offline when the
-     *  user hit send, so the daemon stored it and will deliver it (in order) the
-     *  moment the friend reconnects. Cleared once actually sent. */
-    status?: "queued" | "sent" | "failed";
+    /** Outgoing-text delivery state. "sending" = the background delivery attempt
+     *  is still running (chat-send returns before the network is consulted, so
+     *  the UI never blocks on a slow peer). "queued" = that attempt gave up; the
+     *  daemon will deliver it (in order) the moment the friend reconnects.
+     *  Cleared once actually sent. */
+    status?: "sending" | "queued" | "sent" | "failed";
     /** How this message traversed the network, for the UI to distinguish at a
      *  glance (different colors). "online" = live net_crypto session (direct/relay);
      *  "offline" = express store-and-forward (the friend or we were offline). Lets
@@ -52,11 +54,11 @@ export declare class MessageStore {
     /** Append a message and schedule a flush. Returns the stored message.
      *  Pass `status: "queued"` for an outgoing text the peer wasn't online to
      *  receive — the daemon flushes it on reconnect. */
-    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "queued" | "sent" | "failed", via?: "online" | "offline"): ChatMessage;
+    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "sending" | "queued" | "sent" | "failed", via?: "online" | "offline"): ChatMessage;
     /** Set (or, with undefined, clear) the delivery status on a text message.
      *  Used to flip a "queued" message to delivered once it's actually sent.
      *  No-op if the id isn't found or is a file entry. Returns true if patched. */
-    setStatus(peer: string, id: string, status?: "queued" | "sent" | "failed"): boolean;
+    setStatus(peer: string, id: string, status?: "sending" | "queued" | "sent" | "failed"): boolean;
     /** Outgoing messages still awaiting delivery (peer was offline), oldest
      *  first — both queued text and queued file chips. The daemon drains this
      *  on a friend's reconnect. */

package/dist/message-store.js

@@ -33,6 +33,11 @@ export class MessageStore {
             let total = 0;
             for (const [peer, msgs] of Object.entries(raw)) {
                 if (Array.isArray(msgs)) {
+                    // A "sending" state cannot survive a restart — the attempt it
+                    // described died with the process. Requeue so #flushOutbox owns it.
+                    for (const m of msgs)
+                        if (m.status === "sending")
+                            m.status = "queued";
                     this.byPeer.set(peer, msgs);
                     total += msgs.length;
                 }

package/dist/server.d.ts

@@ -37,6 +37,17 @@ export interface BeagleServerOptions {
     listenHost?: string;
     listenPort?: number;
     log?: (msg: string) => void;
+    /** Carrier identity keyfile + bootstrap fleet — used to mint TURN creds for
+     *  browser WebRTC so online calls use the same relays as Android
+     *  CarrierExtension.getTurnServerInfo(). */
+    callIce?: {
+        keyFile: string;
+        bootstrapNodes: Array<{
+            host: string;
+            port: number;
+            pk: string;
+        }>;
+    };
 }
 export declare function startBeagleServer(opts: BeagleServerOptions): {
     stop: () => void;

package/dist/server.js

@@ -645,6 +645,17 @@ export function startBeagleServer(opts) {
                 }
                 // Is THIS node one of the official exit nodes? (so the UI can badge it).
                 const meExit = DEFAULT_EXITS.find((e) => e.userid && e.userid === identity.userid);
+                // "online" must mean "on the Carrier network", and the two backends
+                // know that differently. The daemon has a TUN device, so a TUN IP is
+                // a fine proxy. The embedded backend NEVER creates a TUN — judging it
+                // by tun.ip pinned this light at false forever, and every
+                // beagle-desktop user (embedded-only, no root) saw a dead app while
+                // messages flowed normally (INBOX 2026-08-02). For embedded, ask the
+                // peer itself: a live TCP-relay connection or a joined DHT is being
+                // on the network. TUN keeps its own field (`lan`) — it answers "do I
+                // have a virtual LAN", which is a different question.
+                const dht = d.dht ?? null;
+                const embeddedOnline = !!dht && ((Number(dht.tcpRelayConnected) || 0) > 0 || (Number(dht.knownNodesCount) || 0) > 0);
                 const me = {
                     name: node.name || (identity.userid ?? "").slice(0, 8),
                     // Handle reads as a network address: <name>@decentnetwork.
@@ -654,7 +665,8 @@ export function startBeagleServer(opts) {
                     carrier: identity.address ?? "",
                     netKey: identity.userid ?? "",
                     ip: tun.ip ?? d.allocatedIp ?? "",
-                    online: !!tun.ip,
+                    online: node.backend === "embedded" ? embeddedOnline : !!tun.ip,
+                    lan: !!tun.ip,
                     lanVer: opts.meExtra?.lanVer ?? "",
                     peerVer: opts.meExtra?.peerVer ?? "",
                     channel: opts.meExtra?.channel ?? "@next",
@@ -861,6 +873,23 @@ export function startBeagleServer(opts) {
                 sendJson(res, r.ok ? 200 : 400, r);
                 return;
             }
+            // Carrier bootstrap TURN for browser RTCPeerConnection — same scheme as
+            // Android WebrtcClient.getIceServers() / carrier_get_turn_server().
+            if (req.method === "GET" && url === "/api/call-ice-servers") {
+                if (!opts.callIce) {
+                    sendJson(res, 503, { ok: false, error: "call ICE not configured" });
+                    return;
+                }
+                try {
+                    const { buildCarrierCallIceServers } = await import("./call-ice.js");
+                    const iceServers = await buildCarrierCallIceServers(opts.callIce);
+                    sendJson(res, 200, { ok: true, iceServers });
+                }
+                catch (error) {
+                    sendJson(res, 500, { ok: false, error: error.message });
+                }
+                return;
+            }
             if (req.method === "GET" && url === "/api/call-poll") {
                 // 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/beagle",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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",
@@ -27,7 +27,7 @@
   "dependencies": {
     "@decentnetwork/chat-components": "^0.1.3",
     "@decentnetwork/lan": "^0.1.256",
-    "@decentnetwork/peer": "^0.1.123",
+    "@decentnetwork/peer": "^0.1.136",
     "@decentnetwork/peer-webrtc": "^0.2.10",
     "js-yaml": "^4.1.0",
     "yargs": "^17.7.2"