@decentnetwork/lan 0.1.166 → 0.1.176

package/dist/carrier/offline-call.d.ts

@@ -0,0 +1,69 @@
+import { EventEmitter } from "node:events";
+import { type RtcSignal } from "@decentnetwork/peer-webrtc";
+/**
+ * Configuration for the offline-call fallback. Defaults target the public
+ * Beagle gateways; the appKey/appName must match what the target device
+ * registered with (see the Beagle app's Service.swift).
+ */
+export interface OfflineCallConfig {
+    /** Master switch. When false the bridge is inert. */
+    enabled: boolean;
+    /** Beagle push appKey (matches the callee's registration). */
+    appKey: string;
+    /** Beagle push appName — the callee app's CFBundleName ("Beagle"/"webrtc"). */
+    appName: string;
+    /** Socket.IO signaling gateway (primary). */
+    socketUrl: string;
+    /** Ordered socket.IO gateways to try — connects to the first that comes up,
+     *  switches to the next on failure. Defaults to [socketUrl]. Both call peers
+     *  must agree on a server, so keep this list in sync with the Beagle apps. */
+    socketUrls?: string[];
+    /** Push-API endpoints (POST /push-api/push-message), tried in order. */
+    pushEndpoints?: string[];
+}
+export declare const DEFAULT_OFFLINE_CONFIG: Omit<OfflineCallConfig, "enabled">;
+/**
+ * Offline-call bridge — the socket.io + push path Beagle uses to reach a peer
+ * whose app is backgrounded/offline (so a live Carrier session doesn't exist).
+ *
+ * The daemon uses this as a FALLBACK: `sendCallSignal` tries Carrier first and
+ * drops to this only when there's no live session. Signaling then rides the
+ * socket.io room (keyed by the RtcSignal `callId`); the initial offer also fires
+ * a push to wake the callee. Inbound socket.io signals are re-emitted as
+ * `"signal"` events so the daemon forwards them to the browser exactly like
+ * Carrier invites.
+ *
+ * Runs entirely in the daemon (Node): socket.io-client for signaling, fetch for
+ * push. socket.io-client is an OPTIONAL dependency — if it isn't installed the
+ * bridge stays disabled and logs a hint rather than crashing.
+ */
+export declare class OfflineCallBridge extends EventEmitter {
+    #private;
+    constructor(opts: {
+        config: OfflineCallConfig;
+        selfUserId: string;
+        selfName: string;
+        log?: (msg: string) => void;
+    });
+    get enabled(): boolean;
+    /**
+     * Send a call signal to `userid` over the offline path. Decodes the signal to
+     * key the room by `callId`; for the initial offer it also pushes to wake the
+     * callee. Throws if the bridge can't be brought up (caller keeps the original
+     * Carrier error).
+     */
+    /** Extract the callId from a raw signal payload (undefined if not decodable). */
+    callIdOf(data: Uint8Array | string): string | undefined;
+    /** True once this call has fallen back to the offline path. */
+    isOfflineCall(callId: string): boolean;
+    /** Mark a call as committed to the Carrier (online) path. */
+    markOnlineCall(callId: string): void;
+    /** True once this call has committed to the Carrier path. */
+    isOnlineCall(callId: string): boolean;
+    /** Drop a finished call's transport state (best-effort cleanup). */
+    forgetCall(callId: string): void;
+    sendSignal(userid: string, data: Uint8Array | string, hasVideo: boolean): Promise<void>;
+    /** Tear down the socket connection (e.g. on daemon shutdown). */
+    close(): void;
+}
+export type { RtcSignal };

package/dist/carrier/offline-call.js

@@ -0,0 +1,192 @@
+import { EventEmitter } from "node:events";
+import { SocketIoSignaling, BeaglePushClient, decodeSignal, encodeSignalBytes } from "@decentnetwork/peer-webrtc";
+export const DEFAULT_OFFLINE_CONFIG = {
+    // From the Beagle app (Service.swift). Overridable via config.
+    appKey: "08726e938c624c4da9dcd9a85f2bbcd8",
+    appName: "Beagle",
+    socketUrl: "https://io.beagle.chat",
+    socketUrls: ["https://io.beagle.chat"],
+    pushEndpoints: [
+        "https://pushapi.beagle.chat/push-api/push-message",
+        "https://www.callpass.cn/push-api/push-message",
+        "https://tokyo.fi.chat:3004/push-api/push-message"
+    ]
+};
+/**
+ * Offline-call bridge — the socket.io + push path Beagle uses to reach a peer
+ * whose app is backgrounded/offline (so a live Carrier session doesn't exist).
+ *
+ * The daemon uses this as a FALLBACK: `sendCallSignal` tries Carrier first and
+ * drops to this only when there's no live session. Signaling then rides the
+ * socket.io room (keyed by the RtcSignal `callId`); the initial offer also fires
+ * a push to wake the callee. Inbound socket.io signals are re-emitted as
+ * `"signal"` events so the daemon forwards them to the browser exactly like
+ * Carrier invites.
+ *
+ * Runs entirely in the daemon (Node): socket.io-client for signaling, fetch for
+ * push. socket.io-client is an OPTIONAL dependency — if it isn't installed the
+ * bridge stays disabled and logs a hint rather than crashing.
+ */
+export class OfflineCallBridge extends EventEmitter {
+    #cfg;
+    #selfUserId;
+    #selfName;
+    #log;
+    #push;
+    #signaling;
+    #socket;
+    #connecting;
+    /** callIds that have fallen to the offline path — subsequent signals for them
+     *  skip the Carrier retry entirely (no per-signal 1.5s stall). */
+    #offlineCalls = new Set();
+    /** callIds committed to the Carrier (online) path — a later transient session
+     *  flap must NOT divert their signals to socket.io (splitting transports
+     *  mid-call breaks ICE: the peer gets candidates over two channels). */
+    #onlineCalls = new Set();
+    constructor(opts) {
+        super();
+        this.#cfg = opts.config;
+        this.#selfUserId = opts.selfUserId;
+        this.#selfName = opts.selfName;
+        this.#log = opts.log ?? (() => { });
+    }
+    get enabled() {
+        return this.#cfg.enabled;
+    }
+    /**
+     * Send a call signal to `userid` over the offline path. Decodes the signal to
+     * key the room by `callId`; for the initial offer it also pushes to wake the
+     * callee. Throws if the bridge can't be brought up (caller keeps the original
+     * Carrier error).
+     */
+    /** Extract the callId from a raw signal payload (undefined if not decodable). */
+    callIdOf(data) {
+        try {
+            return decodeSignal(data).callId || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** True once this call has fallen back to the offline path. */
+    isOfflineCall(callId) {
+        return this.#offlineCalls.has(callId);
+    }
+    /** Mark a call as committed to the Carrier (online) path. */
+    markOnlineCall(callId) {
+        this.#onlineCalls.add(callId);
+    }
+    /** True once this call has committed to the Carrier path. */
+    isOnlineCall(callId) {
+        return this.#onlineCalls.has(callId);
+    }
+    /** Drop a finished call's transport state (best-effort cleanup). */
+    forgetCall(callId) {
+        this.#offlineCalls.delete(callId);
+        this.#onlineCalls.delete(callId);
+    }
+    async sendSignal(userid, data, hasVideo) {
+        if (!this.#cfg.enabled)
+            throw new Error("offline calls disabled");
+        const signal = decodeSignal(data);
+        if (!signal.callId)
+            throw new Error("offline call signal has no callId");
+        this.#offlineCalls.add(signal.callId);
+        await this.#ensureConnected();
+        // Ring the callee for the first outbound signal of a call (the offer).
+        if (signal.type === "offer" && this.#push) {
+            const woke = await this.#push
+                .ring(userid, {
+                callerUserId: this.#selfUserId,
+                callId: signal.callId,
+                callerName: this.#selfName,
+                hasVideo,
+                channel: "socketio"
+            })
+                .catch(() => false);
+            this.#log(`offline call: push ${woke ? "sent" : "FAILED"} to ${userid} (call ${signal.callId})`);
+        }
+        this.#signaling.joinCall(signal.callId);
+        const kind = signal.type === "candidate"
+            ? `candidate(${signal.candidates?.length ?? 0})`
+            : signal.type === "event" ? `event:${signal.event}` : signal.type;
+        this.#log(`offline call: SEND ${kind} to ${userid} (call ${signal.callId})`);
+        this.#signaling.send(userid, signal);
+    }
+    /** Bring up the socket.io connection + signaling/push clients once. */
+    async #ensureConnected() {
+        if (this.#signaling)
+            return;
+        if (this.#connecting)
+            return this.#connecting;
+        this.#connecting = this.#connect();
+        try {
+            await this.#connecting;
+        }
+        finally {
+            this.#connecting = undefined;
+        }
+    }
+    async #connect() {
+        let io;
+        try {
+            // Optional dependency — imported lazily so the daemon runs without it.
+            const mod = (await import("socket.io-client"));
+            io = mod.io;
+        }
+        catch {
+            throw new Error("offline calls need socket.io-client — run `npm install socket.io-client` in decentlan");
+        }
+        // Try each gateway in order; connect to the first that comes up.
+        const urls = this.#cfg.socketUrls?.length ? this.#cfg.socketUrls : [this.#cfg.socketUrl];
+        let connectedUrl;
+        for (const url of urls) {
+            const sock = io(url, { transports: ["websocket"], forceNew: true, reconnection: false });
+            const ok = await new Promise((resolve) => {
+                const t = setTimeout(() => resolve(false), 7000);
+                sock.on("connect", () => { clearTimeout(t); resolve(true); });
+                sock.on("connect_error", () => { clearTimeout(t); resolve(false); });
+            });
+            if (ok) {
+                this.#socket = sock;
+                connectedUrl = url;
+                break;
+            }
+            this.#log(`offline call: socket gateway ${url} unreachable — trying next`);
+            try {
+                sock.disconnect?.();
+            }
+            catch { /* best-effort */ }
+        }
+        if (!this.#socket)
+            throw new Error(`offline calls: no reachable socket gateway (${urls.join(", ")})`);
+        this.#signaling = new SocketIoSignaling(this.#socket, { userId: this.#selfUserId });
+        this.#signaling.onSignal((peerId, signal) => {
+            // Re-emit inbound socket.io signals just like a Carrier invite so the
+            // daemon's existing call-signal queue forwards them to the browser.
+            const kind = signal.type === "candidate"
+                ? `candidate(${signal.candidates?.length ?? 0})`
+                : signal.type === "event" ? `event:${signal.event}` : signal.type;
+            this.#log(`offline call: RECV ${kind} from ${peerId} (call ${signal.callId ?? "?"})`);
+            this.emit("signal", { userid: peerId, data: encodeSignalBytes(signal) });
+        });
+        this.#push = new BeaglePushClient({
+            appKey: this.#cfg.appKey,
+            appName: this.#cfg.appName,
+            endpoints: this.#cfg.pushEndpoints
+        });
+        this.#log(`offline call bridge connected to ${connectedUrl}`);
+    }
+    /** Tear down the socket connection (e.g. on daemon shutdown). */
+    close() {
+        try {
+            this.#socket?.disconnect?.();
+        }
+        catch {
+            /* best-effort */
+        }
+        this.#socket = undefined;
+        this.#signaling = undefined;
+        this.#push = undefined;
+    }
+}

