Merge branch 'main' of https://github.com/CUBETIQ/http-tunnel-client

Bump https-proxy-agent from 7.0.0 to 7.0.1

.npmignore

@@ -1,2 +1,3 @@
 src/
 .github/
+test/

CHANGELOG.md

@@ -1,3 +1,9 @@
+### 11/07/2023
+
+-   Support Client API
+-   Support Proxy (HTTP/HTTPS) and TCP
+-   Improvements and Bugs fixed
+
 ### 30/11/2022
 
 -   Fixed response data in axios request with accept-encoding to identity

bin/hlt

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-require('../dist/client');
+require('../dist/cli');

package.json

@@ -1,14 +1,15 @@
 {
   "name": "@cubetiq/hlt",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "A lightweight http tunnel client using nodejs and socket.io client",
-  "main": "dist/client.js",
+  "main": "dist/cli.js",
   "bin": {
     "hlt": "bin/hlt"
   },
   "scripts": {
-    "start": "ts-node-dev --respawn --transpile-only src/client.ts",
-    "local": "ts-node-dev --respawn --transpile-only src/client.ts start -p local",
+    "start": "ts-node-dev --respawn --transpile-only src/cli.ts",
+    "test": "ts-node-dev --respawn --transpile-only src/test.ts",
+    "local": "ts-node-dev --respawn --transpile-only src/cli.ts start -p local",
     "build": "tsc"
   },
   "repository": {
@@ -23,16 +24,19 @@
   "license": "ISC",
   "dependencies": {
     "axios": "^1.2.0",
-    "commander": "^9.3.0",
-    "https-proxy-agent": "^5.0.1",
+    "express": "^4.18.2",
+    "http-proxy-middleware": "^2.0.6",
+    "commander": "^11.0.0",
+    "https-proxy-agent": "^7.0.0",
     "socket.io-client": "^4.5.1"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@types/node": "^18.0.3",
+    "@types/express": "^4.17.15",
+    "@types/node": "^20.0.0",
     "ts-node-dev": "^2.0.0",
-    "typescript": "^4.7.4"
+    "typescript": "^5.0.0"
   }
 }

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base"
+  ]
+}

src/api.ts

