@decentnetwork/lan 0.1.165 → 0.1.175

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

@@ -1633,18 +1633,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 +1665,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,11 +1673,11 @@ 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 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 };
 }
@@ -1694,8 +1693,53 @@ function AudioSink({ stream }) {
   }, [stream]);
   return /* @__PURE__ */ React.createElement("audio", { ref, autoPlay: true });
 }
+function useRingtone(active) {
+  React.useEffect(() => {
+    if (!active) return void 0;
+    let ctx;
+    try {
+      ctx = new (window.AudioContext || window.webkitAudioContext)();
+    } catch (e) {
+      return void 0;
+    }
+    if (ctx.state === "suspended") {
+      ctx.resume().catch(() => {
+      });
+    }
+    let stopped = false;
+    const timers = [];
+    const burst = () => {
+      if (stopped || ctx.state === "closed") return;
+      [440, 480].forEach((f) => {
+        const o = ctx.createOscillator(), g = ctx.createGain();
+        o.type = "sine";
+        o.frequency.value = f;
+        o.connect(g);
+        g.connect(ctx.destination);
+        const t = ctx.currentTime;
+        g.gain.setValueAtTime(1e-4, t);
+        g.gain.exponentialRampToValueAtTime(0.12, t + 0.05);
+        g.gain.setValueAtTime(0.12, t + 0.9);
+        g.gain.exponentialRampToValueAtTime(1e-4, t + 1);
+        o.start(t);
+        o.stop(t + 1.05);
+      });
+      timers.push(setTimeout(burst, 3e3));
+    };
+    burst();
+    return () => {
+      stopped = true;
+      timers.forEach(clearTimeout);
+      try {
+        ctx.close();
+      } catch (e) {
+      }
+    };
+  }, [active]);
+}
 function IncomingCallModal({ T, ctl, peers }) {
   const inc = ctl.incoming;
+  useRingtone(!!inc);
   if (!inc) return null;
   const peer = (peers || []).find((p) => p.id === inc.peerId) || { id: inc.peerId };
   const name = peer.alias || peer.name || shortKey(inc.peerId, 10, 6);

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,
@@ -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)
@@ -330,8 +341,9 @@ var PeerWebRTC = (() => {
   };
   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 });
@@ -347,7 +359,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 +377,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 +387,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")
@@ -467,7 +479,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 +660,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/package.json

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