querysub 0.2.0

package/src/-g-core-values/oneTimeForward.ts

@@ -0,0 +1,91 @@
+import debugbreak from "debugbreak";
+import * as net from "net";
+import ws from "ws";
+
+// Expose the internal port, via a tcp connection that we forward to internal port, for the first time
+//  externalIP connects to us.
+//  - console.warn if any other ips try to connect
+//  - console.error if externalIP tries to connects multiple times
+export async function hackDevtoolsWebsocketForward(config: {
+    internalPort: number;
+    externalIP: string;
+}): Promise<{
+    externalPort: number;
+    cancel: () => void;
+}> {
+    let hasConnected = false;
+    const server = net.createServer();
+
+    // Start listening on a random available port, binding to all interfaces (0.0.0.0)
+    server.listen(0, "0.0.0.0");
+
+    server.on("connection", (socket) => {
+        const clientIP = socket.remoteAddress;
+
+        if (clientIP !== config.externalIP) {
+            console.error(`Rejected connection attempt from unauthorized IP: ${clientIP}`);
+            socket.destroy();
+            return;
+        }
+
+        console.log(`Forwarding connection from ${config.externalIP}:${(address as any).port} to 127.0.0.1:${config.internalPort}`);
+
+        hasConnected = true;
+
+        // Forward the connection to the internal port
+        const internalConnection = net.createConnection({
+            host: "127.0.0.1",
+            port: config.internalPort,
+        });
+        internalConnection.on("data", (data) => {
+            socket.write(data);
+        });
+        let first = true;
+        socket.on("data", (data) => {
+            // UGH... fix the host, otherwise devtools rejects the request.
+            if (first) {
+                first = false;
+                let lines = data.toString().split("\r\n");
+                lines[1] = `Host: 127.0.0.1:${config.internalPort}`;
+                data = Buffer.from(lines.join("\r\n"));
+            }
+            internalConnection.write(data);
+        });
+
+        // // Handle socket closure
+        socket.on("close", () => {
+            internalConnection.destroy();
+            server.close();
+        });
+        socket.on("error", (err) => {
+            internalConnection.destroy();
+        });
+
+        internalConnection.on("close", () => {
+            socket.destroy();
+        });
+        internalConnection.on("error", (err) => {
+            socket.destroy();
+        });
+    });
+
+    // Wait to we start listening
+    await new Promise((resolve) => {
+        server.on("listening", resolve);
+    });
+
+    // Get the randomly assigned port number
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("Failed to get server address");
+    }
+
+    console.log(`Exposing external port ${address.port} to internal port ${config.internalPort} (for ${config.externalIP})`);
+
+    return {
+        externalPort: address.port,
+        cancel: () => {
+            server.close();
+        }
+    };
+}