@@ -0,0 +1,353 @@
+import * as fs from "fs";
+import * as http from "http";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import * as os from "os";
+import * as path from "path";
+import { Socket, io } from "socket.io-client";
+import { TunnelRequest, TunnelResponse } from "./lib";
+import { addPrefixOnHttpSchema, generateUUID } from "./util";
+
+import { PROFILE_DEFAULT, PROFILE_PATH, SERVER_DEFAULT_URL, TOKEN_FREE } from "./constant";
+import { ClientOptions, Options } from "./interface";
+import { getTokenFree } from './sdk';
+
+interface Stoppable {
+    stop(): void;
+}
+
+class HttpTunnelClient implements Stoppable {
+    // create socket instance
+    private socket: Socket | null = null;
+    private keepAliveTimer: NodeJS.Timeout | null = null;
+    private keepAliveTimeout: number | null = null;
+
+    private keepAlive() {
+        if (!this.socket) {
+            return;
+        }
+
+        this.keepAliveTimer = setTimeout(() => {
+            if (this.socket && this.socket.connected) {
+                this.socket.send("ping");
+            }
+            this.keepAlive();
+        }, this.keepAliveTimeout || 5000);
+    }
+
+    // Init the Client for config file
+    public initConfigFile = async (options: any) => {
+        const profile = options.profile || PROFILE_DEFAULT;
+        const configDir = path.resolve(os.homedir(), PROFILE_PATH);
+
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir);
+            console.log(`config file ${configDir} was created`);
+        }
+
+        let config: any = {};
+        const configFilename = `${profile}.json`;
+        const configFilePath = path.resolve(configDir, configFilename);
+
+        if (fs.existsSync(configFilePath)) {
+            config = JSON.parse(fs.readFileSync(configFilePath, "utf8"));
+        }
+
+        // Force reset config server from client init
+        if (!config.server || options.force) {
+            config.server = options.server || SERVER_DEFAULT_URL;
+        }
+
+        if (!config.token && options.token) {
+            config.token = options.token;
+        }
+
+        if (!config.access) {
+            config.access = options.access || TOKEN_FREE;
+        }
+
+        if (!config.clientId) {
+            config.clientId = options.client || generateUUID();
+        }
+
+        if (!config.apiKey && options.key) {
+            config.apiKey = options.key;
+        }
+
+        let errorCode = 0;
+        if (!config.token || options.force) {
+            console.log(`Generating token from server: ${config.server}`);
+            await getTokenFree(config.server, {
+                timestamp: (new Date().getTime()),
+                clientId: config.clientId,
+                apiKey: config.apiKey,
+            })
+                .then((resp: any) => {
+                    if (resp.data?.token) {
+                        console.log("Token generated successfully!");
+                        config.token = resp.data?.token;
+                    } else {
+                        errorCode = 1;
+                        console.error("Generate free token failed, return with null or empty from server!", resp);
+                        return;
+                    }
+                })
+                .catch((err: any) => {
+                    errorCode = 1;
+                    console.error("cannot get free token from server", err);
+                    return;
+                });
+        }
+
+        if (errorCode === 0) {
+            fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
+            console.log(`initialized config saved successfully to: ${configFilePath}`);
+        }
+    };
+
+    // Start Client
+    public initStartClient = async (options: Options) => {
+        // Please change this if your domain goes wrong here
+        // Current style using sub-domain: https://{{clientId}}-tunnel.myhostingdomain.com
+        // (Original server: https://tunnel.myhostingdomain.com)
+        const profile = options.profile || PROFILE_DEFAULT;
+        const clientId = `${options.apiKey || options.clientId || generateUUID()}`;
+        const clientIdSub =
+            profile === PROFILE_DEFAULT ? `${clientId}-` : `${clientId}-${profile}-`;
+        const clientEndpoint = (
+            options.suffix ? `${clientIdSub}${options.suffix}-` : clientIdSub
+        )
+            .toLowerCase()
+            .trim();
+        const serverUrl = addPrefixOnHttpSchema(options.server || SERVER_DEFAULT_URL, clientEndpoint);
+
+        // extra options for socket to identify the client (authentication and options of tunnel)
+        const defaultParams = {
+            apiKey: options.apiKey,
+            clientId: options.clientId,
+            profile: profile,
+            clientIdSub: clientIdSub,
+            clientEndpoint: clientEndpoint,
+            serverUrl: serverUrl,
+            access: options.access,
+            keep_connection: options.keep_connection || true,
+        };
+
+        // extra info for notify about the running of the tunnel (it's private info, other platfom cannot access this)
+        // this using for internal only (don't worry about this)
+        const osInfo = {
+            hostname: os.hostname(),
+            platform: os.platform(),
+            arch: os.arch(),
+            release: os.release(),
+            timestamp: new Date().getTime(),
+        };
+
+        const initParams: any = {
+            path: "/$cubetiq_http_tunnel",
+            transports: ["websocket"],
+            auth: {
+                token: options.token,
+                ...defaultParams,
+            },
+            headers: {
+                ...defaultParams,
+                os: osInfo,
+            },
+            // reconnection: true,
+        };
+
+        const http_proxy = process.env.https_proxy || process.env.http_proxy;
+        if (http_proxy) {
+            initParams.agent = new HttpsProxyAgent(http_proxy);
+        }
+
+        // Connecting to socket server and agent here...
+        console.log(`client connecting to server: ${serverUrl}`);
+        this.socket = io(serverUrl, initParams);
+
+        const clientLogPrefix = `client: ${clientId} on profile: ${profile}`;
+        this.socket.on("connect", () => {
+            if (this.socket!.connected) {
+                console.log(`${clientLogPrefix} is connected to server successfully!`);
+            }
+        });
+
+        this.socket.on("connect_error", (e) => {
+            console.error(
+                `${clientLogPrefix} connect error:`,
+                (e && e.message) || "something wrong"
+            );
+            if (e && e.message && e.message.startsWith("[40")) {
+                process.exit(1);
+            }
+        });
+
+        this.socket.on("disconnect", (reason) => {
+            console.warn(`${clientLogPrefix} disconnected: ${reason}!`);
+        });
+
+        this.socket.on("disconnect_exit", (reason) => {
+            console.warn(`${clientLogPrefix} disconnected and exited ${reason}!`);
+            this.socket?.disconnect();
+            process.exit(1);
+        });
+
+        this.socket.on("request", (requestId, request) => {
+            const isWebSocket = request.headers.upgrade === "websocket";
+            console.log(`${isWebSocket ? "WS" : request.method}: `, request.path);
+            request.port = options.port;
+            request.hostname = options.host;
+
+            if (options.origin) {
+                request.headers.host = options.origin;
+            }
+
+            const tunnelRequest = new TunnelRequest(this.socket!, requestId);
+
+            const localReq = http.request(request);
+            tunnelRequest.pipe(localReq);
+
+            const onTunnelRequestError = (e: any) => {
+                console.error("tunnel request error: ", e);
+                tunnelRequest.off("end", onTunnelRequestEnd);
+                localReq.destroy(e);
+            };
+
+            const onTunnelRequestEnd = () => {
+                tunnelRequest.off("error", onTunnelRequestError);
+            };
+
+            tunnelRequest.once("error", onTunnelRequestError);
+            tunnelRequest.once("end", onTunnelRequestEnd);
+
+            const onLocalResponse = (localRes: any) => {
+                localReq.off("error", onLocalError);
+
+                if (isWebSocket && localRes.upgrade) {
+                    return;
+                }
+
+                const tunnelResponse = new TunnelResponse(this.socket!, requestId);
+
+                tunnelResponse.writeHead(
+                    localRes.statusCode,
+                    localRes.statusMessage,
+                    localRes.headers,
+                    localRes.httpVersion
+                );
+
+                localRes.pipe(tunnelResponse);
+            };
+
+            const onLocalError = (error: any) => {
+                console.error("local error:", error);
+                localReq.off("response", onLocalResponse);
+                this.socket?.emit("request-error", requestId, error && error.message);
+                tunnelRequest.destroy(error);
+            };
+
+            const onUpgrade = (localRes: any, localSocket: any, localHead: any) => {
+                // localSocket.once('error', onTunnelRequestError);
+                if (localHead && localHead.length) localSocket.unshift(localHead);
+
+                const tunnelResponse = new TunnelResponse(this.socket!, requestId, true);
+                tunnelResponse.writeHead(null, null, localRes.headers);
+                localSocket.pipe(tunnelResponse).pipe(localSocket);
+            };
+
+            localReq.once("error", onLocalError);
+            localReq.once("response", onLocalResponse);
+
+            if (isWebSocket) {
+                localReq.on("upgrade", onUpgrade);
+            }
+        });
+
+        // reconnect manually
+        // const tryReconnect = () => {
+        //     setTimeout(() => {
+        //         socket!.io.open((err) => {
+        //             if (err) {
+        //                 tryReconnect();
+        //             }
+        //         });
+        //     }, 2000);
+        // };
+        // socket.io.on("close", tryReconnect);
+
+        this.keepAlive();
+    };
+
+    public start = async (clientOptions: ClientOptions): Promise<Stoppable | undefined> => {
+        const { port, options = {} } = clientOptions;
+        const configDir = path.resolve(os.homedir(), PROFILE_PATH);
+
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir);
+        }
+
+        let config: any = {};
+        const configFilename = `${options.profile || PROFILE_DEFAULT}.json`;
+        const configFilePath = path.resolve(configDir, configFilename);
+        console.log(`config file: ${configFilePath}`);
+
+        if (fs.existsSync(configFilePath)) {
+            config = JSON.parse(fs.readFileSync(configFilePath, "utf8"));
+        }
+
+        if (!config.server) {
+            config.server = SERVER_DEFAULT_URL;
+        }
+
+        if (!config.token) {
+            console.info(`please init or set token for ${config.server}`);
+            return;
+        }
+
+        if (!config.clientId) {
+            if (!config.apiKey) {
+                console.info(`please init or create a client for ${config.server}`);
+            } else {
+                config.clientId = config.apiKey;
+            }
+            return;
+        }
+
+        options.port = port;
+        options.token = config.token;
+        options.access = config.access;
+        options.server = config.server;
+        options.clientId = config.clientId;
+        options.apiKey = options.key || config.apiKey;
+
+        if (options.suffix === "port" || options.suffix === "true") {
+            options.suffix = `${port}`;
+        } else if (options.suffix === "false") {
+            options.suffix = undefined;
+        } else if (options.suffix === "gen" || options.suffix === "uuid") {
+            options.suffix = generateUUID();
+        }
+
+        await this.initStartClient(options);
+        console.log("client started!");
+
+        return this;
+    };
+
+    public stop = () => {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket.close();
+            this.socket = null;
+            this.keepAliveTimer && clearInterval(this.keepAliveTimer);
+
+            console.log("client stopped!");
+        }
+    };
+}
+
+export const client = new HttpTunnelClient();
+
+export const initConfigFileClient = client.initConfigFile;
+export const startClient = client.start;
+export const stopClient = client.stop;

