cubetiq/http-tunnel-client
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: cubetiq:74fded00f28287aad105c7dd45a6b9cace0ad920
Branches Tags
cubetiq:main
cubetiq:hlt-api
cubetiq:ts
..
compare: cubetiq:fe38f051ff8299dad81b34b590cd5063601c1086
Branches Tags
cubetiq:main
cubetiq:hlt-api
cubetiq:ts

No commits in common. "74fded00f28287aad105c7dd45a6b9cace0ad920" and "fe38f051ff8299dad81b34b590cd5063601c1086" have entirely different histories.
74fded00f2 ... fe38f051ff

16 changed files with 2147 additions and 913 deletions
Show Stats Expand all files Collapse all files

1
.npmignore
View File

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

6
CHANGELOG.md
View File

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

2
bin/hlt
View File

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

1609
package-lock.json generated Normal file
View File

File diff suppressed because it is too large Load Diff

20
package.json
View File

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

6
renovate.json
View File

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

353
src/api.ts
View File

@ -1,353 +0,0 @@
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;

304
src/cli.ts
View File

@ -1,304 +0,0 @@
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();

517
src/client.ts Normal file
View File

@ -0,0 +1,517 @@
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();

5
src/constant.ts
View File

@ -1,5 +0,0 @@
// 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";

21
src/interface.ts
View File

@ -1,21 +0,0 @@
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;
}

47
src/proxy.ts
View File

@ -1,47 +0,0 @@
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}`);
});
};

67
src/proxy_tcp.ts
View File

@ -1,67 +0,0 @@
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;
}

45
src/util.ts
View File

@ -16,49 +16,4 @@ const generateUUID = () => {
return crypto.randomUUID(); 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 }; export { addPrefixOnHttpSchema, generateUUID };

31
test/test.ts
View File

@ -1,31 +0,0 @@
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,
// });

24
tsconfig.json
View File

@ -1,16 +1,14 @@
{ {
"compilerOptions": { "compilerOptions": {
"lib": ["ES2015"], "lib": ["ES2015"],
"target": "es5", "target": "es5",
"module": "commonjs", "module": "commonjs",
"moduleResolution": "node", "moduleResolution": "node",
"sourceMap": false, "sourceMap": false,
"outDir": "dist", "outDir": "dist",
"forceConsistentCasingInFileNames": true, "forceConsistentCasingInFileNames": true,
"strict": true, "strict": true,
"skipLibCheck": true, "skipLibCheck": true
"esModuleInterop": true }
},
"exclude": ["node_modules", "dist", "test", "src/**/*.spec.ts"]
} }