@decentnetwork/peer 0.1.104 → 0.1.107

package/dist/compat/filetransfer.d.ts

@@ -57,6 +57,12 @@ export declare class FileTransferManager {
     accept(friendId: string, fileNumber: number): void;
     cancel(friendId: string, fileNumber: number, isSending: boolean): void;
     cancelByFileId(friendId: string, fileIdHex: string, isSending: boolean): boolean;
+    /** Cancel in-flight sends matching both name and size.
+     *  This is a conservative registry-desync fallback after fileId/hash lookup. */
+    cancelSendsMatching(friendId: string, match: {
+        name?: string;
+        size: number;
+    }): string[];
     handlePacket(friendId: string, packetId: number, payload: Uint8Array): boolean;
     clearFriend(friendId: string): void;
 }

package/dist/compat/filetransfer.js

@@ -239,17 +239,23 @@ export class FileTransferManager {
         }
         return inner;
     }
-    #freeNumber(friendId) {
+    #freeNumber(friendId, preferred = 0) {
         const inner = this.#map(this.#sending, friendId);
-        for (let i = 0; i < MAX_CONCURRENT_FILE_PIPES; i++)
+        // Start at a content-derived slot. Older receivers retain an incomplete
+        // receive slot in memory until it finishes or is killed. After the sender
+        // restarts, always reusing slot 0 makes a DIFFERENT new file look like a
+        // retransmitted offer for that stale slot, so the receiver silently ACKs
+        // the old file and the new UI stays at 0%. The same content keeps the same
+        // preferred slot (resume), while different content naturally avoids stale
+        // collisions; circular search still supports concurrent transfers.
+        for (let n = 0; n < MAX_CONCURRENT_FILE_PIPES; n++) {
+            const i = (preferred + n) % MAX_CONCURRENT_FILE_PIPES;
             if (!inner.has(i))
                 return i;
+        }
         return -1;
     }
     sendFile(friendId, data, opts) {
-        const fileNumber = this.#freeNumber(friendId);
-        if (fileNumber < 0)
-            return null;
         // Content-addressed fileId (sha256): re-sending the SAME file after a
         // restart or a dropped peer yields the SAME id, so the receiver can match
         // it against its persisted partial and resume from where it left off — the
@@ -257,6 +263,9 @@ export class FileTransferManager {
         const fileId = data.length > 0
             ? new Uint8Array(createHash("sha256").update(data).digest()).slice(0, FILE_ID_LENGTH)
             : randomBytes(FILE_ID_LENGTH);
+        const fileNumber = this.#freeNumber(friendId, fileId[0] ?? 0);
+        if (fileNumber < 0)
+            return null;
         const req = encodeFileSendRequest(fileNumber, opts.kind ?? FILEKIND.DATA, BigInt(data.length), fileId, opts.name);
         const lanPath = this.isLanPath(friendId);
         const st = {
@@ -271,6 +280,8 @@ export class FileTransferManager {
             btlBwBps: 0, bwSamples: [], fullBwRounds: 0, startupQueueRounds: 0, bbrPhase: 0, roundCount: 0,
             rateMarkMs: nowMs(), rateMarkAcked: 0, lowRttCount: 0, lowRttMinMs: Infinity, lastCcLogMs: 0,
             lanPath,
+            dbgLanNow: lanPath ? 1 : 0, dbgSampleMs: 0, dbgRoundRate: 0, dbgMeasuredRate: 0,
+            dbgRawQueue: 0, dbgUnder: 0, dbgOvershot: 0,
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
         void this.send(friendId, PACKET_ID_FILE_SENDREQUEST, req).catch(() => undefined);
@@ -321,27 +332,54 @@ export class FileTransferManager {
         }
     }
     cancel(friendId, fileNumber, isSending) {
+        const inner = (isSending ? this.#sending : this.#receiving).get(friendId);
+        const st = inner?.get(fileNumber);
+        const fileId = st ? hex(st.fileId) : undefined;
         const sr = isSending ? 0 : 1;
         void this.send(friendId, PACKET_ID_FILE_CONTROL, encodeFileControl(sr, fileNumber, FILECONTROL.KILL)).catch(() => undefined);
         if (isSending)
             this.#endSend(friendId, fileNumber);
         else
             this.#endRecv(friendId, fileNumber);
+        // Local cancel used to tear down silently. The daemon tracks sends in
+        // activeSends and needs this event when the registry entry is already gone
+        // (or cancel raced with a progress tick) so the UI chip cannot stay "sending".
+        if (fileId)
+            this.emit("file-cancel", { friendId, fileId, sending: isSending, reason: "local" });
     }
     // Cancel by content fileId (hex) — the daemon/UI tracks transfers by fileId,
     // not the internal fileNumber, so it can stop a specific in-flight transfer.
     cancelByFileId(friendId, fileIdHex, isSending) {
+        const want = fileIdHex.trim().toLowerCase();
         const inner = (isSending ? this.#sending : this.#receiving).get(friendId);
         if (!inner)
             return false;
         for (const [fileNumber, st] of inner) {
-            if (hex(st.fileId) === fileIdHex) {
+            if (hex(st.fileId) === want) {
                 this.cancel(friendId, fileNumber, isSending);
                 return true;
             }
         }
         return false;
     }
+    /** Cancel in-flight sends matching both name and size.
+     *  This is a conservative registry-desync fallback after fileId/hash lookup. */
+    cancelSendsMatching(friendId, match) {
+        const inner = this.#sending.get(friendId);
+        if (!inner)
+            return [];
+        const candidates = [...inner].filter(([, st]) => st.size === match.size);
+        const named = match.name
+            ? candidates.filter(([, st]) => st.name === match.name)
+            : [];
+        const picked = named;
+        const killed = [];
+        for (const [fileNumber, st] of picked) {
+            killed.push(hex(st.fileId));
+            this.cancel(friendId, fileNumber, true);
+        }
+        return killed;
+    }
     handlePacket(friendId, packetId, payload) {
         if (packetId === PACKET_ID_FILE_SENDREQUEST) {
             this.#onSendRequest(friendId, payload);
@@ -789,6 +827,12 @@ export class FileTransferManager {
                         const measuredRate = lanNow
                             ? Math.min(roundRate, Math.max(PACE_INIT_BPS, st.paceRateBps * LAN_SAMPLE_MAX_GAIN))
                             : roundRate;
+                        st.dbgLanNow = lanNow ? 1 : 0;
+                        st.dbgSampleMs = Math.round(sampleMs);
+                        st.dbgRoundRate = Math.round(roundRate);
+                        st.dbgMeasuredRate = Math.round(measuredRate);
+                        st.dbgUnder = 0;
+                        st.dbgOvershot = 0;
                         if (measuredRate > 0) {
                             st.bwSamples.push(measuredRate);
                             if (st.bwSamples.length > PACE_BW_WINDOW)
@@ -813,6 +857,8 @@ export class FileTransferManager {
                             st.cwnd = Math.max(st.cwnd, LAN_CWND_INIT_CHUNKS);
                         }
                         st.lanPath = lanNow;
+                        const rawQueue = st.minRttMs !== Infinity ? acceptedRtt - st.minRttMs : 0;
+                        st.dbgRawQueue = Math.round(rawQueue);
                         if (!lanNow) {
                             // Relay/public-NAT file traffic must remain conservative. A short
                             // ACK burst can wildly overstate bandwidth there; allowing LAN's
@@ -840,7 +886,6 @@ export class FileTransferManager {
                             else {
                                 st.fullBwRounds++;
                             }
-                            const rawQueue = st.minRttMs !== Infinity ? acceptedRtt - st.minRttMs : 0;
                             if (rawQueue > LAN_STARTUP_QUEUE_MS) {
                                 st.startupQueueRounds++;
                             }
@@ -855,6 +900,8 @@ export class FileTransferManager {
                             const startupOvershot = rawQueue > LAN_STARTUP_HARD_QUEUE_MS ||
                                 st.startupQueueRounds >= LAN_STARTUP_QUEUE_ROUNDS;
                             const startupUnderDelivering = st.fullBwRounds >= LAN_STARTUP_SLOW_ROUNDS;
+                            st.dbgUnder = startupUnderDelivering ? 1 : 0;
+                            st.dbgOvershot = startupOvershot ? 1 : 0;
                             if (startupUnderDelivering || startupOvershot) {
                                 st.bbrPhase = 2;
                             }
@@ -895,15 +942,26 @@ export class FileTransferManager {
                 }
                 if (process.env.DECENT_DEBUG && nowT - st.lastCcLogMs >= 1000) {
                     st.lastCcLogMs = nowT;
+                    const windowEnd = Math.min(st.acked + st.cwnd * MAX_FILE_DATA_SIZE, st.size);
                     console.error(`[file-cc] friend=${friendId.slice(0, 8)} ack=${st.acked}/${st.size}` +
                         ` rtt=${rtt}ms srtt=${st.srttMs.toFixed(1)}ms low=${st.lowRttCount}` +
                         ` accepted=${(!lowSample || promoteLowPath) ? 1 : 0}` +
                         ` pace=${Math.round(st.paceRateBps)}Bps bw=${Math.round(st.btlBwBps)}Bps` +
                         ` cwnd=${st.cwnd} phase=${st.bbrPhase} slow=${st.fullBwRounds}` +
-                        ` loss=${(st.lossEwma * 100).toFixed(1)}% rounds=${st.roundCount}`);
+                        ` loss=${(st.lossEwma * 100).toFixed(1)}% rounds=${st.roundCount}` +
+                        ` lanNow=${st.dbgLanNow} lanPath=${st.lanPath ? 1 : 0}` +
+                        ` sampleMs=${st.dbgSampleMs} roundRate=${st.dbgRoundRate}` +
+                        ` measuredRate=${st.dbgMeasuredRate} rawQueue=${st.dbgRawQueue}` +
+                        ` startupQueueRounds=${st.startupQueueRounds}` +
+                        ` under=${st.dbgUnder} overshot=${st.dbgOvershot}` +
+                        ` rateMarkAcked=${st.rateMarkAcked} nextSend=${st.nextSend}` +
+                        ` windowEnd=${windowEnd} tokens=${Math.round(st.paceTokens)}`);
                 }
             }
-            if (st.acked - st.lastProgressAcked >= 256 * 1024 || st.acked >= st.size) {
+            // Small files (UI screenshots etc.) used to sit at 0% until the final
+            // byte because progress only fired every 256 KB. Emit at least every
+            // 16 KB or on completion so a 100–200 KB send shows movement.
+            if (st.acked - st.lastProgressAcked >= 16 * 1024 || st.acked >= st.size) {
                 st.lastProgressAcked = st.acked;
                 this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.acked, total: st.size, sending: true });
             }

package/dist/peer.d.ts

@@ -164,6 +164,11 @@ export declare class Peer {
     cancelFile(userid: string, fileNumber: number, isSending?: boolean): void;
     /** Cancel an in-flight transfer by its content fileId (hex). Returns true if found. */
     cancelFileById(userid: string, fileId: string, isSending?: boolean): boolean;
+    /** Cancel in-flight sends that match size/name (registry-desync fallback). */
+    cancelSendsMatching(userid: string, match: {
+        name?: string;
+        size: number;
+    }): string[];
     /** Incoming file offer: { friendId, fileNumber, fileId, name, size, kind }. */
     onFile(cb: (offer: {
         friendId: string;

package/dist/peer.js

@@ -1,4 +1,6 @@
 import { EventEmitter } from "node:events";
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile, rename } from "node:fs/promises";
 import { networkInterfaces } from "node:os";
 import { dirname, join } from "node:path";
@@ -1348,6 +1350,10 @@ export class Peer {
     cancelFile(userid, fileNumber, isSending = false) { this.#fileTransfer.cancel(userid, fileNumber, isSending); }
     /** Cancel an in-flight transfer by its content fileId (hex). Returns true if found. */
     cancelFileById(userid, fileId, isSending = false) { return this.#fileTransfer.cancelByFileId(userid, fileId, isSending); }
+    /** Cancel in-flight sends that match size/name (registry-desync fallback). */
+    cancelSendsMatching(userid, match) {
+        return this.#fileTransfer.cancelSendsMatching(userid, match);
+    }
     /** Incoming file offer: { friendId, fileNumber, fileId, name, size, kind }. */
     onFile(cb) { this.#events.on("file-offer", cb); }
     /** Transfer progress: { friendId, fileId, received, total, sending? }. */
@@ -2163,6 +2169,21 @@ export class Peer {
                     // syscall (that was the CCTV CPU regression) — safe at CCTV packet
                     // rates.
                     this.#adoptRemote(state, remote.address, remote.port);
+                    // A successfully decrypted packet arriving from a private address in
+                    // one of our physical subnets is stronger LAN proof than an endpoint
+                    // hint: it demonstrates that this exact host:port already reaches us.
+                    // Lock it immediately. Without this, duplicate public/relay copies
+                    // arriving a moment later overwrite `remote`, so file DATA travels on
+                    // the LAN but ACKs hairpin through the public Internet (observed as
+                    // ~38KB/s between mac-dev and WSL on the same 10.0.0.0/24).
+                    if (!state.lanRemoteHost &&
+                        isPrivateAddress(remote.address) &&
+                        !isCgnatAddress(remote.address) &&
+                        getPhysicalLanSubnets().some((s) => isInIpv4Subnet(remote.address, s))) {
+                        state.lanRemoteHost = remote.address;
+                        this.#rememberEndpointCandidate(state, remote.address, remote.port);
+                        this.#debugLog(`lan_lock_confirmed friend=${friendId} host=${remote.address}:${remote.port} (decrypted UDP source)`);
+                    }
                     if (!state.lastUdpRecvMs) {
                         this.#debugLog(`udp_confirmed friend=${friendId} via=${remote.address}:${remote.port} (direct UDP path live)`);
                     }
@@ -4474,7 +4495,11 @@ export class Peer {
         // office silently fall back to the TURN relay (~260ms for a <1ms hop).
         const lanIp = getPhysicalLanAddresses().find((ip) => isPrivateAddress(ip));
         const lanOctets = lanIp ? lanIp.split(".").map((s) => parseInt(s, 10)) : undefined;
-        const lanPort = this.#udp.localPort() ?? 0;
+        // WSL packets are NATed by Windows, so the physical host NIC must be paired
+        // with the observed server-reflexive port, not WSL's internal socket port.
+        const lanPort = lanIp && _wslHostAddrsCache.has(lanIp)
+            ? srflx.port
+            : (this.#udp.localPort() ?? 0);
         const lanValid = !!lanOctets && lanOctets.length === 4 && !lanOctets.some((o) => Number.isNaN(o)) && lanPort > 0;
         const size = lanValid ? 18 : relayValid ? 12 : 6;
         const payload = new Uint8Array(size);
@@ -4559,10 +4584,17 @@ export class Peer {
         if (payload.length >= 18) {
             const lanHost = `${payload[12]}.${payload[13]}.${payload[14]}.${payload[15]}`;
             const lanPort = ((payload[16] << 8) | payload[17]) >>> 0;
+            // WSL sees only its 172.x virtual NIC, not the Windows host's physical
+            // 10.x subnet. In that topology a peer on the same real LAN is still
+            // safely identifiable because its server-reflexive address equals ours.
+            // Permit the advertised private candidate when both peers share the same
+            // public NAT; if it is a CGNAT/private collision and never validates, the
+            // normal 12s stale-LAN-lock breaker restores the public/relay path.
+            const samePublicNat = !!this.#srflxCache?.addr.host && this.#srflxCache.addr.host === host;
             const sameLan = lanPort !== 0 &&
                 isPrivateAddress(lanHost) &&
                 !isCgnatAddress(lanHost) &&
-                getPhysicalLanSubnets().some((s) => isInIpv4Subnet(lanHost, s)) &&
+                (getPhysicalLanSubnets().some((s) => isInIpv4Subnet(lanHost, s)) || samePublicNat) &&
                 !(getPhysicalLanAddresses().includes(lanHost) && this.#udp.localPort() === lanPort);
             if (sameLan) {
                 this.#rememberEndpointCandidate(session, lanHost, lanPort);
@@ -6305,6 +6337,45 @@ let _lanAddrsCache = [];
 let _lanSubnetsCache = [];
 let _allOwnAddrsCache = new Set();
 let _ownVirtualAddrsCache = new Set();
+let _wslHostAddrsCache = new Set();
+let _wslHostCacheMs = 0;
+/** Discover the Windows host's physical NIC from WSL2. WSL itself only sees
+ * its 172.x Hyper-V NIC, which is unreachable from another LAN machine. */
+function getWslWindowsHostAddresses(localSubnets) {
+    const now = Date.now();
+    if (now - _wslHostCacheMs < 60_000)
+        return [..._wslHostAddrsCache];
+    _wslHostCacheMs = now;
+    const found = new Set();
+    const ipconfig = "/mnt/c/Windows/System32/ipconfig.exe";
+    if (process.platform !== "linux" || !existsSync(ipconfig)) {
+        _wslHostAddrsCache = found;
+        return [];
+    }
+    try {
+        const output = execFileSync(ipconfig, [], {
+            encoding: "utf8",
+            timeout: 2000,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "ignore"]
+        });
+        // "IPv4" remains in localized ipconfig output (including Chinese).
+        for (const match of output.matchAll(/IPv4[^:\r\n]*:\s*(\d+\.\d+\.\d+\.\d+)/gi)) {
+            const host = match[1];
+            if (!isPrivateAddress(host) || isCgnatAddress(host) || host.startsWith("127.") || host.startsWith("169.254."))
+                continue;
+            // Exclude WSL/Hyper-V addresses already visible inside Linux.
+            if (localSubnets.some((s) => isInIpv4Subnet(host, s)))
+                continue;
+            found.add(host);
+        }
+    }
+    catch {
+        // WSL interop can be disabled; ordinary interface discovery remains valid.
+    }
+    _wslHostAddrsCache = found;
+    return [...found];
+}
 function refreshLanIfaceCache() {
     const now = Date.now();
     if (_lanIfaceCacheMs !== 0 && now - _lanIfaceCacheMs < 5000)
@@ -6341,6 +6412,11 @@ function refreshLanIfaceCache() {
     catch {
         // best-effort
     }
+    // Prefer the physical Windows host NIC over WSL's internal eth0 address.
+    const wslHostAddrs = getWslWindowsHostAddresses(subnets);
+    for (const host of wslHostAddrs)
+        allOwn.add(host);
+    addrs.unshift(...wslHostAddrs);
     _lanAddrsCache = addrs;
     _lanSubnetsCache = subnets;
     _allOwnAddrsCache = allOwn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.104",
+  "version": "0.1.107",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",