@decentnetwork/lan 0.1.156 → 0.1.158

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/dist/proxy/multi-exit-router.js

@@ -42,6 +42,14 @@ export const BUILTIN_REGION_DOMAINS = {
         // subdomains that resolve to a non-China edge, so pin them statically.
         ".v.myalicdn.com", ".myalicdn.com",
         ".kcdnvip.com", ".ks-cdn.com", ".ksyuncdn.com",
+        // CCTV live also rotates onto Baidu (bdydns) and Wangsu/网宿 (wscdns)
+        // edges — observed segment hosts ldcctvwbcdbd.a.bdydns.com and
+        // ldcctvwbcdcnc.v.wscdns.com. These aren't .cn, so pin the provider
+        // suffixes so they deterministically ride a China exit instead of
+        // depending on geo-classify timing (which flaps to direct → geo-block
+        // when a China exit is momentarily busy). Tencent live is .myqcloud.com
+        // below.
+        ".bdydns.com", ".wscdns.com",
         ".bilibili.com", ".biliapi.net", ".bilivideo.com", ".bilivideo.cn", ".hdslb.com",
         ".youku.com", ".iqiyi.com", ".iq.com", ".mgtv.com", ".hitv.com",
         ".miguvideo.com", ".cmvideo.cn", ".migu.cn",
@@ -254,7 +262,14 @@ export function startMultiExitRouter(opts) {
     const geoCn = new GeoCnClassifier();
     async function resolveRegion(host) {
         let region = routeFor(host); // static domains + persistent learned routes
-        if (region === "direct" && !isLocalDest(host) && fallbackRegion && regionHasExits(fallbackRegion)) {
+        // Consult the geo classifier even when the fallback region currently has
+        // NO healthy exits. A China-allocated host (e.g. a CCTV live CDN edge)
+        // must be pinned to the China region and 503 (retriable) when the region
+        // is momentarily down — NOT leaked to `direct`, where the CDN geo-blocks
+        // our non-China egress outright ("您所在的地区,暂不支持播放该视频") and the
+        // directConnect failover can even unlearn the route, turning a transient
+        // exit blip into a persistent geo-block until re-learned.
+        if (region === "direct" && !isLocalDest(host) && fallbackRegion) {
             // peek() is sync for IP literals / cached verdicts; classify() resolves.
             const cn = geoCn.peek(host);
             if (cn === true || (cn === null && await geoCn.classify(host))) {
@@ -265,8 +280,13 @@ export function startMultiExitRouter(opts) {
                 region = fallbackRegion;
             }
         }
-        if (region !== "direct" && !regionHasExits(region))
+        // Downgrade a region-with-no-exits to direct ONLY for hosts we don't know
+        // to be China. A known-China host to direct is a guaranteed geo-block, so
+        // keep it in-region (the caller 503s, the player retries, and a recovered
+        // China exit serves the retry).
+        if (region !== "direct" && !regionHasExits(region) && geoCn.peek(host) !== true) {
             region = "direct";
+        }
         return region;
     }
     const seenGeo = new Set();
@@ -599,7 +619,12 @@ export function startMultiExitRouter(opts) {
             let i = 0;
             const tryNext = () => {
                 if (i >= order.length) {
-                    learner.unlearn(h);
+                    // Only unlearn if we DON'T know this is a China host. Unlearning a
+                    // China-geo host back to `direct` is the geo-block trap: direct is
+                    // guaranteed to fail for it, so keep the learned China route and let
+                    // the player retry when a China exit recovers.
+                    if (geoCn.peek(h) !== true)
+                        learner.unlearn(h);
                     client.end("HTTP/1.1 502 All routes failed\r\n\r\n");
                     return;
                 }

package/package.json

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