src/cli.ts

@@ -0,0 +1,304 @@
+import { Argument, InvalidArgumentError, program } from "commander";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { initConfigFileClient, startClient } from "./api";
+import { PROFILE_DEFAULT, PROFILE_PATH, SERVER_DEFAULT_URL, TOKEN_FREE } from "./constant";
+import { createProxyServer } from "./proxy";
+import { createProxyServer as createProxyTCPServer } from "./proxy_tcp";
+import { getTokenFree } from './sdk';
+import { generateUUID, isValidHost, isValidUrl } from "./util";
+
+const packageInfo = require("../package.json");
+
+program
+  .name("hlt")
+  .description(
+    "CUBETIQ HTTP tunnel client with free access for local tunneling"
+  )
+  .version(`v${packageInfo.version}`);
+
+// init
+program
+  .command("init")
+  .description("generate a new client and token with free access")
+  .option("-s --server <string>", "setting server url", SERVER_DEFAULT_URL)
+  .option(
+    "-t --token <string>",
+    "setting token (default generate FREE access token)",
+    ""
+  )
+  .option("-a --access <string>", "setting token access type", TOKEN_FREE)
+  .option("-c --client <string>", "setting client (auto generate uuid)")
+  .option(
+    "-k --key <string>",
+    "setting client api key for authentication access"
+  )
+  .option("-p --profile <string>", "setting profile name", PROFILE_DEFAULT)
+  .option("-f --force", "force to generate new client and token", false)
+  .action(async (options) => {
+    initConfigFileClient(options);
+  });
+
+// start
+program
+  .command("start")
+  .description("start a connection with specific port")
+  .argument("<port>", "local server port number", (value) => {
+    const port = parseInt(value, 10);
+    if (isNaN(port)) {
+      throw new InvalidArgumentError("Not a number.");
+    }
+    return port;
+  })
+  .option("-s, --suffix <string>", "suffix for client name")
+  .option(
+    "-K, --keep_connection <boolean>",
+    "keep connection for client and old connection will be closed (override connection)",
+    true
+  )
+  .option(
+    "-k --key <string>",
+    "setting client api key for authentication access"
+  )
+  .option("-a, --access <string>", "access type (FREE)", TOKEN_FREE)
+  .option("-p, --profile <string>", "profile name", PROFILE_DEFAULT)
+  .option("-h, --host <string>", "local host value", "localhost")
+  .option("-o, --origin <string>", "change request origin")
+  .action((port, options) => {
+    startClient({
+      port,
+      options,
+    })
+  });
+
+// config
+program
+  .command("config")
+  .description("create and update config file for connection")
+  .addArgument(
+    new Argument("<type>", "config type").choices([
+      "access",
+      "token",
+      "server",
+      "client",
+      "key",
+    ])
+  )
+  .argument("<value>", "config value")
+  .option("-p --profile <string>", "setting profile name", PROFILE_DEFAULT)
+  .action(async (type, value, options) => {
+    if (!type) {
+      console.error("type config is required!");
+      return;
+    }
+
+    const configDir = path.resolve(os.homedir(), PROFILE_PATH);
+
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir);
+      console.log(`config file ${configDir} was created`);
+    }
+
+    let config: any = {};
+    const configFilename = `${options.profile}.json`;
+    const configFilePath = path.resolve(configDir, configFilename);
+
+    if (fs.existsSync(configFilePath)) {
+      config = JSON.parse(fs.readFileSync(configFilePath, "utf8"));
+    }
+
+    if (!config.server) {
+      config.server = SERVER_DEFAULT_URL;
+    }
+
+    // Error Code status
+    let errorCode = 0;
+
+    if (type === "token" || type === "jwt") {
+      config.token = value;
+    } else if (type === "server") {
+      config.server = value;
+    } else if (type === "clientId" || type === "client") {
+      if (!value || value === "" || value === "new") {
+        config.clientId = generateUUID();
+      } else {
+        config.clientId = value;
+      }
+      console.log(`client: ${config.clientId} was set to config`);
+    } else if (type === "apiKey" || type === "key") {
+      config.apiKey = value;
+    } else if (type === "access") {
+      config.access = (value && value.toUpperCase().trim()) || TOKEN_FREE;
+
+      // FREE
+      if (config.access === TOKEN_FREE) {
+        await getTokenFree(config.server)
+          .then((resp: any) => {
+            if (resp.data?.token) {
+              config.token = resp.data?.token;
+            } else {
+              errorCode = 1;
+              console.error("Generate free token failed, return with null or empty from server!", resp);
+              return;
+            }
+          })
+          .catch((err: any) => {
+            errorCode = 1;
+            console.error("cannot get free token from server", err);
+            return;
+          });
+      }
+    }
+
+    if (!config.clientId && config.apiKey) {
+      config.clientId = config.apiKey;
+    }
+
+    if (errorCode === 0) {
+      fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
+      console.log(`${type} config saved successfully to: ${configFilePath}`);
+    }
+  });
+
+// config
+program
+  .command("config-get")
+  .description("get type from config file")
+  .addArgument(
+    new Argument("<type>", "config type").choices([
+      "access",
+      "token",
+      "server",
+      "client",
+      "key",
+    ])
+  )
+  .option("-p --profile <string>", "setting profile name", PROFILE_DEFAULT)
+  .action(async (type, options) => {
+    if (!type) {
+      console.error("type config is required!");
+      return;
+    }
+
+    const configDir = path.resolve(os.homedir(), PROFILE_PATH);
+    if (!fs.existsSync(configDir)) {
+      console.log(`config file ${configDir} not found`);
+      return;
+    }
+
+    let config: any = {};
+    const configFilename = `${options.profile}.json`;
+    const configFilePath = path.resolve(configDir, configFilename);
+
+    if (fs.existsSync(configFilePath)) {
+      config = JSON.parse(fs.readFileSync(configFilePath, "utf8"));
+    } else {
+      console.log(`config file ${configFilePath} not found`);
+      return;
+    }
+
+    if (type === "token" || type === "jwt") {
+      console.log(config.token);
+    } else if (type === "server") {
+      console.log(config.server);
+    } else if (type === "clientId" || type === "client") {
+      console.log(config.clientId);
+    } else if (type === "apiKey" || type === "key") {
+      console.log(config.apiKey);
+    } else if (type === "access") {
+      console.log(config.access);
+    } else {
+      console.log('no config found for type: "' + type + '"');
+    }
+  });
+
+// proxy
+program
+  .command("proxy")
+  .description("start a proxy server with specific port")
+  .argument("<port>", "local server port number", (value) => {
+    const port = parseInt(value, 10);
+    if (isNaN(port)) {
+      throw new InvalidArgumentError("Not a number.");
+    }
+    return port;
+  })
+  .argument("<target>", "target server url (https://google.com) or tcp (tcp://127.0.0.1:8080 or 127.0.0.1:8080)", (value) => {
+    // Validate target
+    if (!value) {
+      throw new InvalidArgumentError("Target is required.");
+    }
+
+    // Check if target is url
+    if (value.indexOf("http") === 0 || value.indexOf("https") === 0) {
+      if (isValidUrl(value)) {
+        return value;
+      }
+
+      throw new InvalidArgumentError("Target is not a valid url.");
+    }
+
+    if (value.indexOf("tcp") === 0) {
+      // Remove tcp prefix from target
+      const t = value.substring(6); // remove tcp prefix (tcp://)
+      if (isValidHost(t)) {
+        return value;
+      }
+
+      throw new InvalidArgumentError("Target is not a valid tcp host.");
+    }
+
+    // Check if target is host with port (tcp)
+    const target = value.split(":");
+    if (target.length === 2) {
+      const port = parseInt(target[1], 10);
+      if (isNaN(port)) {
+        throw new InvalidArgumentError("Target port is not a number.");
+      }
+
+      return `tcp://${value}`;
+    }
+
+    if (isValidHost(value)) {
+      return `tcp://${value}`
+    }
+
+    throw new InvalidArgumentError("Target is not a url or host with port.");
+  })
+  .action((port, target) => {
+    const isTcp = target.indexOf("tcp") === 0;
+    if (isTcp) {
+      console.log("[TCP] Start proxy server with port:", port, "and target:", target);
+      const t = target.substring(6); // remove tcp prefix (tcp://)
+      const targetHost = t.split(":")[0];
+      const targetPort = parseInt(t.split(":")[1], 10);
+      const proxy = createProxyTCPServer(targetHost, targetPort, {
+        proxyPort: port,
+      });
+
+      proxy.on("error", (err) => {
+        console.error("Proxy server error:", err);
+      });
+
+      proxy.on("close", () => {
+        console.log("Proxy server closed");
+      });
+    } else {
+      console.log("[HTTP/HTTPS] Start proxy server with port:", port, "and target:", target);
+      const proxy = createProxyServer(target, {
+        proxyPort: port,
+      });
+
+      proxy.on("error", (err) => {
+        console.error("Proxy server error:", err);
+      });
+
+      proxy.on("close", () => {
+        console.log("Proxy server closed");
+      });
+    }
+  });
+
+
+program.parse();