package/dist/carrier/peer-manager.d.ts

@@ -4,6 +4,7 @@
  */
 import { Peer } from "@decentnetwork/peer";
 import { EventEmitter } from "events";
+import { type OfflineCallConfig } from "./offline-call.js";
 import { PacketSession } from "./packet-session.js";
 import type { PeerIdentity, RemotePeer } from "./types.js";
 import type { BootstrapNode } from "../types.js";
@@ -21,6 +22,10 @@ export interface PeerManagerOptions {
     /** Directory for persisting partially-received files so a dropped/restarted
      *  transfer resumes instead of restarting (断点续传). */
     fileResumeDir?: string;
+    /** Offline-call fallback (socket.io + push). When enabled, a call to a peer
+     *  with no live Carrier session rings it via the Beagle push gateway and
+     *  signals over socket.io instead of failing. */
+    offlineCall?: OfflineCallConfig;
 }
 export declare class PeerManager extends EventEmitter {
     private peer;
@@ -28,6 +33,9 @@ export declare class PeerManager extends EventEmitter {
     private sessions;
     private sessionCounter;
     private logger;
+    private offlineBridge;
+    private offlineConfig;
+    private nickname;
     constructor();
     create(opts: PeerManagerOptions): Promise<void>;
     start(): Promise<void>;
@@ -70,10 +78,12 @@ export declare class PeerManager extends EventEmitter {
      * Send a WebRTC call-signaling payload to a friend over the Carrier
      * friend-invite channel (the "carrier" extension), the exact transport the
      * iOS/Android Beagle apps listen on for calls. `data` is an RtcSignal JSON
-     * string/bytes (see @decentnetwork/peer-webrtc). Realtime — requires a live
-     * session, no offline fallback.
+     * string/bytes (see @decentnetwork/peer-webrtc). Realtime over Carrier when a
+     * live session exists; otherwise falls back to the offline path (socket.io +
+     * push) when configured, so a call to a backgrounded/offline phone still
+     * rings instead of failing.
      */
-    sendCallSignal(userid: string, data: Uint8Array | string): Promise<void>;
+    sendCallSignal(userid: string, data: Uint8Array | string, hasVideo?: boolean): Promise<void>;
     /** True when the friend is a NATIVE Carrier client (iOS/Android/C): its
      *  relay/DHT key differs from its identity key. JS peers announce their
      *  identity key as their DHT key, so the two match. */

package/dist/carrier/peer-manager.js

@@ -4,6 +4,7 @@
  */
 import { Peer } from "@decentnetwork/peer";
 import { EventEmitter } from "events";
+import { OfflineCallBridge } from "./offline-call.js";
 import { PacketSession } from "./packet-session.js";
 import { FrameCodec } from "./frame.js";
 import { FRAME_OPCODE_HANDSHAKE_ACK, PACKET_ID_DL_SESSION, PACKET_ID_DL_DORA, PACKET_ID_DL_IP, PACKET_ID_DL_RATE, } from "./types.js";
@@ -14,12 +15,17 @@ export class PeerManager extends EventEmitter {
     sessions = new Map();
     sessionCounter = 1;
     logger;
+    offlineBridge = null;
+    offlineConfig = null;
+    nickname = "";
     constructor() {
         super();
         this.logger = new Logger({ prefix: "PeerManager" });
     }
     async create(opts) {
         this.logger.info("Creating Peer instance");
+        this.offlineConfig = opts.offlineCall ?? null;
+        this.nickname = opts.nickname ?? "";
         this.peer = await Peer.create({
             keyFile: opts.keyFile,
             compatibilityMode: "legacy",
@@ -50,6 +56,21 @@ export class PeerManager extends EventEmitter {
             userid: this.peer.userid(),
         };
         this.logger.info(`Peer started: ${this.identity.address}`);
+        // Bring up the offline-call fallback (socket.io + push) if configured.
+        // Signals it receives are re-emitted as "call-signal" — identical to a
+        // Carrier invite — so the daemon's existing browser bridge handles them.
+        if (this.offlineConfig?.enabled) {
+            this.offlineBridge = new OfflineCallBridge({
+                config: this.offlineConfig,
+                selfUserId: this.identity.userid,
+                selfName: this.nickname || this.identity.userid,
+                log: (m) => this.logger.info(m),
+            });
+            this.offlineBridge.on("signal", (evt) => {
+                this.emit("call-signal", { pubkey: evt.userid, data: evt.data });
+            });
+            this.logger.info("Offline-call fallback enabled (socket.io + push)");
+        }
     }
     async joinNetwork() {
         if (!this.peer) {
@@ -133,13 +154,45 @@ export class PeerManager extends EventEmitter {
      * Send a WebRTC call-signaling payload to a friend over the Carrier
      * friend-invite channel (the "carrier" extension), the exact transport the
      * iOS/Android Beagle apps listen on for calls. `data` is an RtcSignal JSON
-     * string/bytes (see @decentnetwork/peer-webrtc). Realtime — requires a live
-     * session, no offline fallback.
+     * string/bytes (see @decentnetwork/peer-webrtc). Realtime over Carrier when a
+     * live session exists; otherwise falls back to the offline path (socket.io +
+     * push) when configured, so a call to a backgrounded/offline phone still
+     * rings instead of failing.
      */
-    async sendCallSignal(userid, data) {
+    async sendCallSignal(userid, data, hasVideo = true) {
         if (!this.peer)
             throw new Error("Peer not created. Call create() first.");
-        await this.peer.sendInvite(userid, data, { ext: "carrier" });
+        // Once a call has fallen to the offline path, keep every later signal for it
+        // on that path — don't re-attempt Carrier per signal (that stalled the UI
+        // ~1.5s each and reordered signals across transports).
+        const callId = this.offlineBridge?.enabled ? this.offlineBridge.callIdOf(data) : undefined;
+        if (callId && this.offlineBridge.isOfflineCall(callId)) {
+            await this.offlineBridge.sendSignal(userid, data, hasVideo);
+            return;
+        }
+        try {
+            // Fail fast (1.5s, not 5s) so an offline peer drops to push quickly.
+            await this.peer.sendInvite(userid, data, { ext: "carrier", establishTimeoutMs: 1500 });
+            // Committed to Carrier — keep this call there even if it briefly flaps.
+            if (callId)
+                this.offlineBridge?.markOnlineCall(callId);
+        }
+        catch (err) {
+            // A call already committed to Carrier must NOT split to socket.io on a
+            // transient flap (it breaks ICE). Drop this signal; ICE recovers via the
+            // other candidates / a retried offer.
+            if (callId && this.offlineBridge?.isOnlineCall(callId)) {
+                this.logger.info(`sendCallSignal: dropped a Carrier signal for online call ${callId} (${err.message})`);
+                return;
+            }
+            // No live session and not yet committed to Carrier — use the offline path.
+            if (this.offlineBridge?.enabled) {
+                this.logger.info(`sendCallSignal: Carrier failed (${err.message}) — offline path to ${userid}`);
+                await this.offlineBridge.sendSignal(userid, data, hasVideo);
+                return;
+            }
+            throw err;
+        }
     }
     /** True when the friend is a NATIVE Carrier client (iOS/Android/C): its
      *  relay/DHT key differs from its identity key. JS peers announce their

package/dist/daemon/server.js

@@ -5,6 +5,7 @@ import { resolve } from "path";
 import { EventEmitter } from "events";
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
 import { PeerManager } from "../carrier/peer-manager.js";
+import { DEFAULT_OFFLINE_CONFIG } from "../carrier/offline-call.js";
 import { TunDevice } from "../tun/tun-device.js";
 import { RouteManager } from "../tun/route-manager.js";
 import { Ipam } from "../ipam/ipam.js";
@@ -292,6 +293,18 @@ export class DaemonServer {
                 // Persist partially-received files so a dropped/restarted transfer
                 // resumes instead of restarting from 0 (断点续传).
                 fileResumeDir: resolve(this.configDir, "downloads", ".partial"),
+                // Offline-call fallback (socket.io + push): ring an offline/backgrounded
+                // phone via the Beagle push gateway when there's no live Carrier
+                // session. Enabled by default with the public Beagle gateways; override
+                // appKey/appName/socketUrl under `call:` in config.yaml.
+                offlineCall: {
+                    enabled: this.config.call?.offlineEnabled ?? true,
+                    appKey: this.config.call?.appKey ?? DEFAULT_OFFLINE_CONFIG.appKey,
+                    appName: this.config.call?.appName ?? DEFAULT_OFFLINE_CONFIG.appName,
+                    socketUrl: this.config.call?.socketUrl ?? DEFAULT_OFFLINE_CONFIG.socketUrl,
+                    socketUrls: this.config.call?.socketUrls ?? DEFAULT_OFFLINE_CONFIG.socketUrls,
+                    pushEndpoints: this.config.call?.pushEndpoints ?? DEFAULT_OFFLINE_CONFIG.pushEndpoints,
+                },
             });
             await this.peerManager.start();
             this.logger.info(`Identity: ${this.peerManager.getAddress()}`);
@@ -467,10 +480,12 @@ export class DaemonServer {
                     // Beagle apps themselves use. Detected via the DHT-key signature.
                     if (this.peerManager?.isNativeFriend(userid)) {
                         // The FileModel JSON envelope is base64 (inflates ~1.34x) + a little
-                        // JSON overhead, and the whole thing must fit the 5MB bulkmsg cap
-                        // (CARRIER_MAX_APP_BULKMSG_LEN). 3.5MB raw → ~4.7MB envelope, safely
-                        // under 5MB. (Was a conservative 2MB.)
-                        const INLINE_MAX = 3.5 * 1024 * 1024;
+                        // JSON overhead, and the whole thing must fit the 16MB bulkmsg cap
+                        // (CARRIER_MAX_APP_BULKMSG_LEN, raised from 5MB alongside the receive
+                        // reorder buffer in peer >= 0.1.87). 11MB raw → ~14.7MB envelope,
+                        // safely under 16MB. Needs BOTH ends on the raised cap. (Very large /
+                        // streaming transfers should use toxcore file transfer, not inline.)
+                        const INLINE_MAX = 11 * 1024 * 1024;
                         if (data.length > INLINE_MAX) {
                             throw new Error(`This friend is a native (iOS/Android) client — files are sent inline and limited to ` +
                                 `${(INLINE_MAX / 1024 / 1024).toFixed(1)} MB (this is ${(data.length / 1024 / 1024).toFixed(1)} MB).`);
@@ -563,6 +578,15 @@ export class DaemonServer {
                         });
                     }
                     const signals = this.callSignalQueue.splice(0, this.callSignalQueue.length);
+                    if (signals.length) {
+                        const kinds = signals.map((s) => { try {
+                            return JSON.parse(s.data).type;
+                        }
+                        catch {
+                            return "?";
+                        } }).join(",");
+                        this.logger.info(`call-poll -> browser: ${signals.length} signal(s) [${kinds}]`);
+                    }
                     return { signals };
                 },
                 subscribe: (emit) => {

package/dist/types.d.ts

@@ -193,6 +193,23 @@ export interface DecentAgentNetConfig {
     friends?: FriendsConfig;
     dora?: DoraConfig;
     forwarding?: ForwardingConfig;
+    call?: CallConfig;
+}
+export interface CallConfig {
+    /** Enable the offline-call fallback (socket.io + push). Default true. When a
+     *  call target has no live Carrier session, ring it via the Beagle push
+     *  gateway and signal over socket.io instead of failing. */
+    offlineEnabled?: boolean;
+    /** Beagle push appKey — must match what the callee's app registered with. */
+    appKey?: string;
+    /** Beagle push appName (the callee app's CFBundleName, e.g. "Beagle"). */
+    appName?: string;
+    /** Socket.IO signaling gateway URL (primary). */
+    socketUrl?: string;
+    /** Ordered socket.IO gateways to try (failover). Defaults to [socketUrl]. */
+    socketUrls?: string[];
+    /** Push-API endpoints (POST /push-api/push-message), tried in order. */
+    pushEndpoints?: string[];
 }
 export interface ForwardingConfig {
     /** Pace + fair-queue egress IP data (default true). Prevents one bursty flow

package/dist/ui/desktop/app.js

@@ -20,6 +20,7 @@ const ICON_PATHS = {
   qr: '<rect x="3" y="3" width="7" height="7" rx="1.5"/><rect x="14" y="3" width="7" height="7" rx="1.5"/><rect x="3" y="14" width="7" height="7" rx="1.5"/><path d="M14 14h3v3M21 14v.01M14 21h.01M17 21h.01M21 17v4"/>',
   // ---- app tiles ----
   video: '<path d="m22 8.5-5.4 3.5 5.4 3.5V8.5Z"/><rect x="2" y="6" width="14.5" height="12" rx="3"/>',
+  monitor: '<rect x="2" y="3" width="20" height="14" rx="2"/><path d="M8 21h8M12 17v4"/>',
   sparkles: '<path d="M12 3.5 13.6 9 19 10.5 13.6 12 12 17.5 10.4 12 5 10.5 10.4 9 12 3.5Z"/><path d="M19 3.5v3.2M20.6 5.1h-3.2"/><path d="M5 16v2.4M6.2 17.2H3.8"/>',
   mic: '<rect x="9" y="2.5" width="6" height="11.5" rx="3"/><path d="M5.5 11a6.5 6.5 0 0 0 13 0"/><path d="M12 17.5v3.5"/>',
   flask: '<path d="M9.5 3v6.2L4.8 17.4A2 2 0 0 0 6.5 20.5h11a2 2 0 0 0 1.7-3.1L14.5 9.2V3"/><path d="M8.5 3h7"/><path d="M7.3 15h9.4"/>',
@@ -1596,6 +1597,7 @@ function useCallController(selfId) {
   const [active, setActive] = React.useState(null);
   const [localStream, setLocalStream] = React.useState(null);
   const [remoteStream, setRemoteStream] = React.useState(null);
+  const [sharing, setSharing] = React.useState(false);
   const engineRef = React.useRef(null);
   React.useEffect(() => {
     if (!selfId || engineRef.current) return;
@@ -1610,12 +1612,19 @@ function useCallController(selfId) {
       signaling,
       createPeerConnection: (c) => new RTCPeerConnection(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));
     engine.on("stateChanged", (info, state) => setActive((a) => a && a.callId === info.callId ? { ...a, state } : a));
-    engine.on("localStream", (id, s) => setLocalStream(s));
+    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);
@@ -1633,18 +1642,17 @@ function useCallController(selfId) {
       engineRef.current = null;
     };
   }, [selfId]);
-  const start = React.useCallback(async (peerId, video) => {
+  const start = React.useCallback((peerId, video) => {
     const eng = engineRef.current;
     if (!eng) {
       alert("Calls unavailable (WebRTC not supported here)");
       return;
     }
-    try {
-      const callId = await eng.call(peerId, { audio: true, video: !!video });
-      setActive({ callId, peerId, video: !!video, direction: "outgoing", state: "ringing" });
-    } catch (e) {
+    setActive({ callId: null, peerId, video: !!video, direction: "outgoing", state: "ringing" });
+    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;
@@ -1666,7 +1674,7 @@ function useCallController(selfId) {
   const hangup = React.useCallback(() => {
     const eng = engineRef.current;
     setActive((a) => {
-      if (eng && a) eng.hangup(a.callId);
+      if (eng && a && a.callId) eng.hangup(a.callId);
       return null;
     });
     setLocalStream(null);
@@ -1674,13 +1682,23 @@ function useCallController(selfId) {
   }, []);
   const setMuted = React.useCallback((m) => {
     const eng = engineRef.current, a = active;
-    if (eng && a) eng.setLocalTrackEnabled(a.callId, "audio", !m);
+    if (eng && a && a.callId) eng.setLocalTrackEnabled(a.callId, "audio", !m);
+  }, [active]);
+  const toggleShare = React.useCallback(async () => {
+    const eng = engineRef.current, a = active;
+    if (!eng || !a || !a.callId) return;
+    try {
+      if (eng.isSharingScreen(a.callId)) await eng.stopScreenShare(a.callId);
+      else await eng.shareScreen(a.callId);
+    } catch (e) {
+      if (e && e.name !== "NotAllowedError") alert("Screen share failed: " + (e && e.message || e));
+    }
   }, [active]);
   const setVideoOn = React.useCallback((v) => {
     const eng = engineRef.current, a = active;
-    if (eng && a) eng.setLocalTrackEnabled(a.callId, "video", v);
+    if (eng && a && a.callId) eng.setLocalTrackEnabled(a.callId, "video", v);
   }, [active]);
-  return { incoming, active, localStream, remoteStream, start, accept, reject, hangup, setMuted, setVideoOn };
+  return { incoming, active, localStream, remoteStream, sharing, start, accept, reject, hangup, setMuted, setVideoOn, toggleShare };
 }
 function VideoSurface({ stream, muted, style }) {
   const ref = React.useCallback((el) => {
@@ -1790,7 +1808,8 @@ function CallOverlay({ T, ctl, peers }) {
     setMuted(n);
     ctl.setMuted(n);
   };
-  const controls = /* @__PURE__ */ React.createElement("div", { style: { display: "flex", gap: 18, alignItems: "flex-start" } }, /* @__PURE__ */ React.createElement(CallBtn, { icon: muted ? "micFill" : "mic", label: muted ? T && T.unmute || "unmute" : T && T.mute || "mute", active: muted, onClick: toggleMute }), /* @__PURE__ */ React.createElement(CallBtn, { icon: "phone", label: T && T.endCall || "end", danger: true, wide: true, onClick: ctl.hangup }));
+  const canShare = connected && typeof navigator !== "undefined" && navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia;
+  const controls = /* @__PURE__ */ React.createElement("div", { style: { display: "flex", gap: 18, alignItems: "flex-start" } }, /* @__PURE__ */ React.createElement(CallBtn, { icon: muted ? "micFill" : "mic", label: muted ? T && T.unmute || "unmute" : T && T.mute || "mute", active: muted, onClick: toggleMute }), canShare && /* @__PURE__ */ React.createElement(CallBtn, { icon: "monitor", label: ctl.sharing ? T && T.stopShare || "stop share" : T && T.share || "share", active: ctl.sharing, onClick: ctl.toggleShare }), /* @__PURE__ */ React.createElement(CallBtn, { icon: "phone", label: T && T.endCall || "end", danger: true, wide: true, onClick: ctl.hangup }));
   return /* @__PURE__ */ React.createElement("div", { style: { position: "fixed", inset: 0, zIndex: 70, background: "var(--bg)", display: "flex", flexDirection: "column" } }, ctl.remoteStream && /* @__PURE__ */ React.createElement(AudioSink, { stream: ctl.remoteStream }), /* @__PURE__ */ React.createElement("div", { style: { height: 52, flexShrink: 0, display: "flex", alignItems: "center", gap: 10, padding: "0 18px", borderBottom: "1px solid var(--line)" } }, /* @__PURE__ */ React.createElement(Icon, { name: video ? "video" : "phone", size: 16, color: "var(--accent)", stroke: 2 }), /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 13, fontWeight: 700, color: "var(--text)" } }, name), /* @__PURE__ */ React.createElement(Tag, { tone: connected ? "ok" : "warn" }, stateLabel), /* @__PURE__ */ React.createElement("div", { style: { flex: 1 } }), connected && /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 14, fontWeight: 700, color: "var(--text)", letterSpacing: 1 } }, mm, ":", ss)), video ? /* @__PURE__ */ React.createElement("div", { style: { flex: 1, position: "relative", padding: 18 } }, /* @__PURE__ */ React.createElement("div", { style: { position: "absolute", inset: 18, borderRadius: 14, overflow: "hidden", background: "#000", border: "1px solid var(--line)" } }, ctl.remoteStream ? /* @__PURE__ */ React.createElement(VideoSurface, { stream: ctl.remoteStream, muted: true, style: { width: "100%", height: "100%", objectFit: "cover" } }) : /* @__PURE__ */ React.createElement("div", { style: { width: "100%", height: "100%", display: "flex", alignItems: "center", justifyContent: "center" } }, /* @__PURE__ */ React.createElement(DkIdenticon, { seed: call.peerId, size: 92, radius: 22 }))), /* @__PURE__ */ React.createElement("div", { style: { position: "absolute", right: 30, bottom: 30, width: 220, height: 148, borderRadius: 12, overflow: "hidden", background: "#000", border: "1px solid var(--line)" } }, ctl.localStream ? /* @__PURE__ */ React.createElement(VideoSurface, { stream: ctl.localStream, muted: true, style: { width: "100%", height: "100%", objectFit: "cover", transform: "scaleX(-1)" } }) : /* @__PURE__ */ React.createElement("div", { style: { width: "100%", height: "100%", display: "flex", alignItems: "center", justifyContent: "center" } }, /* @__PURE__ */ React.createElement(Icon, { name: "userRound", size: 30, color: "var(--faint)", stroke: 1.4 }))), /* @__PURE__ */ React.createElement("div", { style: { position: "absolute", left: 0, right: 0, bottom: 30, display: "flex", justifyContent: "center" } }, /* @__PURE__ */ React.createElement("div", { style: { padding: "16px 26px", borderRadius: 20, background: "color-mix(in oklab, var(--panel), transparent 8%)", border: "1px solid var(--line)" } }, controls))) : /* @__PURE__ */ React.createElement("div", { style: { flex: 1, display: "flex", flexDirection: "column", alignItems: "center", justifyContent: "center", gap: 22 } }, /* @__PURE__ */ React.createElement("div", { style: { position: "relative", display: "flex", alignItems: "center", justifyContent: "center" } }, !connected && /* @__PURE__ */ React.createElement("span", { style: { position: "absolute", width: 150, height: 150, borderRadius: 999, border: "2px solid var(--accent)", animation: "dkpulse 2s ease-out infinite" } }), /* @__PURE__ */ React.createElement(DkIdenticon, { seed: call.peerId, size: 108, radius: 26 })), /* @__PURE__ */ React.createElement("div", { style: { textAlign: "center" } }, /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 22, fontWeight: 700, color: "var(--text)" } }, name), /* @__PURE__ */ React.createElement("div", { style: { marginTop: 8, fontFamily: "var(--mono)", fontSize: 12.5, color: "var(--faint)" } }, stateLabel)), /* @__PURE__ */ React.createElement("div", { style: { marginTop: 18 } }, controls)));
 }
 Object.assign(window, { useCallController, CallOverlay, IncomingCallModal });

