@decentnetwork/lan 0.1.156 → 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);
@@ -516,6 +531,9 @@ export class PeerManager extends EventEmitter {
             }
             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/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)");
@@ -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}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.156",
+  "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.81",
+    "@decentnetwork/peer": "^0.1.82",
     "ink": "^5.2.1",
     "js-yaml": "^4.1.0",
     "node-forge": "^1.4.0",