@decentnetwork/lan 0.1.219 → 0.1.220

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

@@ -90,6 +90,8 @@ export declare class PeerManager extends EventEmitter {
     isNativeFriend(userid: string): boolean;
     /** Accept an incoming file offer. */
     acceptFile(userid: string, fileNumber: number): void;
+    /** Reject/cancel an incoming file offer before accepting it. */
+    cancelFile(userid: string, fileNumber: number): void;
     /** Cancel an in-flight send by content fileId. Returns true if it was found. */
     cancelSend(userid: string, fileId: string): boolean;
     /** Cancel in-flight sends matching size/name when activeSends lost the fileId. */

package/dist/carrier/peer-manager.js

@@ -205,6 +205,10 @@ export class PeerManager extends EventEmitter {
     acceptFile(userid, fileNumber) {
         this.peer?.acceptFile(userid, fileNumber);
     }
+    /** Reject/cancel an incoming file offer before accepting it. */
+    cancelFile(userid, fileNumber) {
+        this.peer?.cancelFile(userid, fileNumber, false);
+    }
     /** Cancel an in-flight send by content fileId. Returns true if it was found. */
     cancelSend(userid, fileId) {
         return this.peer?.cancelFileById(userid, fileId, true) ?? false;

package/dist/cli/commands.d.ts

@@ -215,6 +215,15 @@ export declare function cmdProxyWhitelist(args: {
     userid?: string;
     configDir?: string;
 }): Promise<void>;
+/**
+ * Exit bandwidth guard for Messenger file receiving. Default is OFF: friends can
+ * send files normally. When ON, this node only accepts incoming file offers from
+ * peers present in the existing proxy whitelist. Applies live to the daemon.
+ */
+export declare function cmdProxyFileWhitelist(args: {
+    mode: "on" | "off" | "status";
+    configDir?: string;
+}): Promise<void>;
 /**
  * Set (or clear, with 0) the exit's busy threshold in Mbps. Above this smoothed
  * egress rate the exit serves only whitelisted peers; 0 = free for all.

package/dist/cli/commands.js

@@ -1004,6 +1004,9 @@ export async function cmdProxyWhitelist(args) {
         console.log(busy > 0
             ? `Busy threshold: ${busy}Mbps (above this, only whitelisted peers get new tunnels).`
             : `Busy threshold: OFF — exit is free for all. Set one with 'agentnet proxy busy-mbps <N>'.`);
+        console.log(proxy.fileWhitelistOnly === true
+            ? `File receive guard: ON — incoming files are accepted only from this whitelist.`
+            : `File receive guard: OFF — friend file receiving is open. Enable with 'agentnet proxy file-whitelist on'.`);
         return;
     }
     if (!args.userid) {
@@ -1025,6 +1028,35 @@ export async function cmdProxyWhitelist(args) {
     await ConfigLoader.save(config, configPath);
     await applyProxyReloadIfRunning(config);
 }
+/**
+ * Exit bandwidth guard for Messenger file receiving. Default is OFF: friends can
+ * send files normally. When ON, this node only accepts incoming file offers from
+ * peers present in the existing proxy whitelist. Applies live to the daemon.
+ */
+export async function cmdProxyFileWhitelist(args) {
+    const dir = args.configDir || ConfigLoader.defaultConfigDir();
+    const configPath = resolve(dir, "config.yaml");
+    const config = await ConfigLoader.load(configPath);
+    const proxy = config.proxy ?? { enabled: false, port: 8888 };
+    const whitelist = proxy.whitelist ?? [];
+    const enabled = proxy.fileWhitelistOnly === true;
+    if (args.mode === "status") {
+        console.log(enabled
+            ? `File receive guard: ON — incoming files are accepted only from proxy.whitelist (${whitelist.length} entr${whitelist.length === 1 ? "y" : "ies"}).`
+            : `File receive guard: OFF — friend file receiving is open.`);
+        return;
+    }
+    const next = args.mode === "on";
+    config.proxy = { ...proxy, fileWhitelistOnly: next };
+    await ConfigLoader.save(config, configPath);
+    console.log(next
+        ? `File receive guard ON — incoming files from friends outside proxy.whitelist will be rejected.`
+        : `File receive guard OFF — friends can send files normally.`);
+    if (next && whitelist.length === 0) {
+        console.log(`Warning: proxy.whitelist is empty, so all incoming file offers will be rejected until you add peers.`);
+    }
+    await applyProxyReloadIfRunning(config);
+}
 /**
  * Set (or clear, with 0) the exit's busy threshold in Mbps. Above this smoothed
  * egress rate the exit serves only whitelisted peers; 0 = free for all.

package/dist/cli/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // Belt-and-braces — also raise it here in case the CLI is run directly
 // (e.g. `node dist/cli/index.js` rather than via dist/index.js).
 EventEmitter.defaultMaxListeners = 100;
-import { cmdInit, cmdIdentityShow, cmdPeersList, cmdIpamAssign, cmdGrant, cmdRevoke, cmdResolve, cmdStatus, cmdUp, cmdAuditLog, cmdFriendRequest, cmdFriendAccept, cmdFriendsList, cmdFriendsPending, cmdFriendsAccept, cmdFriendsAutoAccept, cmdFriendsReject, cmdProxyEnable, cmdProxyDisable, cmdProxyStatus, cmdProxyWho, cmdProxyAccess, cmdProxyAllowHost, cmdProxyRevokeHost, cmdProxyListHosts, cmdProxyWhitelist, cmdProxyBusyMbps, cmdProxyUse, cmdProxyRouter, cmdProxyTrustCa, cmdDoraEnable, cmdDoraDisable, cmdDoraStatus, cmdDoraAutofriend, cmdDiag, cmdDoctor, cmdDnsInstall, cmdDnsHosts, cmdServiceInstall, cmdRestart, cmdServiceStatus, cmdServiceRestart, cmdUi, cmdConsole, cmdFileSend, cmdChatSend, cmdChatHistory, cmdFriendRemove, cmdFriendAlias, } from "./commands.js";
+import { cmdInit, cmdIdentityShow, cmdPeersList, cmdIpamAssign, cmdGrant, cmdRevoke, cmdResolve, cmdStatus, cmdUp, cmdAuditLog, cmdFriendRequest, cmdFriendAccept, cmdFriendsList, cmdFriendsPending, cmdFriendsAccept, cmdFriendsAutoAccept, cmdFriendsReject, cmdProxyEnable, cmdProxyDisable, cmdProxyStatus, cmdProxyWho, cmdProxyAccess, cmdProxyAllowHost, cmdProxyRevokeHost, cmdProxyListHosts, cmdProxyWhitelist, cmdProxyFileWhitelist, cmdProxyBusyMbps, cmdProxyUse, cmdProxyRouter, cmdProxyTrustCa, cmdDoraEnable, cmdDoraDisable, cmdDoraStatus, cmdDoraAutofriend, cmdDiag, cmdDoctor, cmdDnsInstall, cmdDnsHosts, cmdServiceInstall, cmdRestart, cmdServiceStatus, cmdServiceRestart, cmdUi, cmdConsole, cmdFileSend, cmdChatSend, cmdChatHistory, cmdFriendRemove, cmdFriendAlias, } from "./commands.js";
 async function main() {
     await yargs(hideBin(process.argv))
         .scriptName("agentnet")
@@ -327,6 +327,15 @@ async function main() {
             return;
         }
         await cmdProxyWhitelist({ action: argv.action, userid: argv.userid, configDir: argv["config-dir"] });
+    })
+        .command("file-whitelist <mode>", "Incoming files: accept only from proxy whitelist when on (on|off|status)", (yy) => yy
+        .positional("mode", { type: "string", demandOption: true })
+        .option("config-dir", { type: "string" }), async (argv) => {
+        if (argv.mode !== "on" && argv.mode !== "off" && argv.mode !== "status") {
+            console.log("Usage: agentnet proxy file-whitelist <on|off|status>");
+            return;
+        }
+        await cmdProxyFileWhitelist({ mode: argv.mode, configDir: argv["config-dir"] });
     })
         .command("busy-mbps <mbps>", "Set the exit's busy threshold (Mbps); above it, only whitelisted peers get new tunnels. 0 = free for all", (yy) => yy
         .positional("mbps", { type: "number", demandOption: true })

package/dist/daemon/server.d.ts

@@ -82,6 +82,7 @@ export declare class DaemonServer {
      *  so a helper that keeps dying immediately doesn't tight-loop. */
     private attachTunRecovery;
     private rebuildTun;
+    private isFileSenderWhitelisted;
     start(): Promise<void>;
     stop(): Promise<void>;
     /**

package/dist/daemon/server.js

@@ -207,6 +207,20 @@ export class DaemonServer {
         }
         this.tunRebuildInProgress = false;
     }
+    isFileSenderWhitelisted(userid) {
+        const proxy = this.config.proxy;
+        if (!proxy?.fileWhitelistOnly)
+            return true;
+        const whitelist = new Set((proxy.whitelist ?? []).map((s) => String(s).trim()).filter(Boolean));
+        if (whitelist.size === 0)
+            return false;
+        if (whitelist.has(userid))
+            return true;
+        const rec = this.ipam?.resolveCarrierId(userid);
+        if (!rec)
+            return false;
+        return whitelist.has(rec.virtualIp) || whitelist.has(rec.name) || whitelist.has(rec.carrierId);
+    }
     async start() {
         if (this.isRunning) {
             throw new Error("Daemon already running");
@@ -704,6 +718,7 @@ export class DaemonServer {
                     // and `proxy busy-mbps` apply live without a restart.
                     const whitelist = fresh.proxy?.whitelist ?? [];
                     const busyMbps = fresh.proxy?.busyMbps;
+                    const fileWhitelistOnly = fresh.proxy?.fileWhitelistOnly === true;
                     this.connectProxy.updateAdmission({ whitelist, busyMbps });
                     // Keep the in-memory config in sync so a later diag reflects it.
                     if (this.config.proxy) {
@@ -712,8 +727,9 @@ export class DaemonServer {
                             this.config.proxy.allowConnectPorts = allowConnectPorts;
                         this.config.proxy.whitelist = whitelist;
                         this.config.proxy.busyMbps = busyMbps;
+                        this.config.proxy.fileWhitelistOnly = fileWhitelistOnly;
                     }
-                    return { applied: true, allowHosts, whitelist, busyMbps };
+                    return { applied: true, allowHosts, whitelist, busyMbps, fileWhitelistOnly };
                 },
                 proxyAccess: async (userid, allow) => {
                     // Live block/allow a peer's access to THIS node's exit proxy port.
@@ -1014,6 +1030,13 @@ export class DaemonServer {
             // File transfer (toxcore-standard): auto-accept offers from friends and
             // save completed files under <configDir>/downloads/.
             this.peerManager.on("file-offer", (o) => {
+                if (!this.isFileSenderWhitelisted(o.friendId)) {
+                    const rec = this.ipam?.resolveCarrierId(o.friendId);
+                    const who = rec ? `${rec.name}/${rec.virtualIp}` : o.friendId.slice(0, 8);
+                    this.logger.warn(`Incoming file "${o.name}" (${o.size}B) from ${who} rejected — proxy.fileWhitelistOnly=true and sender is not in proxy.whitelist`);
+                    this.peerManager?.cancelFile(o.friendId, o.fileNumber);
+                    return;
+                }
                 this.logger.info(`Incoming file "${o.name}" (${o.size}B) from ${o.friendId.slice(0, 8)} — accepting`);
                 this.peerManager?.acceptFile(o.friendId, o.fileNumber);
             });

package/dist/types.d.ts

@@ -141,6 +141,7 @@ export interface ProxyConfig {
     egress?: string;
     busyMbps?: number;
     whitelist?: string[];
+    fileWhitelistOnly?: boolean;
 }
 export interface FriendsConfig {
     /** When true (default), the running daemon auto-accepts incoming

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.219",
+  "version": "0.1.220",
   "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",