src/client.ts

@@ -1,517 +0,0 @@
-import * as os from "os";
-import * as fs from "fs";
-import * as path from "path";
-import * as http from "http";
-import { io } from "socket.io-client";
-import { HttpsProxyAgent } from "https-proxy-agent";
-import { program, InvalidArgumentError, Argument } from "commander";
-import { TunnelRequest, TunnelResponse } from "./lib";
-import { generateUUID, addPrefixOnHttpSchema } from "./util";
-import { Socket } from 'socket.io-client';
-
-import { getTokenFree } from './sdk'
-
-const packageInfo = require("../package.json");
-
-// constants
-const PROFILE_DEFAULT = "default";
-const PROFILE_PATH = ".hlt";
-const SERVER_DEFAULT_URL = "https://lt.ctdn.net";
-const TOKEN_FREE = "FREE";
-
-// create socket instance
-let socket: Socket | null = null;
-
-function keepAlive() {
-  setTimeout(() => {
-    if (socket && socket.connected) {
-      socket.send("ping");
-    }
-    keepAlive();
-  }, 5000);
-}
-
-function initClient(options: any) {
-  // Please change this if your domain goes wrong here
-  // Current style using sub-domain: https://{{clientId}}-tunnel.myhostingdomain.com
-  // (Original server: https://tunnel.myhostingdomain.com)
-  const profile = options.profile || PROFILE_DEFAULT;
-  const clientId = `${options.apiKey || options.clientId || generateUUID()}`;
-  const clientIdSub =
-    profile === PROFILE_DEFAULT ? `${clientId}-` : `${clientId}-${profile}-`;
-  const clientEndpoint = (
-    options.suffix ? `${clientIdSub}${options.suffix}-` : clientIdSub
-  )
-    .toLowerCase()
-    .trim();
-  const serverUrl = addPrefixOnHttpSchema(options.server, clientEndpoint);
-
-  // extra options for socket to identify the client (authentication and options of tunnel)
-  const defaultParams = {
-    apiKey: options.apiKey,
-    clientId: options.clientId,
-    profile: options.profile,
-    clientIdSub: clientIdSub,
-    clientEndpoint: clientEndpoint,
-    serverUrl: serverUrl,
-    access: options.access,
-    keep_connection: options.keep_connection || true,
-  };
-
-  // extra info for notify about the running of the tunnel (it's private info, other platfom cannot access this)
-  // this using for internal only (don't worry about this)
-  const osInfo = {
-    hostname: os.hostname(),
-    platform: os.platform(),
-    arch: os.arch(),
-    release: os.release(),
-  };
-
-  const initParams: any = {
-    path: "/$cubetiq_http_tunnel",
-    transports: ["websocket"],
-    auth: {
-      token: options.token,
-      ...defaultParams,
-    },
-    headers: {
-      ...defaultParams,
-      os: osInfo,
-    },
-    // reconnection: true,
-  };
-
-  const http_proxy = process.env.https_proxy || process.env.http_proxy;
-  if (http_proxy) {
-    initParams.agent = new HttpsProxyAgent(http_proxy);
-  }
-
-  // Connecting to socket server and agent here...
-  console.log(`client connecting to server: ${serverUrl}`);
-  socket = io(serverUrl, initParams);
-
-  const clientLogPrefix = `client: ${clientId} on profile: ${profile}`;
-  socket.on("connect", () => {
-    if (socket!.connected) {
-      console.log(`${clientLogPrefix} is connected to server successfully!`);
-    }
-  });
-
-  socket.on("connect_error", (e) => {
-    console.error(
-      `${clientLogPrefix} connect error:`,
-      (e && e.message) || "something wrong"
-    );
-    if (e && e.message && e.message.startsWith("[40")) {
-      process.exit(1);
-    }
-  });
-
-  socket.on("disconnect", (reason) => {
-    console.warn(`${clientLogPrefix} disconnected: ${reason}!`);
-  });
-
-  socket.on("disconnect_exit", (reason) => {
-    console.warn(`${clientLogPrefix} disconnected and exited ${reason}!`);
-    socket?.disconnect();
-    process.exit(1);
-  });
-
-  socket.on("request", (requestId, request) => {
-    const isWebSocket = request.headers.upgrade === "websocket";
-    console.log(`${isWebSocket ? "WS" : request.method}: `, request.path);
-    request.port = options.port;
-    request.hostname = options.host;
-
-    if (options.origin) {
-      request.headers.host = options.origin;
-    }
-
-    const tunnelRequest = new TunnelRequest(socket!, requestId);
-
-    const localReq = http.request(request);
-    tunnelRequest.pipe(localReq);
-
-    const onTunnelRequestError = (e: any) => {
-      console.error("tunnel request error: ", e);
-      tunnelRequest.off("end", onTunnelRequestEnd);
-      localReq.destroy(e);
-    };
-
-    const onTunnelRequestEnd = () => {
-      tunnelRequest.off("error", onTunnelRequestError);
-    };
-
-    tunnelRequest.once("error", onTunnelRequestError);
-    tunnelRequest.once("end", onTunnelRequestEnd);
-
-    const onLocalResponse = (localRes: any) => {
-      localReq.off("error", onLocalError);
-
-      if (isWebSocket && localRes.upgrade) {
-        return;
-      }
-
-      const tunnelResponse = new TunnelResponse(socket!, requestId);
-
-      tunnelResponse.writeHead(
-        localRes.statusCode,
-        localRes.statusMessage,
-        localRes.headers,
-        localRes.httpVersion
-      );
-
-      localRes.pipe(tunnelResponse);
-    };
-
-    const onLocalError = (error: any) => {
-      console.error("local error:", error);
-      localReq.off("response", onLocalResponse);
-      socket?.emit("request-error", requestId, error && error.message);
-      tunnelRequest.destroy(error);
-    };
-
-    const onUpgrade = (localRes: any, localSocket: any, localHead: any) => {
-      // localSocket.once('error', onTunnelRequestError);
-      if (localHead && localHead.length) localSocket.unshift(localHead);
-
-      const tunnelResponse = new TunnelResponse(socket!, requestId, true);
-      tunnelResponse.writeHead(null, null, localRes.headers);
-      localSocket.pipe(tunnelResponse).pipe(localSocket);
-    };
-
-    localReq.once("error", onLocalError);
-    localReq.once("response", onLocalResponse);
-
-    if (isWebSocket) {
-      localReq.on("upgrade", onUpgrade);
-    }
-  });
-
-  // reconnect manually
-  const tryReconnect = () => {
-    setTimeout(() => {
-      socket!.io.open((err) => {
-        if (err) {
-          tryReconnect();
-        }
-      });
-    }, 2000);
-  };
-
-  // socket.io.on("close", tryReconnect);
-
-  keepAlive();
-}
-
-program
-  .name("hlt")
-  .description(
-    "CUBETIQ HTTP tunnel client with free access for local tunneling"
-  )
-  .version(`v${packageInfo.version}`);
-
-// init
-program
-  .command("init")
-  .description("generate a new client and token with free access")
-  .option("-s --server <string>", "setting server url", SERVER_DEFAULT_URL)
-  .option(
-    "-t --token <string>",
-    "setting token (default generate FREE access token)",
-    ""
-  )
-  .option("-a --access <string>", "setting token access type", TOKEN_FREE)
-  .option("-c --client <string>", "setting client (auto generate uuid)")
-  .option(
-    "-k --key <string>",
-    "setting client api key for authentication access"
-  )
-  .option("-p --profile <string>", "setting profile name", PROFILE_DEFAULT)
-  .option("-f --force", "force to generate new client and token", false)
-  .action(async (options) => {
-    const configDir = path.resolve(os.homedir(), PROFILE_PATH);
-
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir);
-      console.log(`config file ${configDir} was created`);
-    }
-
-    let config: any = {};
-    const configFilename = `${options.profile}.json`;
-    const configFilePath = path.resolve(configDir, configFilename);
-
-    if (fs.existsSync(configFilePath)) {
-      config = JSON.parse(fs.readFileSync(configFilePath, "utf8"));
-    }
-
-    // Force reset config server from client init
-    if (!config.server || options.force) {
-      config.server = options.server || SERVER_DEFAULT_URL;
-    }
-
-    if (!config.token && options.token) {
-      config.token = options.token;
-    }
-
-    if (!config.access) {
-      config.access = options.access || TOKEN_FREE;
-    }
-
-    if (!config.clientId) {
-      config.clientId = options.client || generateUUID();
-    }
-
-    if (!config.apiKey && options.key) {
-      config.apiKey = options.key;
-    }
-
-    let errorCode = 0;
-    if (!config.token || options.force) {
-      console.log(`Generating token from server: ${config.server}`);
-      await getTokenFree(config.server, {
-        timestamp: (new Date().getTime()),
-        clientId: config.clientId,
-        apiKey: config.apiKey,
-      })
-        .then((resp: any) => {
-          if (resp.data?.token) {
-            console.log("Token generated successfully!");
-            config.token = resp.data?.token;
-          } else {
-            errorCode = 1;
-            console.error("Generate free token failed, return with null or empty from server!", resp);
-            return;
-          }
-        })
-        .catch((err: any) => {
-          errorCode = 1;
-          console.error("cannot get free token from server", err);
-          return;
-        });
-    }
-
-    if (errorCode === 0) {
-      fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
-      console.log(`initialized config saved successfully to: ${configFilePath}`);
-    }
-  });
-
-// start
-program
-  .command("start")
-  .description("start a connection with specific port")
-  .argument("<port>", "local server port number", (value) => {
-    const port = parseInt(value, 10);
-    if (isNaN(port)) {
-      throw new InvalidArgumentError("Not a number.");
-    }
-    return port;
-  })
-  .option("-s, --suffix <string>", "suffix for client name")
-  .option(
-    "-K, --keep_connection <boolean>",
-    "keep connection for client and old connection will be closed (override connection)",
-    true
-  )
-  .option(
-    "-k --key <string>",
-    "setting client api key for authentication access"
-  )
-  .option("-a, --access <string>", "access type (FREE)", TOKEN_FREE)
-  .option("-p, --profile <string>", "profile name", PROFILE_DEFAULT)
-  .option("-h, --host <string>", "local host value", "localhost")
-  .option("-o, --origin <string>", "change request origin")
-  .action((port, options) => {
-    const configDir = path.resolve(os.homedir(), PROFILE_PATH);
-
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir);
-    }
-
-    let config: any = {};
-    const configFilename = `${options.profile}.json`;
-    const configFilePath = path.resolve(configDir, configFilename);
-
-    if (fs.existsSync(configFilePath)) {
-      config = JSON.parse(fs.readFileSync(configFilePath, "utf8"));
-    }
-
-    if (!config.server) {
-      config.server = SERVER_DEFAULT_URL;
-    }
-
-    if (!config.token) {
-      console.info(`please init or set token for ${config.server}`);
-      return;
-    }
-
-    if (!config.clientId) {
-      if (!config.apiKey) {
-        console.info(`please init or create a client for ${config.server}`);
-      } else {
-        config.clientId = config.apiKey;
-      }
-      return;
-    }
-
-    options.port = port;
-    options.token = config.token;
-    options.access = config.access;
-    options.server = config.server;
-    options.clientId = config.clientId;
-    options.apiKey = options.key || config.apiKey;
-
-    if (options.suffix === "port" || options.suffix === "true") {
-      options.suffix = `${port}`;
-    } else if (options.suffix === "false") {
-      options.suffix = undefined;
-    } else if (options.suffix === "gen" || options.suffix === "uuid") {
-      options.suffix = generateUUID();
-    }
-
-    initClient(options);
-  });
-
-// config
-program
-  .command("config")
-  .description("create and update config file for connection")
-  .addArgument(
-    new Argument("<type>", "config type").choices([
-      "access",
-      "token",
-      "server",
-      "client",
-      "key",
-    ])
-  )
-  .argument("<value>", "config value")
-  .option("-p --profile <string>", "setting profile name", PROFILE_DEFAULT)
-  .action(async (type, value, options) => {
-    if (!type) {
-      console.error("type config is required!");
-      return;
-    }
-
-    const configDir = path.resolve(os.homedir(), PROFILE_PATH);
-
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir);
-      console.log(`config file ${configDir} was created`);
-    }
-
-    let config: any = {};
-    const configFilename = `${options.profile}.json`;
-    const configFilePath = path.resolve(configDir, configFilename);
-
-    if (fs.existsSync(configFilePath)) {
-      config = JSON.parse(fs.readFileSync(configFilePath, "utf8"));
-    }
-
-    if (!config.server) {
-      config.server = SERVER_DEFAULT_URL;
-    }
-
-    // Error Code status
-    let errorCode = 0;
-
-    if (type === "token" || type === "jwt") {
-      config.token = value;
-    } else if (type === "server") {
-      config.server = value;
-    } else if (type === "clientId" || type === "client") {
-      if (!value || value === "" || value === "new") {
-        config.clientId = generateUUID();
-      } else {
-        config.clientId = value;
-      }
-      console.log(`client: ${config.clientId} was set to config`);
-    } else if (type === "apiKey" || type === "key") {
-      config.apiKey = value;
-    } else if (type === "access") {
-      config.access = (value && value.toUpperCase().trim()) || TOKEN_FREE;
-
-      // FREE
-      if (config.access === TOKEN_FREE) {
-        await getTokenFree(config.server)
-          .then((resp: any) => {
-            if (resp.data?.token) {
-              config.token = resp.data?.token;
-            } else {
-              errorCode = 1;
-              console.error("Generate free token failed, return with null or empty from server!", resp);
-              return;
-            }
-          })
-          .catch((err: any) => {
-            errorCode = 1;
-            console.error("cannot get free token from server", err);
-            return;
-          });
-      }
-    }
-
-    if (!config.clientId && config.apiKey) {
-      config.clientId = config.apiKey;
-    }
-
-    if (errorCode === 0) {
-      fs.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
-      console.log(`${type} config saved successfully to: ${configFilePath}`);
-    }
-  });
-
-// config
-program
-  .command("config-get")
-  .description("get type from config file")
-  .addArgument(
-    new Argument("<type>", "config type").choices([
-      "access",
-      "token",
-      "server",
-      "client",
-      "key",
-    ])
-  )
-  .option("-p --profile <string>", "setting profile name", PROFILE_DEFAULT)
-  .action(async (type, options) => {
-    if (!type) {
-      console.error("type config is required!");
-      return;
-    }
-
-    const configDir = path.resolve(os.homedir(), PROFILE_PATH);
-    if (!fs.existsSync(configDir)) {
-      console.log(`config file ${configDir} not found`);
-      return;
-    }
-
-    let config: any = {};
-    const configFilename = `${options.profile}.json`;
-    const configFilePath = path.resolve(configDir, configFilename);
-
-    if (fs.existsSync(configFilePath)) {
-      config = JSON.parse(fs.readFileSync(configFilePath, "utf8"));
-    } else {
-      console.log(`config file ${configFilePath} not found`);
-      return;
-    }
-
-    if (type === "token" || type === "jwt") {
-      console.log(config.token);
-    } else if (type === "server") {
-      console.log(config.server);
-    } else if (type === "clientId" || type === "client") {
-      console.log(config.clientId);
-    } else if (type === "apiKey" || type === "key") {
-      console.log(config.apiKey);
-    } else if (type === "access") {
-      console.log(config.access);
-    } else {
-      console.log('no config found for type: "' + type + '"');
-    }
-  });
-
-program.parse();

