@decentnetwork/lan 0.1.155 → 0.1.157

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

@@ -62,6 +62,14 @@ export declare class PeerManager extends EventEmitter {
     sign(message: Uint8Array): Uint8Array;
     /** Offer a file to a friend (toxcore-standard transfer). Returns the fileId. */
     sendFile(userid: string, data: Uint8Array, name: string): string | null;
+    /** Send a file INLINE over the message channel (FileModel JSON envelope,
+     *  bulkmsg-split) — the only file path native iOS/C Carrier clients can
+     *  receive online. Use for native friends; JS friends keep sendFile(). */
+    sendInlineFile(userid: string, data: Uint8Array, name: string): 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. */
+    isNativeFriend(userid: string): boolean;
     /** Accept an incoming file offer. */
     acceptFile(userid: string, fileNumber: number): void;
     /** Cancel an in-flight send by content fileId. Returns true if it was found. */

package/dist/carrier/peer-manager.js

@@ -121,6 +121,21 @@ export class PeerManager extends EventEmitter {
             throw new Error("Peer not created. Call create() first.");
         return this.peer.sendFile(userid, data, { name });
     }
+    /** Send a file INLINE over the message channel (FileModel JSON envelope,
+     *  bulkmsg-split) — the only file path native iOS/C Carrier clients can
+     *  receive online. Use for native friends; JS friends keep sendFile(). */
+    async sendInlineFile(userid, data, name) {
+        if (!this.peer)
+            throw new Error("Peer not created. Call create() first.");
+        await this.peer.sendInlineFile(userid, { name, data });
+    }
+    /** 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. */
+    isNativeFriend(userid) {
+        const rec = this.peer?.friends().find((f) => f.pubkey === userid);
+        return !!(rec?.dhtPubkey && rec.dhtPubkey !== rec.pubkey);
+    }
     /** Accept an incoming file offer. */
     acceptFile(userid, fileNumber) {
         this.peer?.acceptFile(userid, fileNumber);
@@ -514,8 +529,11 @@ export class PeerManager extends EventEmitter {
             if (message.text.length === 0) {
                 return;
             }
-            this.emit("message", message.pubkey, message.text);
+            this.emit("message", message.pubkey, message.text, message.via);
         });
+        // Inline files (iOS/C Carrier style: FileModel JSON over bulkmsg).
+        // The SDK reassembles + decodes; forward to the daemon to save + log.
+        this.peer.onInlineFile((f) => this.emit("inline-file", f));
         // Toxcore-standard file transfer (native-compatible). Forward offers,
         // progress, and completions to the daemon, which auto-accepts and saves.
         this.peer.onFile((o) => this.emit("file-offer", o));

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

@@ -18,6 +18,11 @@ export interface ChatMessage {
      *  user hit send, so the daemon stored it and will deliver it (in order) the
      *  moment the friend reconnects. Cleared once actually sent. */
     status?: "queued" | "sent" | "failed";
+    /** How this message traversed the network, for the UI to distinguish at a
+     *  glance (different colors). "online" = live net_crypto session (direct/relay);
+     *  "offline" = express store-and-forward (the friend or we were offline). Lets
+     *  a user SEE when online delivery is silently failing and only offline lands. */
+    via?: "online" | "offline";
     /** Present when this entry is a file transfer rather than a text message.
      *  `name`/`size` describe the file; received files (dir:"in") are saved to
      *  <configDir>/downloads/<name> and downloadable via the UI. For outgoing
@@ -47,7 +52,7 @@ export declare class MessageStore {
     /** Append a message and schedule a flush. Returns the stored message.
      *  Pass `status: "queued"` for an outgoing text the peer wasn't online to
      *  receive — the daemon flushes it on reconnect. */
-    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "queued" | "sent" | "failed"): ChatMessage;
+    append(peer: string, dir: "in" | "out", text: string, ts?: number, status?: "queued" | "sent" | "failed", via?: "online" | "offline"): ChatMessage;
     /** Set (or, with undefined, clear) the delivery status on a text message.
      *  Used to flip a "queued" message to delivered once it's actually sent.
      *  No-op if the id isn't found or is a file entry. Returns true if patched. */

package/dist/daemon/message-store.js

@@ -46,10 +46,12 @@ export class MessageStore {
     /** Append a message and schedule a flush. Returns the stored message.
      *  Pass `status: "queued"` for an outgoing text the peer wasn't online to
      *  receive — the daemon flushes it on reconnect. */
-    append(peer, dir, text, ts = Date.now(), status) {
+    append(peer, dir, text, ts = Date.now(), status, via) {
         const msg = { dir, text, ts, id: `${ts}-${this.seq++}` };
         if (status)
             msg.status = status;
+        if (via)
+            msg.via = via;
         return this.push(peer, msg);
     }
     /** Set (or, with undefined, clear) the delivery status on a text message.

package/dist/daemon/server.js

@@ -455,6 +455,23 @@ export class DaemonServer {
                         this.logger.info(`Queued file "${name}" (${data.length}B) for offline ${userid.slice(0, 8)} (delivers on reconnect)`);
                         return { queued: true, name: safe, size: data.length };
                     }
+                    // NATIVE friends (iOS/Android/C Carrier) cannot see the toxcore
+                    // file-transfer protocol at all — the only online file path they
+                    // receive is the inline FileModel-JSON-over-bulkmsg envelope the
+                    // Beagle apps themselves use. Detected via the DHT-key signature.
+                    if (this.peerManager?.isNativeFriend(userid)) {
+                        const INLINE_MAX = 2 * 1024 * 1024; // base64 inflates ~1.37x; protocol cap is 5MB
+                        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) | 0} MB (this is ${(data.length / 1024 / 1024).toFixed(1)} MB).`);
+                        }
+                        await this.peerManager.sendInlineFile(userid, new Uint8Array(data), name);
+                        this.logger.info(`Sent inline file "${name}" (${data.length}B) to native peer ${userid.slice(0, 8)}`);
+                        this.messageStore?.appendFile(userid, "out", { name: sanitizeFileName(name), size: data.length, status: "sent", sent: data.length });
+                        this.friendMeta?.ensure(userid);
+                        this.ipcEvents.emit("event", { type: "chat", userid, dir: "out" });
+                        return { inline: true, name, size: data.length };
+                    }
                     const fileId = this.peerManager?.sendFile(userid, new Uint8Array(data), name);
                     if (!fileId)
                         throw new Error("No free transfer slot (or friend unknown)");
@@ -806,8 +823,8 @@ export class DaemonServer {
                 return input;
             };
             // Chat: log incoming Carrier text messages (packet 64) for the UI.
-            this.peerManager.on("message", (pubkey, text) => {
-                this.logChat(pubkey, "in", text);
+            this.peerManager.on("message", (pubkey, text, via) => {
+                this.logChat(pubkey, "in", text, via);
             });
             // Presence: push to IPC subscribers so the TUI/UI reflects online/offline
             // transitions immediately instead of on the next poll tick.
@@ -898,6 +915,22 @@ export class DaemonServer {
                     this.ipcEvents.emit("event", { type: "chat", userid: p.friendId, dir: "in" });
                 })().catch((e) => this.logger.warn(`Failed to save file: ${e.message}`));
             });
+            // Inline files (iOS/C Carrier style — FileModel JSON over bulkmsg,
+            // reassembled + decoded by the SDK). Save like a completed transfer so
+            // the chat shows a media chip instead of a wall of base64 "text".
+            this.peerManager.on("inline-file", (f) => {
+                void (async () => {
+                    const dir = resolve(this.configDir, "downloads");
+                    const fs = await import("fs/promises");
+                    await fs.mkdir(dir, { recursive: true });
+                    const safe = sanitizeFileName(f.name);
+                    await fs.writeFile(resolve(dir, safe), Buffer.from(f.data));
+                    this.logger.info(`Saved inline file "${f.name}" (${f.data.length}B, ${f.via ?? "online"}) from ${f.pubkey.slice(0, 8)} → ${resolve(dir, safe)}`);
+                    this.messageStore?.appendFile(f.pubkey, "in", { name: safe, size: f.data.length });
+                    this.friendMeta?.ensure(f.pubkey);
+                    this.ipcEvents.emit("event", { type: "chat", userid: f.pubkey, dir: "in" });
+                })().catch((e) => this.logger.warn(`Failed to save inline file: ${e.message}`));
+            });
             this.peerManager.on("friend-request", (req) => {
                 void pubkeyHexToUserid(req.pubkey).then((userid) => {
                     const who = `${req.name || "(unnamed)"} ${userid}`;
@@ -1139,8 +1172,8 @@ export class DaemonServer {
     /** Append a chat message to the on-disk message store (persists across
      *  restarts). Also ensures a friend-meta entry exists so the friend shows up
      *  in the UI list even before it's been renamed. */
-    logChat(userid, dir, text) {
-        this.messageStore?.append(userid, dir, text);
+    logChat(userid, dir, text, via) {
+        this.messageStore?.append(userid, dir, text, Date.now(), undefined, via);
         this.friendMeta?.ensure(userid);
         this.ipcEvents.emit("event", { type: "chat", userid, dir });
     }

package/dist/ui/desktop/app.js

@@ -307,7 +307,10 @@ function useDaemonData() {
           pct: m.file.status === "sending" && m.file.size ? Math.min(100, (m.file.sent || 0) / m.file.size * 100) : void 0,
           kbps: m.file.kbps
         } : void 0,
-        status: m.dir === "out" ? m.status === "queued" ? "queued" : "read" : void 0
+        status: m.dir === "out" ? m.status === "queued" ? "queued" : "read" : void 0,
+        // Delivery path: "online" = live session, "offline" = express relay.
+        // Incoming messages carry this; the bubble colors them differently.
+        via: m.via
       }));
       const withDay = msgs.length ? [{ day: dkDayLabel(arr[0].ts) }].concat(msgs) : [];
       setThreads((t) => Object.assign({}, t, { [peerId]: withDay }));
@@ -1206,15 +1209,25 @@ function Msg({ m, peer, T, onTheater, onDelete, onCancel, selMode, selected, onT
       borderRadius: 12,
       borderBottomRightRadius: mine ? 4 : 12,
       borderBottomLeftRadius: mine ? 12 : 4,
-      background: mine ? "var(--bub-me)" : "var(--bub-them)",
+      // Incoming messages are tinted by delivery path so the split is
+      // visible: amber = arrived via the express relay (offline), plain =
+      // live online session. Outgoing keep the accent bubble.
+      background: mine ? "var(--bub-me)" : m.via === "offline" ? "rgba(245,158,11,0.16)" : "var(--bub-them)",
       color: mine ? "#fff" : "var(--text)",
-      border: "1px solid " + (mine ? "transparent" : "var(--line)"),
+      border: "1px solid " + (mine ? "transparent" : m.via === "offline" ? "rgba(245,158,11,0.55)" : "var(--line)"),
       fontFamily: "var(--ui)",
       fontSize: 13.5,
       lineHeight: 1.4,
       letterSpacing: -0.1,
       wordBreak: "break-word"
-    } }, m.text), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 4, margin: "3px 3px 0" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, m.time), !selMode && m.id && /* @__PURE__ */ React.createElement(
+    } }, m.text), /* @__PURE__ */ React.createElement("div", { style: { display: "flex", alignItems: "center", gap: 4, margin: "3px 3px 0" } }, /* @__PURE__ */ React.createElement("span", { style: { fontFamily: "var(--mono)", fontSize: 10, color: "var(--faint)" } }, m.time), !mine && m.via && /* @__PURE__ */ React.createElement(
+      "span",
+      {
+        title: m.via === "offline" ? "delivered via express relay (offline)" : "delivered over a live session (online)",
+        style: { fontFamily: "var(--mono)", fontSize: 9, color: m.via === "offline" ? "#f59e0b" : "var(--faint)" }
+      },
+      m.via === "offline" ? "\u79BB\u7EBF" : "\u5728\u7EBF"
+    ), !selMode && m.id && /* @__PURE__ */ React.createElement(
       "button",
       {
         title: T.delete || "delete",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.155",
+  "version": "0.1.157",
   "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,7 +79,7 @@
   },
   "dependencies": {
     "@decentnetwork/dora": "^0.1.13",
-    "@decentnetwork/peer": "^0.1.79",
+    "@decentnetwork/peer": "^0.1.82",
     "ink": "^5.2.1",
     "js-yaml": "^4.1.0",
     "node-forge": "^1.4.0",