socket-function 1.2.22 → 1.2.23

package/index.d.ts

@@ -984,6 +984,9 @@ declare module "socket-function/src/forwardPort" {
         externalPort: number;
         internalPort: number;
         duration?: number;
+        /** Keep the lease alive by re-creating the mapping at 80% of `duration`, forever. On by
+         *      default, which is what you want — an un-maintained forward silently expires. */
+        autoRenew?: boolean;
     }): Promise<void>;
     /** Our machine's LAN IP, as the router sees it — used to tell whether an existing port
      *      mapping points at us or at a different machine on the network. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.2.22",
+	"version": "1.2.23",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/forwardPort.d.ts

@@ -19,6 +19,9 @@ export declare function forwardPort(config: {
     externalPort: number;
     internalPort: number;
     duration?: number;
+    /** Keep the lease alive by re-creating the mapping at 80% of `duration`, forever. On by
+     *      default, which is what you want — an un-maintained forward silently expires. */
+    autoRenew?: boolean;
 }): Promise<void>;
 /** Our machine's LAN IP, as the router sees it — used to tell whether an existing port
  *      mapping points at us or at a different machine on the network. */

package/src/forwardPort.ts

@@ -74,36 +74,58 @@ export async function listPortMappings(): Promise<PortMapping[]> {
     throw new Error(`Failed to list port mappings, could not find a working controlURL. Last error: ${(lastError as Error)?.stack ?? lastError}`);
 }
 
+// A UPnP lease expires on its own, so a forward left un-renewed silently dies partway through.
+//  Renew at 80% of the duration: enough margin to cover a failed attempt (we retry on the next
+//  tick) while the previous lease is still live, so the mapping never actually lapses.
+const LEASE_RENEW_FRACTION = 0.8;
+
 export async function forwardPort(config: {
     externalPort: number;
     internalPort: number;
     duration?: number;
+    /** Keep the lease alive by re-creating the mapping at 80% of `duration`, forever. On by
+     *      default, which is what you want — an un-maintained forward silently expires. */
+    autoRenew?: boolean;
 }) {
-    try {
-        const { externalPort, internalPort } = config;
-        let duration = config.duration ?? timeInHour;
-
-        const { internalIP, gatewayIP, controlPort, controlURLs } = await resolveGateway();
+    let duration = config.duration ?? timeInHour;
+    let autoRenew = config.autoRenew ?? true;
 
-        for (let controlURL of controlURLs) {
-            try {
-                await createPortMapping({
-                    externalPort, internalPort,
-                    gatewayIP,
-                    controlPort,
-                    controlPath: controlURL,
-                    internalIP,
-                    duration,
-                });
-                console.log(`Port mapping created on ${gatewayIP}:${externalPort} -> ${internalIP}:${internalPort}`);
-                return;
-            } catch (e) {
-                console.error(`Failed to create port mapping using controlURL ${controlURL}`, e);
+    async function createMapping() {
+        try {
+            const { externalPort, internalPort } = config;
+            const { internalIP, gatewayIP, controlPort, controlURLs } = await resolveGateway();
+
+            for (let controlURL of controlURLs) {
+                try {
+                    await createPortMapping({
+                        externalPort, internalPort,
+                        gatewayIP,
+                        controlPort,
+                        controlPath: controlURL,
+                        internalIP,
+                        duration,
+                    });
+                    console.log(`Port mapping created on ${gatewayIP}:${externalPort} -> ${internalIP}:${internalPort}`);
+                    return;
+                } catch (e) {
+                    console.error(`Failed to create port mapping using controlURL ${controlURL}`, e);
+                }
             }
+            console.error("Failed to create port mapping, could not find controlURL");
+        } catch (e) {
+            console.error("Error in forwardPort", e);
         }
-        console.error("Failed to create port mapping, could not find controlURL");
-    } catch (e) {
-        console.error("Error in forwardPort", e);
+    }
+
+    await createMapping();
+
+    if (autoRenew) {
+        // unref so a script that only wants a one-off forward (and then exits) isn't held open by
+        //  the renewal timer; a running server stays alive on its own and the renewals keep firing.
+        let timer = setInterval(() => {
+            void createMapping();
+        }, Math.max(1, Math.floor(duration * LEASE_RENEW_FRACTION)));
+        timer.unref?.();
     }
 }
 

package/src/webSocketServer.ts

@@ -11,8 +11,8 @@ import { parseSNIExtension, parseTLSHello, SNIType } from "./tlsParsing";
 import debugbreak from "debugbreak";
 import { getNodeId } from "./nodeCache";
 import crypto from "crypto";
-import { Watchable, getRootDomain, timeInHour, timeInMinute } from "./misc";
-import { delay, runInfinitePoll } from "./batching";
+import { Watchable, getRootDomain } from "./misc";
+import { delay } from "./batching";
 import { magenta, red } from "./formatting/logColors";
 import { yellow } from "./formatting/logColors";
 import { green } from "./formatting/logColors";
@@ -439,12 +439,9 @@ export async function startSocketServer(
     port = (realServer.address() as net.AddressInfo).port;
 
     if (doForward) {
-        // The mapping is claimed above; keep refreshing the lease so it doesn't expire.
-        async function refreshForward() {
-            await forwardPort({ externalPort: port, internalPort: port });
-            console.log(magenta(`Refreshed port forward ${port} to our machine`));
-        }
-        runInfinitePoll(timeInMinute * 30, refreshForward);
+        // The mapping is claimed above; this establishes the maintained forward, which
+        //  auto-renews its own lease (at 80% of the duration) so it doesn't expire.
+        await forwardPort({ externalPort: port, internalPort: port });
     }
 
     let nodeId = getNodeId(getCommonName(config.cert), port);