src/constant.ts

@@ -0,0 +1,5 @@
+// constants
+export const PROFILE_DEFAULT = "default";
+export const PROFILE_PATH = ".hlt";
+export const SERVER_DEFAULT_URL = "https://lt.ctdn.net";
+export const TOKEN_FREE = "FREE";

src/interface.ts

@@ -0,0 +1,21 @@
+export interface Options {
+    server?: string;
+    profile?: string;
+    key?: string;
+    apiKey?: string;
+    access?: string;
+    suffix?: string;
+    clientId?: string;
+    keep_connection?: boolean;
+    token?: string;
+    origin?: string;
+    port?: number;
+    host?: string;
+
+    // [key: string]: any;
+}
+
+export interface ClientOptions {
+    port: number;
+    options?: Options;
+}

src/proxy.ts

@@ -0,0 +1,47 @@
+import express from 'express';
+import { createProxyMiddleware, Options as ProxyOpts } from 'http-proxy-middleware';
+
+interface ProxyOptions extends ProxyOpts {
+    basePath?: string;
+    proxyPort?: number | string;
+}
+
+interface SSLProxyOptions extends ProxyOptions {
+    ssl?: {
+        key: string;
+        cert: string;
+    };
+}
+
+const port = process.env.PROXY_PORT || 3000;
+const app = express();
+
+export const createProxyServer = (target: string, opts?: ProxyOptions) => {
+    if (!target) {
+        throw new Error('Proxy target is required');
+    }
+
+    app.use(
+        opts?.basePath || '',
+        createProxyMiddleware({
+            target,
+            changeOrigin: true,
+            ws: true,
+            onProxyReq: (proxyReq, req, res) => {
+                console.log(`[HTTP] Proxying ${req.method} ${req.url} to ${target}`);
+            },
+            onProxyReqWs: (proxyReq, req, socket, options, head) => {
+                console.log(`[WS] Proxying ${req.method} ${req.url} to ${target}`);
+            },
+            onError: (err, req, res) => {
+                console.error(`Proxy error: ${err.message}`);
+            },
+            ...opts
+        })
+    );
+
+    const proxyPort = opts?.proxyPort || port;
+    return app.listen(proxyPort, () => {
+        console.log(`Proxy listening on port ${proxyPort} and forwarding to ${target}`);
+    });
+};