package/dist/ui/desktop/vendor/peer-webrtc.js

@@ -28,10 +28,12 @@ var PeerWebRTC = (() => {
   // node_modules/@decentnetwork/peer-webrtc/dist/index.js
   var dist_exports = {};
   __export(dist_exports, {
+    BeaglePushClient: () => BeaglePushClient,
     BroadcastChannelSignaling: () => BroadcastChannelSignaling,
     CallEngine: () => CallEngine,
     CarrierSignaling: () => CarrierSignaling,
     Emitter: () => Emitter,
+    SocketIoSignaling: () => SocketIoSignaling,
     decodeSignal: () => decodeSignal,
     decodeSignalBytesGuard: () => decodeSignalBytesGuard,
     encodeSignal: () => encodeSignal,
@@ -151,7 +153,7 @@ var PeerWebRTC = (() => {
   var DEFAULT_ICE_SERVERS = [
     { urls: "stun:stun.l.google.com:19302" }
   ];
-  var _opts, _iceServers, _sessions, _CallEngine_instances, handleSignal_fn, onOffer_fn, onAnswer_fn, onCandidate_fn, onBye_fn, onAuxiliary_fn, createSession_fn, wirePeerConnection_fn, ensureRemoteStream_fn, attachLocalMedia_fn, flushLocalCandidates_fn, drainRemoteCandidates_fn, send_fn, sendByeSafe_fn, cleanup_fn, setState_fn, normId_fn, _toInfo, newCallId_fn, log_fn;
+  var _opts, _iceServers, _sessions, _CallEngine_instances, setOutgoingVideoTrack_fn, renegotiate_fn, handleSignal_fn, onOffer_fn, answerRenegotiation_fn, onAnswer_fn, onCandidate_fn, onBye_fn, onAuxiliary_fn, createSession_fn, wirePeerConnection_fn, ensureRemoteStream_fn, attachLocalMedia_fn, flushLocalCandidates_fn, drainRemoteCandidates_fn, send_fn, sendByeSafe_fn, cleanup_fn, setState_fn, normId_fn, _toInfo, newCallId_fn, log_fn;
   var CallEngine = class extends Emitter {
     constructor(opts) {
       var _a;
@@ -197,17 +199,26 @@ var PeerWebRTC = (() => {
      * "remoteStream"/"ended" as the call progresses.
      */
     async call(peerId, kinds = {}) {
-      var _a, _b, _c;
+      var _a, _b, _c, _d, _e;
       const audio = (_a = kinds.audio) != null ? _a : true;
       const video = (_b = kinds.video) != null ? _b : false;
       const data = (_c = kinds.data) != null ? _c : false;
       const callId = __privateMethod(this, _CallEngine_instances, newCallId_fn).call(this);
       const session = __privateMethod(this, _CallEngine_instances, createSession_fn).call(this, callId, peerId, "outgoing", { audio, video, data });
       await __privateMethod(this, _CallEngine_instances, attachLocalMedia_fn).call(this, session);
-      const offer = await session.pc.createOffer({
-        offerToReceiveAudio: audio,
-        offerToReceiveVideo: video
-      });
+      if (audio && !((_d = session.localStream) == null ? void 0 : _d.getAudioTracks().length)) {
+        try {
+          session.pc.addTransceiver("audio", { direction: "recvonly" });
+        } catch {
+        }
+      }
+      if (video && !((_e = session.localStream) == null ? void 0 : _e.getVideoTracks().length)) {
+        try {
+          session.pc.addTransceiver("video", { direction: "recvonly" });
+        } catch {
+        }
+      }
+      const offer = await session.pc.createOffer();
       await session.pc.setLocalDescription(offer);
       const options = [];
       if (audio)
@@ -275,6 +286,50 @@ var PeerWebRTC = (() => {
           track.enabled = enabled;
       }
     }
+    /** Start sharing the screen on an active call. Captures the display, sends it
+     *  as the outgoing video track (replacing the camera if any), and renegotiates
+     *  so the peer receives it. Works even with no camera. Ending the OS "stop
+     *  sharing" prompt reverts automatically. */
+    async shareScreen(callId) {
+      const session = __privateGet(this, _sessions).get(__privateMethod(this, _CallEngine_instances, normId_fn).call(this, callId));
+      if (!session)
+        throw new Error(`shareScreen: no call ${callId}`);
+      if (!__privateGet(this, _opts).getDisplayMedia)
+        throw new Error("screen share not supported here");
+      const screen = await __privateGet(this, _opts).getDisplayMedia({ video: true, audio: false });
+      const track = screen.getVideoTracks()[0];
+      if (!track)
+        return;
+      if (!session.screenStream)
+        session.cameraStream = session.localStream;
+      session.screenStream = screen;
+      await __privateMethod(this, _CallEngine_instances, setOutgoingVideoTrack_fn).call(this, session, track, screen);
+      track.addEventListener("ended", () => {
+        void this.stopScreenShare(callId);
+      });
+      await __privateMethod(this, _CallEngine_instances, renegotiate_fn).call(this, session);
+      __privateMethod(this, _CallEngine_instances, log_fn).call(this, `shareScreen started for ${callId}`);
+    }
+    /** Stop screen sharing; restore the camera track if there was one. */
+    async stopScreenShare(callId) {
+      var _a;
+      const session = __privateGet(this, _sessions).get(__privateMethod(this, _CallEngine_instances, normId_fn).call(this, callId));
+      if (!(session == null ? void 0 : session.screenStream))
+        return;
+      for (const t of session.screenStream.getTracks())
+        t.stop();
+      session.screenStream = void 0;
+      const camTrack = (_a = session.cameraStream) == null ? void 0 : _a.getVideoTracks()[0];
+      await __privateMethod(this, _CallEngine_instances, setOutgoingVideoTrack_fn).call(this, session, camTrack != null ? camTrack : null, session.cameraStream);
+      session.cameraStream = void 0;
+      await __privateMethod(this, _CallEngine_instances, renegotiate_fn).call(this, session);
+      __privateMethod(this, _CallEngine_instances, log_fn).call(this, `shareScreen stopped for ${callId}`);
+    }
+    /** True when the call is currently sharing the screen. */
+    isSharingScreen(callId) {
+      var _a;
+      return !!((_a = __privateGet(this, _sessions).get(__privateMethod(this, _CallEngine_instances, normId_fn).call(this, callId))) == null ? void 0 : _a.screenStream);
+    }
     /** Tear down every call (e.g. on app shutdown). */
     dispose() {
       for (const session of [...__privateGet(this, _sessions).values()]) {
@@ -287,6 +342,44 @@ var PeerWebRTC = (() => {
   _iceServers = new WeakMap();
   _sessions = new WeakMap();
   _CallEngine_instances = new WeakSet();
+  setOutgoingVideoTrack_fn = async function(session, track, stream) {
+    var _a;
+    const transceivers = session.pc.getTransceivers();
+    const tr = (_a = transceivers.find((t) => {
+      var _a2;
+      return ((_a2 = t.sender.track) == null ? void 0 : _a2.kind) === "video";
+    })) != null ? _a : transceivers.find((t) => {
+      var _a2;
+      return ((_a2 = t.receiver.track) == null ? void 0 : _a2.kind) === "video";
+    });
+    if (tr) {
+      await tr.sender.replaceTrack(track);
+      if (track) {
+        if (tr.direction === "recvonly")
+          tr.direction = "sendrecv";
+        else if (tr.direction === "inactive")
+          tr.direction = "sendonly";
+      }
+    } else if (track && stream) {
+      session.pc.addTrack(track, stream);
+    }
+    session.localStream = stream;
+    this.emit("localStream", session.callId, stream != null ? stream : new MediaStream());
+  };
+  renegotiate_fn = async function(session) {
+    try {
+      const offer = await session.pc.createOffer();
+      await session.pc.setLocalDescription(offer);
+      const options = [];
+      if (session.audio)
+        options.push("audio");
+      if (session.video || session.screenStream)
+        options.push("video");
+      await __privateMethod(this, _CallEngine_instances, send_fn).call(this, session.peerId, { type: "offer", sdp: offer.sdp, options, callId: session.callId });
+    } catch (err) {
+      __privateMethod(this, _CallEngine_instances, log_fn).call(this, `renegotiate failed: ${err.message}`);
+    }
+  };
   // ---- internals -------------------------------------------------------
   handleSignal_fn = function(peerId, signal) {
     switch (signal.type) {
@@ -317,7 +410,10 @@ var PeerWebRTC = (() => {
       return;
     const existing = __privateGet(this, _sessions).get(__privateMethod(this, _CallEngine_instances, normId_fn).call(this, signal.callId));
     if (existing) {
-      existing.pendingOffer = signal.sdp;
+      if (existing.hasReceivedSdp)
+        void __privateMethod(this, _CallEngine_instances, answerRenegotiation_fn).call(this, existing, signal.sdp);
+      else
+        existing.pendingOffer = signal.sdp;
       return;
     }
     const audio = signal.options ? signal.options.includes("audio") : true;
@@ -328,15 +424,27 @@ var PeerWebRTC = (() => {
     this.emit("incomingCall", __privateGet(this, _toInfo).call(this, session));
     __privateMethod(this, _CallEngine_instances, log_fn).call(this, `incoming call from ${peerId} callId=${signal.callId} audio=${audio} video=${video}`);
   };
+  answerRenegotiation_fn = async function(session, sdp) {
+    try {
+      await session.pc.setRemoteDescription({ type: "offer", sdp });
+      const answer = await session.pc.createAnswer();
+      await session.pc.setLocalDescription(answer);
+      await __privateMethod(this, _CallEngine_instances, send_fn).call(this, session.peerId, { type: "answer", sdp: answer.sdp, callId: session.callId });
+    } catch (err) {
+      __privateMethod(this, _CallEngine_instances, log_fn).call(this, `renegotiation answer failed: ${err.message}`);
+    }
+  };
   onAnswer_fn = function(peerId, signal) {
     const session = __privateGet(this, _sessions).get(__privateMethod(this, _CallEngine_instances, normId_fn).call(this, signal.callId));
-    if (!session || session.peerId !== peerId || !signal.sdp)
+    if (!session || !signal.sdp)
       return;
+    session.peerId = peerId;
     void (async () => {
       try {
         await session.pc.setRemoteDescription({ type: "answer", sdp: signal.sdp });
         session.hasReceivedSdp = true;
-        __privateMethod(this, _CallEngine_instances, setState_fn).call(this, session, "connecting");
+        if (session.state !== "connected")
+          __privateMethod(this, _CallEngine_instances, setState_fn).call(this, session, "connecting");
         await __privateMethod(this, _CallEngine_instances, drainRemoteCandidates_fn).call(this, session);
         await __privateMethod(this, _CallEngine_instances, flushLocalCandidates_fn).call(this, session);
       } catch (err) {
@@ -347,7 +455,7 @@ var PeerWebRTC = (() => {
   onCandidate_fn = function(peerId, signal) {
     var _a;
     const session = __privateGet(this, _sessions).get(__privateMethod(this, _CallEngine_instances, normId_fn).call(this, signal.callId));
-    if (!session || session.peerId !== peerId || !signal.candidates)
+    if (!session || !signal.candidates)
       return;
     for (const c of signal.candidates) {
       const init = {
@@ -365,7 +473,7 @@ var PeerWebRTC = (() => {
   onBye_fn = function(peerId, signal) {
     var _a;
     const session = __privateGet(this, _sessions).get(__privateMethod(this, _CallEngine_instances, normId_fn).call(this, signal.callId));
-    if (!session || session.peerId !== peerId)
+    if (!session)
       return;
     const reason = (_a = signal.reason) != null ? _a : "normal";
     const state = reason === "busy" ? "busy" : reason === "declined" ? "declined" : "ended";
@@ -375,7 +483,7 @@ var PeerWebRTC = (() => {
   };
   onAuxiliary_fn = function(peerId, signal) {
     const session = __privateGet(this, _sessions).get(__privateMethod(this, _CallEngine_instances, normId_fn).call(this, signal.callId));
-    if (!session || session.peerId !== peerId)
+    if (!session)
       return;
     if (signal.type === "event") {
       if (signal.event === "ringing")
@@ -427,12 +535,8 @@ var PeerWebRTC = (() => {
       }
     };
     pc.ontrack = (ev) => {
-      var _a;
-      const stream = (_a = ev.streams[0]) != null ? _a : __privateMethod(this, _CallEngine_instances, ensureRemoteStream_fn).call(this, session, ev.track);
-      if (session.remoteStream !== stream) {
-        session.remoteStream = stream;
-        this.emit("remoteStream", session.callId, stream);
-      }
+      const stream = __privateMethod(this, _CallEngine_instances, ensureRemoteStream_fn).call(this, session, ev.track);
+      this.emit("remoteStream", session.callId, stream);
     };
     pc.oniceconnectionstatechange = () => {
       switch (pc.iceConnectionState) {
@@ -459,7 +563,8 @@ var PeerWebRTC = (() => {
   ensureRemoteStream_fn = function(session, track) {
     if (!session.remoteStream)
       session.remoteStream = new MediaStream();
-    session.remoteStream.addTrack(track);
+    if (!session.remoteStream.getTracks().includes(track))
+      session.remoteStream.addTrack(track);
     return session.remoteStream;
   };
   attachLocalMedia_fn = async function(session) {
@@ -467,7 +572,24 @@ var PeerWebRTC = (() => {
       return;
     if (!__privateGet(this, _opts).getLocalMedia || !session.audio && !session.video)
       return;
-    const stream = await __privateGet(this, _opts).getLocalMedia({ audio: session.audio, video: session.video });
+    let stream;
+    try {
+      stream = await __privateGet(this, _opts).getLocalMedia({ audio: session.audio, video: session.video });
+    } catch (err) {
+      __privateMethod(this, _CallEngine_instances, log_fn).call(this, `getLocalMedia(audio:${session.audio},video:${session.video}) failed: ${err.message}`);
+      if (session.video && session.audio) {
+        try {
+          stream = await __privateGet(this, _opts).getLocalMedia({ audio: true, video: false });
+          __privateMethod(this, _CallEngine_instances, log_fn).call(this, `local camera unavailable \u2014 sending audio only, still receiving video, call ${session.callId}`);
+        } catch (err2) {
+          __privateMethod(this, _CallEngine_instances, log_fn).call(this, `audio-only fallback failed too: ${err2.message}`);
+        }
+      }
+    }
+    if (!stream) {
+      __privateMethod(this, _CallEngine_instances, log_fn).call(this, `no local media for ${session.callId}; connecting receive-only`);
+      return;
+    }
     session.localStream = stream;
     for (const track of stream.getTracks()) {
       session.pc.addTrack(track, stream);
@@ -631,5 +753,237 @@ var PeerWebRTC = (() => {
   };
   _peer = new WeakMap();
   _ext = new WeakMap();
+
+  // node_modules/@decentnetwork/peer-webrtc/dist/signaling/socketio.js
+  var _socket, _userId, _handler2, _rooms, _pending, _lastOffer, _wired, _SocketIoSignaling_instances, roomKey_fn, ensureRoom_fn, emitMessage_fn, wire_fn;
+  var SocketIoSignaling = class {
+    constructor(socket, opts) {
+      __privateAdd(this, _SocketIoSignaling_instances);
+      __privateAdd(this, _socket);
+      __privateAdd(this, _userId);
+      __privateAdd(this, _handler2);
+      /** Rooms we've asked to join (callId -> confirmed self-membership). */
+      __privateAdd(this, _rooms, /* @__PURE__ */ new Map());
+      /** Signals queued per room until the server confirms our membership. */
+      __privateAdd(this, _pending, /* @__PURE__ */ new Map());
+      /** Last offer per callId, RE-SENT when the peer joins the room — the callee
+       *  (woken by a push) joins seconds after we sent the offer, and socket.io does
+       *  NOT replay, so without this the peer never sees the offer and never
+       *  answers (offline call stuck at "connecting"). */
+      __privateAdd(this, _lastOffer, /* @__PURE__ */ new Map());
+      /** The remote peer id per room, learned from inbound messages so a queued
+       *  peer-greeting can be addressed. */
+      __privateAdd(this, _wired, false);
+      __privateSet(this, _socket, socket);
+      __privateSet(this, _userId, opts.userId);
+    }
+    onSignal(handler) {
+      __privateSet(this, _handler2, handler);
+      __privateMethod(this, _SocketIoSignaling_instances, wire_fn).call(this);
+    }
+    /**
+     * Deliver a signal to `peerId`. Joins the call's room (keyed by
+     * `signal.callId`) on first use and queues until the server confirms
+     * membership, then emits — mirroring the iOS provider, which queues until
+     * `connectToRoom`.
+     */
+    send(peerId, signal) {
+      var _a;
+      __privateMethod(this, _SocketIoSignaling_instances, wire_fn).call(this);
+      const callId = signal.callId;
+      if (!callId) {
+        __privateMethod(this, _SocketIoSignaling_instances, emitMessage_fn).call(this, signal);
+        return;
+      }
+      if (signal.type === "offer")
+        __privateGet(this, _lastOffer).set(callId, signal);
+      const room = __privateMethod(this, _SocketIoSignaling_instances, ensureRoom_fn).call(this, callId);
+      if (room.joined) {
+        __privateMethod(this, _SocketIoSignaling_instances, emitMessage_fn).call(this, signal);
+      } else {
+        const q = (_a = __privateGet(this, _pending).get(callId)) != null ? _a : [];
+        q.push(signal);
+        __privateGet(this, _pending).set(callId, q);
+      }
+    }
+    /**
+     * Explicitly join the room for an INCOMING call (e.g. after a push
+     * notification delivered the `callId`), so inbound signals for it are
+     * received. Safe to call more than once.
+     */
+    joinCall(callId) {
+      __privateMethod(this, _SocketIoSignaling_instances, wire_fn).call(this);
+      __privateMethod(this, _SocketIoSignaling_instances, ensureRoom_fn).call(this, callId);
+    }
+    /** Leave a call's room (best-effort) and forget its queued state. */
+    leaveCall(callId) {
+      __privateGet(this, _rooms).delete(callId);
+      __privateGet(this, _pending).delete(callId);
+      __privateGet(this, _lastOffer).delete(callId);
+      __privateGet(this, _socket).emit("leave-channel", { channel: __privateMethod(this, _SocketIoSignaling_instances, roomKey_fn).call(this, callId), sender: __privateGet(this, _userId) });
+    }
+  };
+  _socket = new WeakMap();
+  _userId = new WeakMap();
+  _handler2 = new WeakMap();
+  _rooms = new WeakMap();
+  _pending = new WeakMap();
+  _lastOffer = new WeakMap();
+  _wired = new WeakMap();
+  _SocketIoSignaling_instances = new WeakSet();
+  /** The socket.io ROOM key. The native Beagle apps join the room with the
+   *  call's `UUID.uuidString`, which Swift renders UPPERCASE — so a lowercase
+   *  `crypto.randomUUID()` from JS would land us in a DIFFERENT room and we'd
+   *  never receive the peer's answer/candidates. Canonicalize to UPPERCASE to
+   *  share the native peer's room. (The RtcSignal payload callId stays as-is;
+   *  the CallEngine matches it case-insensitively.) */
+  roomKey_fn = function(callId) {
+    return callId.toUpperCase();
+  };
+  ensureRoom_fn = function(callId) {
+    let room = __privateGet(this, _rooms).get(callId);
+    if (!room) {
+      room = { joined: false };
+      __privateGet(this, _rooms).set(callId, room);
+      __privateGet(this, _socket).emit("new-channel", { channel: __privateMethod(this, _SocketIoSignaling_instances, roomKey_fn).call(this, callId), sender: __privateGet(this, _userId) });
+    }
+    return room;
+  };
+  emitMessage_fn = function(signal) {
+    __privateGet(this, _socket).emit("message", { data: encodeSignal(signal), sender: __privateGet(this, _userId) });
+  };
+  wire_fn = function() {
+    if (__privateGet(this, _wired))
+      return;
+    __privateSet(this, _wired, true);
+    __privateGet(this, _socket).on("message", (...args) => {
+      var _a;
+      const payload = firstObject(args);
+      if (!(payload == null ? void 0 : payload.data) || !payload.sender)
+        return;
+      if (payload.sender === __privateGet(this, _userId))
+        return;
+      const signal = decodeSignalBytesGuard(payload.data);
+      if (signal)
+        (_a = __privateGet(this, _handler2)) == null ? void 0 : _a.call(this, payload.sender, signal);
+    });
+    __privateGet(this, _socket).on("connectToRoom", (...args) => {
+      const payload = firstObject(args);
+      const sender = payload == null ? void 0 : payload.sender;
+      if (!sender)
+        return;
+      if (sender === __privateGet(this, _userId)) {
+        for (const [callId, room] of __privateGet(this, _rooms)) {
+          room.joined = true;
+          const q = __privateGet(this, _pending).get(callId);
+          if (q && q.length) {
+            for (const sig of q)
+              __privateMethod(this, _SocketIoSignaling_instances, emitMessage_fn).call(this, sig);
+            __privateGet(this, _pending).delete(callId);
+          }
+        }
+      } else {
+        for (const callId of __privateGet(this, _rooms).keys()) {
+          __privateMethod(this, _SocketIoSignaling_instances, emitMessage_fn).call(this, { type: "event", callId, event: "online" });
+          const offer = __privateGet(this, _lastOffer).get(callId);
+          if (offer)
+            __privateMethod(this, _SocketIoSignaling_instances, emitMessage_fn).call(this, offer);
+        }
+      }
+    });
+    __privateGet(this, _socket).on("disconnectToRoom", (...args) => {
+      const payload = firstObject(args);
+      const sender = payload == null ? void 0 : payload.sender;
+      if (sender && sender === __privateGet(this, _userId)) {
+        for (const room of __privateGet(this, _rooms).values())
+          room.joined = false;
+      }
+    });
+  };
+  function firstObject(args) {
+    const first = args[0];
+    return first && typeof first === "object" ? first : void 0;
+  }
+
+  // node_modules/@decentnetwork/peer-webrtc/dist/signaling/push.js
+  var DEFAULT_ENDPOINTS = [
+    "https://pushapi.beagle.chat/push-api/push-message",
+    "https://www.callpass.cn/push-api/push-message",
+    "https://tokyo.fi.chat:3004/push-api/push-message"
+  ];
+  var _appKey, _appName, _endpoints, _fetch;
+  var BeaglePushClient = class {
+    constructor(opts) {
+      __privateAdd(this, _appKey);
+      __privateAdd(this, _appName);
+      __privateAdd(this, _endpoints);
+      __privateAdd(this, _fetch);
+      var _a, _b;
+      __privateSet(this, _appKey, opts.appKey);
+      __privateSet(this, _appName, opts.appName);
+      __privateSet(this, _endpoints, ((_a = opts.endpoints) == null ? void 0 : _a.length) ? opts.endpoints : DEFAULT_ENDPOINTS);
+      const f = (_b = opts.fetch) != null ? _b : globalThis.fetch;
+      if (!f)
+        throw new Error("BeaglePushClient: no fetch available \u2014 pass opts.fetch");
+      __privateSet(this, _fetch, f);
+    }
+    /**
+     * Ring an offline peer. `calleeUserId` is the destination (their Carrier user
+     * id); the payload describes the call. Tries each endpoint until one accepts.
+     * Resolves `true` on success, `false` if every endpoint failed.
+     */
+    async sendCallPush(calleeUserId, payload) {
+      var _a;
+      const params = new URLSearchParams({
+        account: calleeUserId,
+        payload: JSON.stringify(payload),
+        appKey: __privateGet(this, _appKey),
+        appName: __privateGet(this, _appName)
+      }).toString();
+      for (const endpoint of __privateGet(this, _endpoints)) {
+        try {
+          const url = endpoint + (endpoint.includes("?") ? "&" : "?") + params;
+          const res = await __privateGet(this, _fetch).call(this, url, { method: "POST" });
+          if (!res.ok)
+            continue;
+          const json = await res.json().catch(() => ({}));
+          const code = json.code;
+          const ok = code === void 0 || code === 0 || code === "0" || ((_a = json.data) == null ? void 0 : _a.success) === true;
+          if (ok)
+            return true;
+        } catch {
+        }
+      }
+      return false;
+    }
+    /** Convenience: ring `calleeUserId` for a call over `channel`. */
+    ring(calleeUserId, args) {
+      var _a;
+      return this.sendCallPush(calleeUserId, {
+        userId: args.callerUserId,
+        hasVideo: args.hasVideo ? "true" : "false",
+        callId: args.callId,
+        callName: args.callerName,
+        action: "call",
+        channel: (_a = args.channel) != null ? _a : "socketio"
+      });
+    }
+    /** Convenience: cancel a ring (e.g. caller hung up before answer). */
+    cancel(calleeUserId, args) {
+      var _a;
+      return this.sendCallPush(calleeUserId, {
+        userId: args.callerUserId,
+        hasVideo: args.hasVideo ? "true" : "false",
+        callId: args.callId,
+        callName: args.callerName,
+        action: "decline",
+        channel: (_a = args.channel) != null ? _a : "socketio"
+      });
+    }
+  };
+  _appKey = new WeakMap();
+  _appName = new WeakMap();
+  _endpoints = new WeakMap();
+  _fetch = new WeakMap();
   return __toCommonJS(dist_exports);
 })();

package/dist/ui/server.js

@@ -198,11 +198,13 @@ export function startFriendUi(opts) {
                 const file = join(DESKTOP_DIR, rel);
                 // Guard against path traversal: resolved file must stay under DESKTOP_DIR.
                 if (existsSync(file) && file.startsWith(DESKTOP_DIR)) {
-                    // app.js changes on every UI rebuild → never cache it. Vendored React
-                    // UMD is stable, so let it cache normally.
+                    // app.js AND vendor/peer-webrtc.js change on every rebuild / SDK bump
+                    // → never cache them, or the browser keeps running stale call/UI code
+                    // (this silently defeated every peer-webrtc fix). Only the truly stable
+                    // vendored libs (React UMD) may cache.
                     const headers = { "content-type": "application/javascript; charset=utf-8" };
-                    if (rel === "app.js")
-                        headers["cache-control"] = "no-store";
+                    const volatile = rel === "app.js" || rel.includes("peer-webrtc");
+                    headers["cache-control"] = volatile ? "no-store" : "public, max-age=31536000";
                     res.writeHead(200, headers);
                     res.end(readFileSync(file));
                     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.166",
+  "version": "0.1.176",
   "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,12 +79,13 @@
   },
   "dependencies": {
     "@decentnetwork/dora": "^0.1.13",
-    "@decentnetwork/peer": "^0.1.86",
-    "@decentnetwork/peer-webrtc": "^0.1.1",
+    "@decentnetwork/peer": "^0.1.91",
+    "@decentnetwork/peer-webrtc": "^0.2.8",
     "ink": "^5.2.1",
     "js-yaml": "^4.1.0",
     "node-forge": "^1.4.0",
     "react": "^18.3.1",
+    "socket.io-client": "^4.7.5",
     "yargs": "^17.7.2"
   },
   "devDependencies": {