uplink-cli 0.1.37 → 0.1.39

package/scripts/tunnel/client-improved.js

@@ -55,10 +55,13 @@ function optionalRead(path) {
 
 // State
 let socket = null;
+// wsId -> net.Socket — active WebSocket (upgrade) passthrough sessions to the local service
+const wsSessions = new Map();
 let reconnectDelay = INITIAL_RECONNECT_DELAY;
 let reconnectTimer = null;
 let isConnected = false;
 let isRegistered = false;
+let shuttingDown = false;
 let healthCheckTimer = null;
 let lastHealthTimeoutLog = 0;
 let stats = {
@@ -138,6 +141,7 @@ function checkLocalService() {
 }
 
 function connect() {
+  if (shuttingDown) return;
   if (socket && !socket.destroyed) {
     socket.destroy();
   }
@@ -197,12 +201,27 @@ function connect() {
         const msg = JSON.parse(line);
         if (msg.type === "request") {
           handleRequest(msg);
+        } else if (msg.type === "ws-open") {
+          handleWsOpen(msg);
+        } else if (msg.type === "ws-data") {
+          const local = wsSessions.get(msg.id);
+          if (local && !local.destroyed) {
+            local.write(Buffer.from(msg.data || "", "base64"));
+          }
+        } else if (msg.type === "ws-close") {
+          const local = wsSessions.get(msg.id);
+          wsSessions.delete(msg.id);
+          if (local && !local.destroyed) local.end();
         } else if (msg.type === "registered") {
           isRegistered = true;
           log("success", `Registered with relay (token: ${token.substring(0, 8)}...)`);
           stats.reconnects = 0; // Reset reconnect count on successful registration
         } else if (msg.type === "error") {
           log("error", "Relay error:", msg.message || "Unknown error");
+          if (/invalid token/i.test(String(msg.message || ""))) {
+            log("error", "Token rejected by relay; exiting");
+            shutdown(1);
+          }
         }
       } catch (err) {
         log("error", "Parse error:", err.message, `(message length: ${line.length})`);
@@ -213,15 +232,18 @@ function connect() {
   socket.on("error", (err) => {
     isConnected = false;
     isRegistered = false;
+    closeAllWsSessions();
     logError(err, "Connection error");
-    scheduleReconnect();
+    if (!shuttingDown) scheduleReconnect();
   });
 
   socket.on("close", () => {
     const wasRegistered = isRegistered;
     isConnected = false;
     isRegistered = false;
-    
+    closeAllWsSessions();
+
+    if (shuttingDown) return;
     if (wasRegistered) {
       log("warn", "Connection closed. Attempting to reconnect...");
       scheduleReconnect();
@@ -232,6 +254,7 @@ function connect() {
 }
 
 function scheduleReconnect() {
+  if (shuttingDown) return;
   if (reconnectTimer) {
     clearTimeout(reconnectTimer);
   }
@@ -286,39 +309,45 @@ function handleRequest(msg) {
     headers: cleanHeaders,
     timeout: REQUEST_TIMEOUT,
   };
+  log("info", `Local ${options.method} ${options.path} host=${cleanHeaders.host || cleanHeaders.Host || "-"}`);
 
   const req = http.request(options, (resp) => {
-    const chunks = [];
-    let totalSize = 0;
-    
+    // Stream the response over the control channel instead of buffering it.
+    // This removes the response size cap (needed e.g. for large dev-mode JS
+    // chunks) and keeps memory usage flat regardless of response size.
+    let aborted = false;
+    const send = (obj) => {
+      if (!socket || socket.destroyed || !isRegistered) {
+        aborted = true;
+        resp.destroy();
+        return false;
+      }
+      return socket.write(JSON.stringify(obj) + "\n");
+    };
+
+    send({
+      type: "response-head",
+      id: msg.id,
+      status: resp.statusCode,
+      headers: resp.headers,
+    });
+
     resp.on("data", (d) => {
-      chunks.push(d);
-      totalSize += d.length;
-      
-      // Check response size
-      if (totalSize > MAX_BODY_SIZE) {
-        req.destroy();
-        log("error", `Response too large: ${totalSize} bytes (max: ${MAX_BODY_SIZE})`);
-        sendErrorResponse(msg.id, 413, "Response entity too large");
-        return;
+      if (aborted) return;
+      const ok = send({ type: "response-chunk", id: msg.id, data: d.toString("base64") });
+      // Backpressure: pause the local response while the control socket drains
+      if (ok === false && socket && !socket.destroyed) {
+        resp.pause();
+        socket.once("drain", () => resp.resume());
       }
     });
-    
+
     resp.on("end", () => {
-      const body = Buffer.concat(chunks);
-      const resMsg = {
-        type: "response",
-        id: msg.id,
-        status: resp.statusCode,
-        headers: resp.headers,
-        body: body.length ? body.toString("base64") : "",
-      };
-      
-      if (socket && !socket.destroyed && isRegistered) {
-        socket.write(JSON.stringify(resMsg) + "\n");
-      } else {
-        log("warn", "Cannot send response: not connected");
-      }
+      if (!aborted) send({ type: "response-end", id: msg.id });
+    });
+
+    resp.on("error", () => {
+      if (!aborted) send({ type: "response-end", id: msg.id });
     });
   });
 
@@ -353,6 +382,56 @@ function handleRequest(msg) {
   req.end();
 }
 
+// WebSocket / HTTP Upgrade passthrough: open a raw TCP connection to the
+// local service, replay the original handshake bytes, then stream data in
+// both directions over the control channel until either side closes.
+function handleWsOpen(msg) {
+  if (!msg.id || !msg.head) return;
+  stats.requests++;
+
+  const local = net.createConnection({ host: "127.0.0.1", port }, () => {
+    local.write(Buffer.from(msg.head, "base64"));
+  });
+  local.setNoDelay(true);
+  wsSessions.set(msg.id, local);
+
+  local.on("data", (data) => {
+    if (!socket || socket.destroyed || !isRegistered) return;
+    try {
+      socket.write(
+        JSON.stringify({ type: "ws-data", id: msg.id, data: data.toString("base64") }) + "\n"
+      );
+    } catch {
+      local.destroy();
+    }
+  });
+
+  const closeSession = () => {
+    if (!wsSessions.has(msg.id)) return;
+    wsSessions.delete(msg.id);
+    if (socket && !socket.destroyed && isRegistered) {
+      try {
+        socket.write(JSON.stringify({ type: "ws-close", id: msg.id }) + "\n");
+      } catch {
+        /* control channel gone */
+      }
+    }
+  };
+  local.on("close", closeSession);
+  local.on("error", (err) => {
+    stats.errors++;
+    logError(err, "Local ws connection error");
+    closeSession();
+  });
+}
+
+function closeAllWsSessions() {
+  for (const [, local] of wsSessions.entries()) {
+    if (!local.destroyed) local.destroy();
+  }
+  wsSessions.clear();
+}
+
 function sendErrorResponse(id, status, message) {
   if (!socket || socket.destroyed || !isRegistered) {
     return;
@@ -374,26 +453,36 @@ function sendErrorResponse(id, status, message) {
 }
 
 // Graceful shutdown
-function shutdown() {
+function shutdown(exitCode = 0) {
+  if (shuttingDown) {
+    process.exit(exitCode);
+    return;
+  }
+  shuttingDown = true;
   log("info", "Shutting down...");
-  
+
   if (reconnectTimer) {
     clearTimeout(reconnectTimer);
+    reconnectTimer = null;
   }
-  
+
   if (healthCheckTimer) {
     clearInterval(healthCheckTimer);
+    healthCheckTimer = null;
   }
-  
+
+  closeAllWsSessions();
+
   if (socket && !socket.destroyed) {
-    socket.end();
+    socket.removeAllListeners("close");
+    socket.removeAllListeners("error");
+    socket.destroy();
   }
-  
-  // Print stats
+
   const uptime = Math.floor((Date.now() - stats.startTime) / 1000);
   log("info", `Stats: ${stats.requests} requests, ${stats.errors} errors, ${stats.reconnects} reconnects, ${uptime}s uptime`);
-  
-  process.exit(0);
+
+  process.exit(exitCode);
 }
 
 // Start connection

package/scripts/tunnel/client.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * Minimal tunnel client for local testing.
+ * Connects to control server, receives HTTP requests, proxies to localhost:port.
+ * Usage: node scripts/tunnel/client.js --token <token> --port 3000 --ctrl 127.0.0.1:7071
+ */
+
+const net = require("net");
+const http = require("http");
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const out = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--token") out.token = args[++i];
+    else if (a === "--port") out.port = Number(args[++i]);
+    else if (a === "--ctrl") out.ctrl = args[++i];
+  }
+  return out;
+}
+
+const { token, port, ctrl } = parseArgs();
+if (!token || !port || !ctrl) {
+  console.error("Usage: node scripts/tunnel/client.js --token <token> --port <port> --ctrl <host:port>");
+  process.exit(1);
+}
+
+const [CTRL_HOST, CTRL_PORT] = ctrl.split(":");
+
+function log(...args) {
+  console.log(new Date().toISOString(), ...args);
+}
+
+const socket = net.createConnection({ host: CTRL_HOST, port: Number(CTRL_PORT) }, () => {
+  log("connected to relay ctrl");
+  socket.write(
+    JSON.stringify({ type: "register", token, targetPort: port }) + "\n"
+  );
+});
+
+let buf = "";
+socket.on("data", (chunk) => {
+  buf += chunk.toString("utf8");
+  let idx;
+  while ((idx = buf.indexOf("\n")) >= 0) {
+    const line = buf.slice(0, idx);
+    buf = buf.slice(idx + 1);
+    if (!line.trim()) continue;
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "request") {
+        handleRequest(msg);
+      } else if (msg.type === "registered") {
+        log("registered with relay");
+      }
+    } catch (err) {
+      log("client parse error", err.message);
+    }
+  }
+});
+
+socket.on("error", (err) => {
+  log("ctrl connection error", err.message);
+  process.exit(1);
+});
+
+socket.on("close", () => {
+  log("ctrl connection closed");
+  process.exit(1);
+});
+
+function handleRequest(msg) {
+  const options = {
+    hostname: "127.0.0.1",
+    port,
+    path: msg.path || "/",
+    method: msg.method || "GET",
+    headers: msg.headers || {},
+  };
+
+  const req = http.request(options, (resp) => {
+    const chunks = [];
+    resp.on("data", (d) => chunks.push(d));
+    resp.on("end", () => {
+      const body = Buffer.concat(chunks);
+      const resMsg = {
+        type: "response",
+        id: msg.id,
+        status: resp.statusCode,
+        headers: resp.headers,
+        body: body.length ? body.toString("base64") : "",
+      };
+      socket.write(JSON.stringify(resMsg) + "\n");
+    });
+  });
+
+  req.on("error", (err) => {
+    const resMsg = {
+      type: "response",
+      id: msg.id,
+      status: 502,
+      headers: { "x-tunnel-error": err.message },
+      body: "",
+    };
+    socket.write(JSON.stringify(resMsg) + "\n");
+  });
+
+  if (msg.body) {
+    req.write(Buffer.from(msg.body, "base64"));
+  }
+  req.end();
+}
+
+
+
+
+