src/proxy_tcp.ts

@@ -0,0 +1,67 @@
+import * as net from 'net'
+
+const port = process.env.PROXY_PORT || 3000;
+
+interface ProxyOptions extends net.TcpNetConnectOpts {
+    proxyPort?: number | string;
+}
+
+// Create a TCP server that acts as a proxy
+export const createProxyServer = (targetHost: string, targetPort: number, opts?: Partial<ProxyOptions>) => {
+    const server = net.createServer((clientSocket) => {
+        const targetSocket = net.createConnection({
+            host: targetHost,
+            port: targetPort,
+            ...opts,
+        });
+
+        clientSocket.pipe(targetSocket);
+        targetSocket.pipe(clientSocket);
+
+        // Listen for target socket connection
+        targetSocket.on('connect', () => {
+            console.log(`Target socket connected to ${targetHost}:${targetPort}`);
+        });
+
+        // targetSocket.on('data', (data) => {
+        //     console.log('Target socket received data length:', data.length);
+        // });
+
+        // Listen for client socket requests
+        clientSocket.on('data', (data) => {
+            console.log('Client socket request data', data.toString());
+        });
+
+        clientSocket.on('end', () => {
+            targetSocket.end();
+        });
+
+        targetSocket.on('end', () => {
+            clientSocket.end();
+        });
+
+        clientSocket.on('error', (err) => {
+            console.error('Client socket error:', err);
+        });
+
+        targetSocket.on('error', (err) => {
+            console.error('Target socket error:', err);
+        });
+
+        targetSocket.on('timeout', () => {
+            console.log('Target socket timeout');
+        });
+
+        clientSocket.on('timeout', () => {
+            console.log('Client socket timeout');
+        });
+
+    });
+
+    const proxyPort = opts?.proxyPort || port;
+    server.listen(proxyPort, () => {
+        console.log(`TCP proxy server listening on port ${proxyPort} and forwarding to ${targetHost}:${targetPort}`);
+    });
+
+    return server;
+}

