@decentnetwork/lan 0.1.214 → 0.1.217

package/dist/daemon/message-store.d.ts

@@ -33,7 +33,7 @@ export interface ChatMessage {
     file?: {
         name: string;
         size: number;
-        status?: "queued" | "sending" | "sent" | "failed";
+        status?: "queued" | "sending" | "sent" | "failed" | "cancelled";
         sent?: number;
         durationMs?: number;
         avgKbps?: number;
@@ -65,13 +65,13 @@ export declare class MessageStore {
     appendFile(peer: string, dir: "in" | "out", file: {
         name: string;
         size: number;
-        status?: "queued" | "sending" | "sent" | "failed";
+        status?: "queued" | "sending" | "sent" | "failed" | "cancelled";
         sent?: number;
     }, ts?: number): ChatMessage;
     /** Patch an existing file message's transfer fields (status / sent bytes).
      *  No-op if the id isn't found. Returns true if it patched. */
     patchFile(peer: string, id: string, patch: {
-        status?: "queued" | "sending" | "sent" | "failed";
+        status?: "queued" | "sending" | "sent" | "failed" | "cancelled";
         sent?: number;
         durationMs?: number;
         avgKbps?: number;

package/dist/daemon/server.d.ts

@@ -98,6 +98,12 @@ export declare class DaemonServer {
      *  restarts). Also ensures a friend-meta entry exists so the friend shows up
      *  in the UI list even before it's been renamed. */
     private logChat;
+    /** A live file send cannot make progress once the Carrier session drops.
+     *  Move any active chips for that peer out of "sending" immediately instead
+     *  of leaving the UI to show a misleading 1 KB/s forever. If the original
+     *  bytes are still in the outbox, queue it for the next reconnect; otherwise
+     *  mark failed and let the user explicitly retry/cancel. */
+    private markPeerActiveSendsInterrupted;
     /** On startup, re-queue any offline file transfer that was mid-flight when the
      *  daemon last stopped: an out chip stuck at "sending" whose bytes still sit in
      *  the outbox. Flips it back to "queued" so the next reconnect redelivers it

package/dist/daemon/server.js

@@ -585,7 +585,7 @@ export class DaemonServer {
                                 killed = true;
                         }
                         if (killed || wasActive) {
-                            this.messageStore?.patchFile(userid, id, { status: "failed", sent: 0, kbps: undefined });
+                            this.messageStore?.patchFile(userid, id, { status: "cancelled", sent: 0, kbps: undefined });
                             n++;
                         }
                         this.logger.info(`file-cancel peer=${userid.slice(0, 8)} msg=${id} killed=${killed ? 1 : 0} wasActive=${wasActive ? 1 : 0}`);
@@ -1007,6 +1007,9 @@ export class DaemonServer {
                 if (evt?.status === "connected" && evt.pubkey) {
                     void this.flushOutbox(evt.pubkey).catch((e) => this.logger.warn(`Outbox flush for ${evt.pubkey.slice(0, 8)} failed: ${e.message}`));
                 }
+                else if (evt?.status === "disconnected" && evt.pubkey) {
+                    this.markPeerActiveSendsInterrupted(evt.pubkey, "peer-disconnected");
+                }
             });
             // File transfer (toxcore-standard): auto-accept offers from friends and
             // save completed files under <configDir>/downloads/.
@@ -1395,6 +1398,35 @@ export class DaemonServer {
         this.friendMeta?.ensure(userid);
         this.ipcEvents.emit("event", { type: "chat", userid, dir });
     }
+    /** A live file send cannot make progress once the Carrier session drops.
+     *  Move any active chips for that peer out of "sending" immediately instead
+     *  of leaving the UI to show a misleading 1 KB/s forever. If the original
+     *  bytes are still in the outbox, queue it for the next reconnect; otherwise
+     *  mark failed and let the user explicitly retry/cancel. */
+    markPeerActiveSendsInterrupted(userid, reason) {
+        const affected = [...this.activeSends].filter(([, t]) => t.peer === userid);
+        if (!affected.length)
+            return;
+        let queued = 0;
+        let failed = 0;
+        for (const [fileId, t] of affected) {
+            this.activeSends.delete(fileId);
+            this.peerManager?.cancelSend(userid, fileId);
+            const canQueue = !!this.outboxDir && existsSync(resolve(this.outboxDir, t.msgId));
+            this.messageStore?.patchFile(userid, t.msgId, {
+                status: canQueue ? "queued" : "failed",
+                sent: 0,
+                kbps: undefined,
+            });
+            if (canQueue)
+                queued++;
+            else
+                failed++;
+        }
+        this.logger.warn(`Interrupted ${affected.length} active file send(s) to ${userid.slice(0, 8)} ` +
+            `(${reason}; queued=${queued}, failed=${failed})`);
+        this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+    }
     /** On startup, re-queue any offline file transfer that was mid-flight when the
      *  daemon last stopped: an out chip stuck at "sending" whose bytes still sit in
      *  the outbox. Flips it back to "queued" so the next reconnect redelivers it

package/dist/ui/desktop/app.js

@@ -332,6 +332,113 @@ Object.assign(window, {
   DK_ME_FALLBACK,
   dkCopy
 });
+function dkRtcParseEnvelope(data) {
+  const text = String(data || "").replace(/\0+$/u, "").trim();
+  if (!text) return null;
+  try {
+    const obj = JSON.parse(text);
+    if (obj && obj.dkRtc === 1 && typeof obj.kind === "string") return obj;
+  } catch (e) {
+  }
+  return null;
+}
+function dkRtcSignalBus() {
+  if (window.__dkRtcSignalBus) return window.__dkRtcSignalBus;
+  const PW = window.PeerWebRTC;
+  const handlers = /* @__PURE__ */ new Map();
+  let started = false;
+  let stopped = false;
+  function emit(kind, userid, payload) {
+    const set = handlers.get(kind);
+    if (!set) return;
+    for (const h of Array.from(set)) {
+      try {
+        h(userid, payload);
+      } catch (e) {
+        console.warn("[rtc] signal handler failed", e);
+      }
+    }
+  }
+  async function pollLoop() {
+    while (!stopped) {
+      let signals = [];
+      try {
+        const r = await fetch("/api/call-poll", { headers: { "cache-control": "no-cache" } });
+        const d = await r.json();
+        signals = d && d.signals || [];
+      } catch (e) {
+        await new Promise((res) => setTimeout(res, 1e3));
+        continue;
+      }
+      for (const s of signals) {
+        const env = dkRtcParseEnvelope(s.data);
+        if (env) {
+          emit(env.kind, s.userid, env);
+          continue;
+        }
+        if (PW) {
+          try {
+            emit("call", s.userid, PW.decodeSignal(s.data));
+          } catch (e) {
+          }
+        }
+      }
+    }
+  }
+  const bus = {
+    start() {
+      if (started) return;
+      started = true;
+      stopped = false;
+      pollLoop();
+    },
+    on(kind, cb) {
+      if (!handlers.has(kind)) handlers.set(kind, /* @__PURE__ */ new Set());
+      handlers.get(kind).add(cb);
+      this.start();
+      return () => {
+        var _a;
+        return (_a = handlers.get(kind)) == null ? void 0 : _a.delete(cb);
+      };
+    },
+    async send(userid, data) {
+      const body = JSON.stringify({ userid, data: typeof data === "string" ? data : JSON.stringify(data) });
+      const r = await fetch("/api/call-signal", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body
+      });
+      const d = await r.json().catch(() => ({ ok: r.ok }));
+      if (!d.ok) throw new Error(d.error || "call-signal send failed");
+    },
+    stop() {
+      stopped = true;
+    }
+  };
+  window.__dkRtcSignalBus = bus;
+  return bus;
+}
+function makeDaemonSignaling() {
+  const PW = window.PeerWebRTC;
+  const bus = dkRtcSignalBus();
+  let off = null;
+  return {
+    async send(peerId, signal) {
+      await bus.send(peerId, PW.encodeSignal(signal));
+    },
+    onSignal(cb) {
+      if (off) off();
+      off = bus.on("call", cb);
+    },
+    stop() {
+      if (off) {
+        off();
+        off = null;
+      }
+    }
+  };
+}
+Object.assign(window, { dkRtcSignalBus, makeDaemonSignaling });
 function DkIdenticon({ seed, size = 30, radius = 7 }) {
   const { cells, hue } = dkIdenticon(seed);
   const cell = size / 5;
@@ -1108,7 +1215,7 @@ function Msg({ m, peer, T, onTheater, onDelete, onCancel, onRetry, selMode, sele
       // Inline preview/player. Received media: as soon as it's saved.
       // Sent media: once it's fully delivered ('sent') — the daemon keeps a
       // local copy so it plays on the sender's side too.
-      (m.file.media === "image" || m.file.media === "video" || m.file.media === "audio") && (mine ? m.file.status === "sent" : m.file.status !== "sending" && m.file.status !== "failed" && m.file.status !== "queued") ? (
+      (m.file.media === "image" || m.file.media === "video" || m.file.media === "audio") && (mine ? m.file.status === "sent" : m.file.status !== "sending" && m.file.status !== "failed" && m.file.status !== "queued" && m.file.status !== "cancelled") ? (
         // Received media → inline preview / player, with name, size, download.
         /* @__PURE__ */ React.createElement("div", { style: {
           display: "flex",
@@ -1170,10 +1277,10 @@ function Msg({ m, peer, T, onTheater, onDelete, onCancel, onRetry, selMode, sele
           cursor: mine ? "default" : "pointer"
         };
         const icon = /* @__PURE__ */ React.createElement("div", { style: { width: 34, height: 34, borderRadius: 7, flexShrink: 0, background: mine ? "rgba(255,255,255,0.16)" : "var(--chip)", display: "flex", alignItems: "center", justifyContent: "center", color: mine ? "#fff" : "var(--accent)" } }, /* @__PURE__ */ React.createElement(Icon, { name: m.file.media === "image" ? "image" : m.file.media === "video" ? "video" : m.file.media === "audio" ? "play" : "file", size: 18, stroke: 1.9 }));
-        const meta = /* @__PURE__ */ React.createElement("div", { style: { minWidth: 0, flex: 1 } }, /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 12.5, fontWeight: 600, color: mine ? "#fff" : "var(--text)", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" } }, m.file.name), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 11, color: mine ? "rgba(255,255,255,0.7)" : "var(--faint)", marginTop: 1 } }, busy === "cancel" ? `${m.file.size} \xB7 ${T.cancelling || "Cancelling\u2026"}` : busy === "retry" ? `${m.file.size} \xB7 ${T.retrying || "Retrying\u2026"}` : m.file.status === "queued" ? `${m.file.size} \xB7 ${T.queued || "queued"}` : m.file.status === "sending" ? `${m.file.size} \xB7 ${dkPct(m.file.pct)}${m.file.kbps ? " \xB7 " + dkSpeed(m.file.kbps) : ""}` : m.file.status === "failed" ? `${m.file.size} \xB7 failed` : mine ? `${m.file.size} \xB7 sent` : `${m.file.size} \xB7 ${T.open || "open"}`));
+        const meta = /* @__PURE__ */ React.createElement("div", { style: { minWidth: 0, flex: 1 } }, /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 12.5, fontWeight: 600, color: mine ? "#fff" : "var(--text)", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" } }, m.file.name), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 11, color: mine ? "rgba(255,255,255,0.7)" : "var(--faint)", marginTop: 1 } }, busy === "cancel" ? `${m.file.size} \xB7 ${T.cancelling || "Cancelling\u2026"}` : busy === "retry" ? `${m.file.size} \xB7 ${T.retrying || "Retrying\u2026"}` : m.file.status === "queued" ? `${m.file.size} \xB7 ${T.queued || "queued"}` : m.file.status === "sending" ? `${m.file.size} \xB7 ${dkPct(m.file.pct)}${m.file.kbps ? " \xB7 " + dkSpeed(m.file.kbps) : ""}` : m.file.status === "failed" ? `${m.file.size} \xB7 failed` : m.file.status === "cancelled" ? `${m.file.size} \xB7 ${T.cancelled || "cancelled"}` : mine ? `${m.file.size} \xB7 sent` : `${m.file.size} \xB7 ${T.open || "open"}`));
         if (mine) {
           const btnBusy = !!busy;
-          return /* @__PURE__ */ React.createElement("div", { style: { ...cardStyle, opacity: btnBusy ? 0.85 : 1 } }, icon, meta, busy === "cancel" || busy === "retry" ? /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 16, stroke: 2, color: "rgba(255,255,255,0.85)" }) : m.file.status === "queued" ? /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 16, stroke: 2, color: "rgba(255,255,255,0.85)" }) : m.file.status === "sending" ? /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, fontWeight: 700, color: "rgba(255,255,255,0.9)", whiteSpace: "nowrap" } }, dkPct(m.file.pct), m.file.kbps ? " \xB7 " + dkSpeed(m.file.kbps) : "") : m.file.status === "failed" ? /* @__PURE__ */ React.createElement(Icon, { name: "x", size: 16, stroke: 2.4, color: "rgba(255,200,190,0.95)" }) : /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 16, stroke: 2, color: "rgba(255,255,255,0.85)" }), (m.file.status === "sending" || m.file.status === "queued" || busy === "cancel") && m.id && /* @__PURE__ */ React.createElement(
+          return /* @__PURE__ */ React.createElement("div", { style: { ...cardStyle, opacity: btnBusy ? 0.85 : 1 } }, icon, meta, busy === "cancel" || busy === "retry" ? /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 16, stroke: 2, color: "rgba(255,255,255,0.85)" }) : m.file.status === "queued" ? /* @__PURE__ */ React.createElement(Icon, { name: "clock", size: 16, stroke: 2, color: "rgba(255,255,255,0.85)" }) : m.file.status === "sending" ? /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 11, fontWeight: 700, color: "rgba(255,255,255,0.9)", whiteSpace: "nowrap" } }, dkPct(m.file.pct), m.file.kbps ? " \xB7 " + dkSpeed(m.file.kbps) : "") : m.file.status === "failed" || m.file.status === "cancelled" ? /* @__PURE__ */ React.createElement(Icon, { name: "x", size: 16, stroke: 2.4, color: "rgba(255,200,190,0.95)" }) : /* @__PURE__ */ React.createElement(Icon, { name: "checkCheck", size: 16, stroke: 2, color: "rgba(255,255,255,0.85)" }), (m.file.status === "sending" || m.file.status === "queued" || busy === "cancel") && m.id && /* @__PURE__ */ React.createElement(
             "button",
             {
               title: T.cancel || "cancel",
@@ -1260,6 +1367,7 @@ function Msg({ m, peer, T, onTheater, onDelete, onCancel, onRetry, selMode, sele
 }
 function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, onAlias, onRemove, onOpenNet, onCall, onReloadThread }) {
   const scrollRef = React.useRef(null);
+  const followScrollRef = React.useRef(true);
   const fileRef = React.useRef(null);
   const [menu, setMenu] = React.useState(false);
   const [selMode, setSelMode] = React.useState(false);
@@ -1284,6 +1392,7 @@ function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, o
     setFileBusy({});
     setFilePatch({});
     setFlash(null);
+    followScrollRef.current = true;
   }, [peer.id]);
   React.useEffect(() => {
     setFilePatch((p) => {
@@ -1307,9 +1416,18 @@ function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, o
       return { ...m, file: { ...m.file, ...filePatch[m.id] } };
     });
   }, [baseThread, filePatch]);
-  React.useEffect(() => {
-    if (scrollRef.current) scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
-  }, [peer.id, threadProp]);
+  const scrollToBottom = () => {
+    const el = scrollRef.current;
+    if (el) el.scrollTop = el.scrollHeight;
+  };
+  const updateFollowScroll = () => {
+    const el = scrollRef.current;
+    if (!el) return;
+    followScrollRef.current = el.scrollHeight - el.scrollTop - el.clientHeight < 80;
+  };
+  React.useLayoutEffect(() => {
+    if (followScrollRef.current) scrollToBottom();
+  }, [peer.id, thread]);
   const toggleSel = (id) => setSel((s) => {
     const n = new Set(s);
     n.has(id) ? n.delete(id) : n.add(id);
@@ -1334,7 +1452,7 @@ function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, o
         showFlash("err", msg);
         window.alert(msg);
       } else {
-        setFilePatch((p) => ({ ...p, [id]: { status: "failed", pct: void 0, kbps: void 0 } }));
+        setFilePatch((p) => ({ ...p, [id]: { status: "cancelled", pct: void 0, kbps: void 0 } }));
         showFlash("ok", T.cancelled || "Transfer cancelled");
         if (onReloadThread) onReloadThread();
       }
@@ -1417,17 +1535,23 @@ function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, o
   }, [theater]);
   const sendDraft = () => {
     if (draft.trim()) {
+      followScrollRef.current = true;
       onSend(draft);
       setDraft("");
+      requestAnimationFrame(scrollToBottom);
     }
   };
   const sendFiles = (files) => {
     if (!files || !files.length || !onSendFile) return;
     const file = files[0];
+    followScrollRef.current = true;
     setSending({ name: file.name });
     Promise.resolve(onSendFile(file)).then((r) => {
       if (r && r.ok === false) window.alert((lang === "zh" ? "\u53D1\u9001\u5931\u8D25: " : "Send failed: ") + (r.error || ""));
-    }).finally(() => setSending(null));
+    }).finally(() => {
+      setSending(null);
+      requestAnimationFrame(scrollToBottom);
+    });
   };
   const onDrop = (e) => {
     e.preventDefault();
@@ -1458,7 +1582,7 @@ function Conversation({ T, peer, lang, thread: threadProp, onSend, onSendFile, o
       setMenu(false);
       onRemove(peer);
     } }))))),
