querysub 0.82.0 → 0.83.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.82.0",
+  "version": "0.83.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

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

@@ -1,11 +1,15 @@
 import debugbreak from "debugbreak";
 import * as net from "net";
 import ws from "ws";
+import child_process from "child_process";
 
 // 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
+//  - If any connection is closed, we terminate the forward, making this fairly safe (after a developer
+//      is finished debugging the connection can't be reused, and if it used while they are debugging
+//      they will likely notice).
 export async function hackDevtoolsWebsocketForward(config: {
     internalPort: number;
     externalIP: string;
@@ -13,78 +17,120 @@ export async function hackDevtoolsWebsocketForward(config: {
     externalPort: number;
     cancel: () => void;
 }> {
-    const server = net.createServer();
+    const forwardCode = (() => {
+        const net = require("net");
+        const config = JSON.parse(process.argv[2]);
+        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");
+        // 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;
+        server.on("connection", (socket: net.Socket) => {
+            const clientIP = socket.remoteAddress;
 
-        if (clientIP !== config.externalIP) {
-            console.error(`Rejected connection attempt from unauthorized IP: ${clientIP}`);
-            socket.destroy();
-            return;
-        }
+            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}`);
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                throw new Error("Failed to get server address");
+            }
 
-        // 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);
+            console.log(`Forwarding connection from ${config.externalIP}:${address.port} to 127.0.0.1:${config.internalPort}`);
+
+            // Forward the connection to the internal port
+            const internalConnection = net.createConnection({
+                host: "127.0.0.1",
+                port: config.internalPort,
+            });
+            internalConnection.on("data", (data: Buffer) => {
+                socket.write(data);
+            });
+            let first = true;
+            socket.on("data", (data: Buffer) => {
+                // 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();
+                // IMPORTANT! We terminate when the connection is closed, which is what makes this safe.
+                process.exit();
+            });
+            socket.on("error", (err: Error) => {
+                internalConnection.destroy();
+            });
+
+            internalConnection.on("close", () => {
+                socket.destroy();
+            });
+            internalConnection.on("error", (err: Error) => {
+                socket.destroy();
+            });
         });
-        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"));
+
+        // Wait to we start listening
+        server.on("listening", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                throw new Error("Failed to get server address");
             }
-            internalConnection.write(data);
-        });
 
-        // // Handle socket closure
-        socket.on("close", () => {
-            internalConnection.destroy();
-            // TESTING:
-            //  - For now, we don't close the server, so... we can reconnect. I think this might be required...
-            //server.close();
-        });
-        socket.on("error", (err) => {
-            internalConnection.destroy();
+            console.log(`EXTERNAL_PORT:${address.port}`);
         });
+    }).toString();
 
-        internalConnection.on("close", () => {
-            socket.destroy();
-        });
-        internalConnection.on("error", (err) => {
-            socket.destroy();
-        });
+    const child = child_process.spawn("node", [
+        "-e",
+        `(${forwardCode})()`,
+        JSON.stringify(config)
+    ]);
+
+    let externalPort: number | undefined;
+    let portPromiseResolve: ((port: number) => void) | undefined;
+    const portPromise = new Promise<number>((resolve) => {
+        portPromiseResolve = resolve;
     });
 
-    // Wait to we start listening
-    await new Promise((resolve) => {
-        server.on("listening", resolve);
+    let curData = "";
+    child.stdout.on("data", (data) => {
+        console.log(data.toString());
+        curData += data.toString();
+        const match = curData.match(/EXTERNAL_PORT:(\d+)/);
+        if (match) {
+            externalPort = parseInt(match[1], 10);
+            if (portPromiseResolve) {
+                portPromiseResolve(externalPort);
+            }
+        }
+    });
+
+    child.stderr.on("data", (data) => {
+        console.error(data.toString());
     });
 
-    // Get the randomly assigned port number
-    const address = server.address();
-    if (!address || typeof address === "string") {
-        throw new Error("Failed to get server address");
-    }
+    child.on("error", (err) => {
+        console.error("Failed to start child process:", err);
+        throw err;
+    });
 
-    console.log(`Exposing external port ${address.port} to internal port ${config.internalPort} (for ${config.externalIP})`);
+    // Wait for the port to be available
+    externalPort = await portPromise;
 
     return {
-        externalPort: address.port,
+        externalPort,
         cancel: () => {
-            server.close();
+            child.kill();
         }
     };
 }

package/src/diagnostics/NodeViewer.tsx

@@ -265,10 +265,11 @@ export class NodeViewer extends qreact.Component {
                                             <button onClick={async () => {
                                                 const controller = NodeViewerController.nodes[getBrowserUrlNode()];
                                                 let url = await controller.getExternalInspectURL(str);
+                                                console.log(url);
                                                 console.log(url.replace("https://notdevtools.com/devtools", "devtools://devtools/bundled"));
                                                 // devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&wss=99-250-124-91.querysub.com:2058/cc5b76b2-549f-4a66-8026-021811e9edd3
 
-                                                //window.open(url, "_blank");
+                                                window.open(url, "_blank");
                                             }}>
                                                 Inspect
                                             </button>