src/util.ts

@@ -16,4 +16,49 @@ const generateUUID = () => {
   return crypto.randomUUID();
 };
 
+export const isValidUrl = (url: string) => {
+  try {
+    new URL(url);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+
+export const isValidIP = (ip: string) => {
+  const regex = new RegExp(
+    "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.|$)){4}$"
+  );
+  return regex.test(ip);
+};
+
+export const isValidHostname = (hostname: string) => {
+  const regex = new RegExp(
+    "^(?:(?:(?:xn--)?[a-z0-9]+(?:-[a-z0-9]+)*\\.?)+(?:(?:[a-z]{2,}\\.)?[a-z]{2,})|localhost)$",
+    "i"
+  );
+  return regex.test(hostname) || isValidIP(hostname);
+};
+
+export const isValidPort = (port: number) => {
+  return port > 0 && port < 65536;
+};
+
+export const isValidHost = (host: string) => {
+  const [hostname, port] = host.split(":");
+  return isValidHostname(hostname) && isValidPort(parseInt(port, 10));
+};
+
+export const isValidTarget = (target: string) => {
+  if (isValidUrl(target)) {
+    return true;
+  }
+
+  if (isValidHost(target)) {
+    return true;
+  }
+
+  return false;
+};
+
 export { addPrefixOnHttpSchema, generateUUID };

test/test.ts

@@ -0,0 +1,31 @@
+import { startClient } from '../src/api';
+
+async function main() {
+    const client = await startClient({
+        port: 3000,
+        options: {
+            profile: 'mytest',
+        },
+    });
+
+    setTimeout(async () => {
+        client?.stop();
+    }, 5000);
+}
+
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+
+// import { createProxyServer } from './proxy';
+// import { createProxyServer } from './proxy_tcp';
+
+// const proxy = createProxyServer('https://git.cubetiqs.com', {
+//     proxyPort: 3005,
+//     basePath: '/',
+// });
+
+// const proxy = createProxyServer('192.168.0.202', 8081, {
+//     proxyPort: 3005,
+// });

tsconfig.json

@@ -9,6 +9,8 @@
         "outDir": "dist",
         "forceConsistentCasingInFileNames": true,
         "strict": true,
-    "skipLibCheck": true
-  }
+        "skipLibCheck": true,
+        "esModuleInterop": true
+    },
+    "exclude": ["node_modules", "dist", "test", "src/**/*.spec.ts"]
 }