-    /* @__PURE__ */ React.createElement("div", { ref: scrollRef, style: { flex: 1, overflow: "auto", padding: "18px 22px" } }, /* @__PURE__ */ React.createElement("div", { style: { maxWidth: 760, margin: "0 auto" } }, thread.filter((m) => m.day || !hidden.has(m.id)).map((m, i) => m.day ? /* @__PURE__ */ React.createElement("div", { key: i, style: { display: "flex", justifyContent: "center", margin: "14px 0" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10.5, fontWeight: 600, color: "var(--faint)", background: "var(--chip)", padding: "3px 10px", borderRadius: 999 } }, m.day)) : /* @__PURE__ */ React.createElement(
+    /* @__PURE__ */ React.createElement("div", { ref: scrollRef, onScroll: updateFollowScroll, style: { flex: 1, overflow: "auto", padding: "18px 22px" } }, /* @__PURE__ */ React.createElement("div", { style: { maxWidth: 760, margin: "0 auto" } }, thread.filter((m) => m.day || !hidden.has(m.id)).map((m, i) => m.day ? /* @__PURE__ */ React.createElement("div", { key: i, style: { display: "flex", justifyContent: "center", margin: "14px 0" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10.5, fontWeight: 600, color: "var(--faint)", background: "var(--chip)", padding: "3px 10px", borderRadius: 999 } }, m.day)) : /* @__PURE__ */ React.createElement(
       Msg,
       {
         key: m.id || i,
@@ -1710,53 +1834,261 @@ function ProfileTab({ T, me, onEdit }) {
   } }));
 }
 Object.assign(window, { ProfileTab });
-function makeDaemonSignaling() {
-  const PW = window.PeerWebRTC;
-  let handler = null;
-  let stopped = false;
-  async function pollLoop() {
-    while (!stopped) {
-      let signals = [];
+const DK_FILE_RTC_KIND = "file";
+const DK_FILE_RTC_CHUNK = 64 * 1024;
+const DK_FILE_RTC_OPEN_TIMEOUT_MS = 8e3;
+const DK_FILE_RTC_SIGNAL_TTL_MS = 10 * 60 * 1e3;
+function dkFileRtcId() {
+  if (window.crypto && window.crypto.randomUUID) return window.crypto.randomUUID();
+  return "frtc-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2);
+}
+function dkFileRtcEnvelope(fileId, type, extra) {
+  return Object.assign({ dkRtc: 1, kind: DK_FILE_RTC_KIND, fileId, type, ts: Date.now() }, extra || {});
+}
+function dkWaitForOpen(dc, timeoutMs) {
+  if (dc.readyState === "open") return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new Error("WebRTC data channel open timed out"));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      dc.removeEventListener("open", onOpen);
+      dc.removeEventListener("error", onError);
+      dc.removeEventListener("close", onClose);
+    };
+    const onOpen = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error("WebRTC data channel failed"));
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("WebRTC data channel closed"));
+    };
+    dc.addEventListener("open", onOpen);
+    dc.addEventListener("error", onError);
+    dc.addEventListener("close", onClose);
+  });
+}
+function dkWaitBufferedLow(dc, highWater) {
+  if (dc.bufferedAmount < highWater) return Promise.resolve();
+  return new Promise((resolve) => {
+    const prev = dc.bufferedAmountLowThreshold;
+    dc.bufferedAmountLowThreshold = Math.floor(highWater / 2);
+    const done = () => {
+      dc.removeEventListener("bufferedamountlow", done);
+      dc.bufferedAmountLowThreshold = prev;
+      resolve();
+    };
+    dc.addEventListener("bufferedamountlow", done);
+  });
+}
+function dkFileDownload(blob, name) {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = name || "agentnet-file";
+  a.textContent = name || "agentnet-file";
+  return { url, name: a.download };
+}
+function useRtcFileController(selfId, onReceivedText) {
+  const [incoming, setIncoming] = React.useState([]);
+  const peersRef = React.useRef(/* @__PURE__ */ new Map());
+  React.useEffect(() => {
+    if (!selfId || !window.RTCPeerConnection || !window.dkRtcSignalBus) return;
+    const bus = dkRtcSignalBus();
+    const cleanup = (fileId) => {
+      const sess = peersRef.current.get(fileId);
+      if (!sess) return;
       try {
-        const r = await fetch("/api/call-poll", { headers: { "cache-control": "no-cache" } });
-        const d = await r.json();
-        signals = d && d.signals || [];
+        sess.dc && sess.dc.close();
       } catch (e) {
-        await new Promise((res) => setTimeout(res, 1e3));
-        continue;
       }
-      for (const s of signals) {
-        try {
-          const signal = PW.decodeSignal(s.data);
-          handler && handler(s.userid, signal);
-        } catch (e) {
+      try {
+        sess.pc && sess.pc.close();
+      } catch (e) {
+      }
+      peersRef.current.delete(fileId);
+    };
+    const sendSignal = (peerId, fileId, type, extra) => bus.send(peerId, dkFileRtcEnvelope(fileId, type, extra));
+    const handleDataChannel = (peerId, fileId, pc, dc, initialMeta) => {
+      dc.binaryType = "arraybuffer";
+      const prev = peersRef.current.get(fileId);
+      const sess = Object.assign(prev || {}, { pc, dc, peerId, meta: initialMeta || null, chunks: [], received: 0 });
+      peersRef.current.set(fileId, sess);
+      dc.onmessage = (ev) => {
+        if (typeof ev.data === "string") {
+          let msg = null;
+          try {
+            msg = JSON.parse(ev.data);
+          } catch (e) {
+          }
+          if (!msg) return;
+          if (msg.type === "meta") {
+            sess.meta = msg;
+            sess.chunks = [];
+            sess.received = 0;
+          } else if (msg.type === "done") {
+            const meta = sess.meta || {};
+            const blob = new Blob(sess.chunks, { type: meta.mime || "application/octet-stream" });
+            const dl = dkFileDownload(blob, meta.name || "agentnet-file");
+            setIncoming((arr) => [{ id: fileId, peerId, name: dl.name, size: blob.size, url: dl.url }].concat(arr).slice(0, 8));
+            if (onReceivedText) onReceivedText(peerId, "received file via WebRTC: " + dl.name + " (" + dkFileSize(blob.size) + ")");
+            cleanup(fileId);
+          } else if (msg.type === "cancel") {
+            cleanup(fileId);
+          }
+          return;
         }
+        sess.chunks.push(ev.data);
+        sess.received += ev.data.byteLength || ev.data.size || 0;
+      };
+      dc.onclose = () => setTimeout(() => cleanup(fileId), 1e3);
+      dc.onerror = () => cleanup(fileId);
+    };
+    const off = bus.on(DK_FILE_RTC_KIND, async (peerId, env) => {
+      if (!env || !env.fileId || !env.type) return;
+      if (Date.now() - (env.ts || Date.now()) > DK_FILE_RTC_SIGNAL_TTL_MS) return;
+      const fileId = env.fileId;
+      let sess = peersRef.current.get(fileId);
+      try {
+        if (env.type === "offer") {
+          if (sess) cleanup(fileId);
+          const pc = new RTCPeerConnection({ iceServers: CALL_ICE_SERVERS });
+          pc.onicecandidate = (ev) => {
+            if (ev.candidate) sendSignal(peerId, fileId, "candidate", { candidate: ev.candidate.toJSON() }).catch(() => {
+            });
+          };
+          pc.ondatachannel = (ev) => handleDataChannel(peerId, fileId, pc, ev.channel, env.meta || null);
+          peersRef.current.set(fileId, { pc, dc: null, peerId, chunks: [], meta: env.meta || null, pendingCandidates: [] });
+          await pc.setRemoteDescription({ type: "offer", sdp: env.sdp });
+          sess = peersRef.current.get(fileId);
+          if (sess && sess.pendingCandidates) {
+            for (const c of sess.pendingCandidates.splice(0)) {
+              try {
+                await pc.addIceCandidate(c);
+              } catch (e) {
+              }
+            }
+          }
+          const answer = await pc.createAnswer();
+          await pc.setLocalDescription(answer);
+          await sendSignal(peerId, fileId, "answer", { sdp: answer.sdp });
+        } else if (env.type === "answer" && sess) {
+          await sess.pc.setRemoteDescription({ type: "answer", sdp: env.sdp });
+          if (sess.pendingCandidates) {
+            for (const c of sess.pendingCandidates.splice(0)) {
+              try {
+                await sess.pc.addIceCandidate(c);
+              } catch (e) {
+              }
+            }
+          }
+        } else if (env.type === "candidate" && sess && env.candidate) {
+          if (sess.pc.remoteDescription) {
+            try {
+              await sess.pc.addIceCandidate(env.candidate);
+            } catch (e) {
+            }
+          } else {
+            if (!sess.pendingCandidates) sess.pendingCandidates = [];
+            sess.pendingCandidates.push(env.candidate);
+          }
+        } else if (env.type === "bye") {
+          cleanup(fileId);
+        }
+      } catch (e) {
+        console.warn("[file-rtc] signal failed", e);
+        cleanup(fileId);
       }
+    });
+    return () => {
+      off();
+      for (const id of Array.from(peersRef.current.keys())) cleanup(id);
+    };
+  }, [selfId, onReceivedText]);
+  const sendFile = React.useCallback(async (peerId, file, onProgress) => {
+    if (!peerId || !file || !window.RTCPeerConnection || !window.dkRtcSignalBus) {
+      return { ok: false, fallback: true, error: "WebRTC unavailable" };
     }
-  }
-  return {
-    async send(peerId, signal) {
-      const body = JSON.stringify({ userid: peerId, data: PW.encodeSignal(signal) });
-      const r = await fetch("/api/call-signal", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body
+    const bus = dkRtcSignalBus();
+    const fileId = dkFileRtcId();
+    const pc = new RTCPeerConnection({ iceServers: CALL_ICE_SERVERS });
+    const dc = pc.createDataChannel("agentnet-file", { ordered: true });
+    const sess = { pc, dc, peerId, chunks: [], meta: null, pendingCandidates: [] };
+    peersRef.current.set(fileId, sess);
+    const cleanup = () => {
+      try {
+        dc.close();
+      } catch (e) {
+      }
+      try {
+        pc.close();
+      } catch (e) {
+      }
+      peersRef.current.delete(fileId);
+    };
+    const sendSignal = (type, extra) => bus.send(peerId, dkFileRtcEnvelope(fileId, type, extra));
+    try {
+      pc.onicecandidate = (ev) => {
+        if (ev.candidate) sendSignal("candidate", { candidate: ev.candidate.toJSON() }).catch(() => {
+        });
+      };
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      await sendSignal("offer", {
+        sdp: offer.sdp,
+        meta: { name: file.name, size: file.size, mime: file.type || "application/octet-stream" }
       });
-      const d = await r.json().catch(() => ({ ok: r.ok }));
-      if (!d.ok) throw new Error(d.error || "call-signal send failed");
-    },
-    onSignal(cb) {
-      handler = cb;
-      if (stopped === false && !this._started) {
-        this._started = true;
-        pollLoop();
+      await dkWaitForOpen(dc, DK_FILE_RTC_OPEN_TIMEOUT_MS);
+      dc.send(JSON.stringify({ type: "meta", name: file.name, size: file.size, mime: file.type || "application/octet-stream" }));
+      let sent = 0;
+      const highWater = 4 * 1024 * 1024;
+      while (sent < file.size) {
+        if (dc.readyState !== "open") throw new Error("WebRTC data channel closed");
+        const end = Math.min(file.size, sent + DK_FILE_RTC_CHUNK);
+        const buf = await file.slice(sent, end).arrayBuffer();
+        dc.send(buf);
+        sent = end;
+        if (onProgress) onProgress({ sent, size: file.size, pct: file.size ? sent / file.size * 100 : 100 });
+        await dkWaitBufferedLow(dc, highWater);
       }
-    },
-    stop() {
-      stopped = true;
+      dc.send(JSON.stringify({ type: "done" }));
+      await sendSignal("bye", { reason: "done" }).catch(() => {
+      });
+      setTimeout(cleanup, 1500);
+      return { ok: true, via: "webrtc", fileId };
+    } catch (e) {
+      await sendSignal("bye", { reason: "fallback" }).catch(() => {
+      });
+      cleanup();
+      return { ok: false, fallback: true, error: e && e.message || String(e) };
     }
-  };
-}
+  }, []);
+  const dismissIncoming = React.useCallback((id) => {
+    setIncoming((arr) => {
+      const item = arr.find((x) => x.id === id);
+      if (item && item.url) setTimeout(() => URL.revokeObjectURL(item.url), 1e3);
+      return arr.filter((x) => x.id !== id);
+    });
+  }, []);
+  return { incoming, sendFile, dismissIncoming };
+}
+function RtcFileInbox({ T, peers, ctl }) {
+  const items = ctl && ctl.incoming || [];
+  if (!items.length) return null;
+  return /* @__PURE__ */ React.createElement("div", { style: { position: "fixed", right: 18, bottom: 18, zIndex: 90, width: 360, display: "flex", flexDirection: "column", gap: 10 } }, items.map((it) => {
+    const peer = (peers || []).find((p) => p.id === it.peerId || p.userId === it.peerId) || {};
+    const who = peer.alias || peer.name || shortKey(it.peerId, 8, 5);
+    return /* @__PURE__ */ React.createElement("div", { key: it.id, style: { border: "1px solid var(--line)", background: "var(--panel)", borderRadius: 12, padding: 12, boxShadow: "0 14px 40px rgba(0,0,0,0.35)" } }, /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 12, color: "var(--faint)", marginBottom: 6 } }, T && T.receivedFile || "Received file", " \xB7 ", who), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--ui)", fontSize: 13, fontWeight: 700, color: "var(--text)", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" } }, it.name), /* @__PURE__ */ React.createElement("div", { style: { fontFamily: "var(--mono)", fontSize: 11, color: "var(--faint)", marginTop: 3 } }, dkFileSize(it.size)), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", justifyContent: "flex-end", gap: 8, marginTop: 10 } }, /* @__PURE__ */ React.createElement("button", { onClick: () => ctl.dismissIncoming(it.id), style: { height: 30, borderRadius: 8, border: "1px solid var(--line)", background: "transparent", color: "var(--dim)", cursor: "pointer" } }, T && T.cancel || "Close"), /* @__PURE__ */ React.createElement("a", { href: it.url, download: it.name, onClick: () => setTimeout(() => ctl.dismissIncoming(it.id), 500), style: { height: 30, borderRadius: 8, padding: "6px 10px", background: "var(--accent)", color: "#fff", textDecoration: "none", fontFamily: "var(--mono)", fontSize: 12 } }, T && T.open || "Download")));
+  }));
+}
+Object.assign(window, { useRtcFileController, RtcFileInbox });
 const CALL_ICE_SERVERS = [
   { urls: "stun:stun.l.google.com:19302" },
   { urls: "turn:tokyo.fi.chat:3478", username: "allcom", credential: "allcompass" }
@@ -2085,6 +2417,7 @@ const STR = {
     sendFile: "Send file",
     block: "Block peer",
     remove: "Remove friend",
+    receivedFile: "Received file",
     attach: "Attach file",
     message: "Message",
     send: "Send",
@@ -2175,6 +2508,7 @@ const STR = {
     sendFile: "\u53D1\u9001\u6587\u4EF6",
     block: "\u62C9\u9ED1",
     remove: "\u5220\u9664\u597D\u53CB",
+    receivedFile: "\u6536\u5230\u6587\u4EF6",
     attach: "\u9644\u4EF6",
     message: "\u6D88\u606F",
     send: "\u53D1\u9001",
@@ -2279,6 +2613,7 @@ function DkApp() {
   const rowPad = t.density === "comfortable" ? "11px 12px" : "7px 10px";
   const callCtl = useCallController(me.userId);
   const onCall = (peerId, video) => callCtl.start(peerId, !!video);
+  const rtcFileCtl = useRtcFileController(me.userId);
   React.useEffect(() => {
     if (!activeId && peers.length) setActiveId(peers[0].id);
   }, [peers, activeId]);
@@ -2315,7 +2650,12 @@ function DkApp() {
   };
   const onSendFile = (file) => {
     if (!activeId || !file) return Promise.resolve({ ok: false });
-    return dkApi.sendFile(activeId, file).then((r) => {
+    return rtcFileCtl.sendFile(activeId, file).then((r) => {
+      if (r && r.ok && r.via === "webrtc") {
+        return dkApi.send(activeId, (t.lang === "zh" ? "\u5DF2\u901A\u8FC7 WebRTC \u53D1\u9001\u6587\u4EF6: " : "sent file via WebRTC: ") + file.name).then(() => ({ ok: true, via: "webrtc" }));
+      }
+      return dkApi.sendFile(activeId, file);
+    }).then((r) => {
       data.loadThread(activeId);
       data.refresh();
       return r;
@@ -2381,6 +2721,6 @@ function DkApp() {
     color: "#fff",
     fontSize: 12,
     fontWeight: 600
-  } }, n.label)))), /* @__PURE__ */ React.createElement(IncomingCallModal, { T, ctl: callCtl, peers }), /* @__PURE__ */ React.createElement(CallOverlay, { T, ctl: callCtl, peers }));
+  } }, n.label)))), /* @__PURE__ */ React.createElement(IncomingCallModal, { T, ctl: callCtl, peers }), /* @__PURE__ */ React.createElement(CallOverlay, { T, ctl: callCtl, peers }), /* @__PURE__ */ React.createElement(RtcFileInbox, { T, peers, ctl: rtcFileCtl }));
 }
 ReactDOM.createRoot(document.getElementById("root")).render(/* @__PURE__ */ React.createElement(DkApp, null));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.214",
+  "version": "0.1.217",
   "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",
@@ -84,7 +84,7 @@
   },
   "dependencies": {
     "@decentnetwork/dora": "^0.1.14",
-    "@decentnetwork/peer": "^0.1.107",
+    "@decentnetwork/peer": "^0.1.109",
     "@decentnetwork/peer-webrtc": "^0.2.10",
     "ink": "^5.2.1",
     "js-yaml": "^4.1.0",