@karthik_yk/ws-tunnel-cli 1.0.0

package/README.md

@@ -0,0 +1,10 @@
+# ws-tunnel-cli
+
+A lightweight TCP & HTTP tunneling CLI (ngrok-style).
+
+## Install
+```bash
+npm install -g @karthik617/ws-tunnel-cli
+
+# Custom host
+ws-tunnel http 3000  wss://abcom.com

package/bin/tunnel.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../src/index.js";

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@karthik_yk/ws-tunnel-cli",
+  "version": "1.0.0",
+  "description": "websocket tunnel cli",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github-personal:karthik617/ws-tunnel-cli.git"
+  },
+  "bin": {
+    "ws-tunnel": "bin/tunnel.js"
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "keywords": [
+    "tunnel",
+    "ws",
+    "ngrok",
+    "http",
+    "cli"
+  ],
+  "license": "MIT",
+  "author": "karthik617",
+  "type": "module",
+  "main": "src/index.js",
+  "scripts": {
+    "start": "node src/index.js"
+  }
+}

package/src/httpClient.js

@@ -0,0 +1,97 @@
+import WebSocket from "ws";
+import http from "http";
+
+export function createHttpTunnel(localPort, remoteHost) {
+  if (!remoteHost || !/^wss?:\/\//.test(remoteHost)) {
+    throw new Error("remoteHost must be ws:// or wss:// url");
+  }
+
+  const ws = new WebSocket(remoteHost);
+
+  ws.on("open", () => {
+    ws.send(JSON.stringify({
+      type: "register",
+      localPort
+    }));
+  });
+
+  ws.on("message", async (msg) => {
+    const data = JSON.parse(msg.toString());
+
+    // 🌍 PUBLIC URL LOGIC (IMPORTANT)
+    if (data.type === "registered") {
+      const url = getPublicUrl(remoteHost, data.id);
+      console.log(`🌍 Public URL: ${url}`);
+      return;
+    }
+
+    if (data.type === "http_request") {
+      const response = await forwardToLocal(data, localPort);
+      ws.send(JSON.stringify({
+        type: "http_response",
+        requestId: data.requestId,
+        ...response
+      }));
+    }
+  });
+
+  ws.on("close", () => {
+    console.error("❌ Tunnel disconnected");
+    process.exit(1);
+  });
+
+  ws.on("error", (err) => {
+    console.error("❌ Tunnel error:", err.message);
+    process.exit(1);
+  });
+}
+
+function getPublicUrl(remoteHost, id) {
+  const { protocol, host } = new URL(remoteHost.replace("ws", "http"));
+
+  // Local dev → path based
+  if (host.startsWith("localhost") || host.startsWith("127.")) {
+    return `${protocol}//${host}/tunnel/${id}`;
+  }
+
+  // Production (Render) → subdomain based
+  return `${protocol}//${id}.${host}`;
+}
+
+function forwardToLocal(req, localPort) {
+  return new Promise((resolve) => {
+    const headers = { ...req.headers };
+    delete headers.host; // 🔥 IMPORTANT
+
+    const localReq = http.request(
+      {
+        host: "localhost",
+        port: localPort,
+        method: req.method,
+        path: req.path,
+        headers
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (c) => (body += c));
+        res.on("end", () => {
+          resolve({
+            status: res.statusCode,
+            headers: res.headers,
+            body
+          });
+        });
+      }
+    );
+
+    localReq.on("error", (err) => {
+      resolve({
+        status: 502,
+        body: err.message
+      });
+    });
+
+    if (req.body) localReq.write(req.body);
+    localReq.end();
+  });
+}

package/src/index.js

@@ -0,0 +1,25 @@
+import { createHttpTunnel } from "./httpClient.js";
+
+const args = process.argv.slice(2);
+if (args.length < 2) {
+  console.log(`
+  Usage:
+    ws-tunnel http <localPort> <wss:remoteHost>
+  
+  Examples:
+    ws-tunnel http 8080 wss://localhost:8080
+  `);
+  process.exit(1);
+}
+const [mode, localPort, remoteHost] = args;
+
+if (mode !== "http" || !localPort || !remoteHost) {
+  console.log("Usage: ws-tunnel http <localPort> <wss:remoteHost>");
+  process.exit(1);
+}
+try {
+    createHttpTunnel(Number(localPort), remoteHost);
+} catch (err) {
+  console.error(err.message);
+  process.exit(1);
+}