tunli 0.0.19

package/src/net/http/TunnelRequest.js

@@ -0,0 +1,177 @@
+import {Readable} from "stream";
+import {TunnelResponse} from "#src/net/http/TunnelResponse";
+import https from "node:https";
+import http from "node:http";
+
+class TunnelRequest extends Readable {
+
+  #socket
+
+  /**
+   * uuid v4 request/response id
+   * @type {string}
+   */
+  #requestId
+
+  constructor({socket, requestId}) {
+
+    super();
+    this.#socket = socket;
+    this.#requestId = requestId;
+
+    this.#bindEvents()
+  }
+
+  #bindEvents() {
+    const events = {
+      'request-pipe': this.#onRequestPipe.bind(this),
+      'request-pipes': this.#onRequestPipes.bind(this),
+      'request-pipe-error': this.#onRequestPipeError.bind(this),
+      'request-pipe-end': this.#onRequestPipeEnd.bind(this),
+    }
+
+    for (const [event, handler] of Object.entries(events)) {
+      this.#socket.on(event, handler);
+    }
+
+    this.once('close', () => {
+      for (const [event, handler] of Object.entries(events)) {
+        this.#socket.off(event, handler);
+      }
+    })
+  }
+
+  #onRequestPipe(requestId, data) {
+    if (this.#requestId === requestId) {
+      this.push(data);
+    }
+  }
+
+  #onRequestPipes(requestId, data) {
+    if (this.#requestId === requestId) {
+      data.forEach((chunk) => {
+        this.push(chunk);
+      });
+    }
+  }
+
+  #onRequestPipeError(requestId, error) {
+    if (this.#requestId === requestId) {
+      this.destroy(new Error(error));
+    }
+  }
+
+  #onRequestPipeEnd(requestId, data) {
+    if (this.#requestId === requestId) {
+      if (data) {
+        this.push(data);
+      }
+      this.push(null);
+    }
+  }
+
+  _read() {
+    // No op
+  }
+}
+
+const setupErrorHandlers = (source, target) => {
+  const onTunnelRequestError = (e) => {
+    source.off('end', onTunnelRequestEnd);
+    target.destroy(e);
+  };
+  const onTunnelRequestEnd = () => {
+    target.off('error', onTunnelRequestError);
+  };
+
+  source.once('error', onTunnelRequestError);
+  source.once('end', onTunnelRequestEnd);
+};
+
+
+/**
+ * @param {SocketIoRawRequestObject} req
+ * @param {EventEmitter} eventEmitter
+ * @param {tunnelClientOptions} options
+ */
+export const forwardTunnelRequestToProxyTarget = (req, eventEmitter, options) => {
+
+  const tunnelRequest = new TunnelRequest({
+    requestId: req.requestId,
+    socket: req.tunnelSocket,
+  });
+
+  const isWebSocket = req.headers.upgrade === 'websocket'
+  const localReq = options.protocol === 'https' ? https.request(req) : http.request(req)
+
+  tunnelRequest.pipe(localReq)
+
+  setupErrorHandlers(tunnelRequest, localReq)
+
+  const onLocalResponse = (localRes) => {
+    localReq.off('error', onLocalError)
+    if (isWebSocket && localRes.upgrade) {
+      return
+    }
+
+    const tunnelResponse = new TunnelResponse({
+      responseId: req.requestId,
+      socket: req.tunnelSocket,
+    })
+
+    tunnelResponse.writeHead(
+      localRes.statusCode,
+      localRes.statusMessage,
+      localRes.headers,
+      localRes.httpVersion
+    )
+    localRes.pipe(tunnelResponse)
+    if (!isWebSocket) {
+      eventEmitter.emit('response', localRes, req)
+    }
+  }
+  const onLocalError = (error) => {
+
+    let statusCode = 500
+    let statusMessage = 'UNKNOWN ERROR'
+    if (error.code === 'ECONNREFUSED') {
+      statusCode = 502
+      statusMessage = 'Bad gateway'
+    } else if (error.code === 'ECONNRESET') {
+      statusCode = 500
+      statusMessage = 'Connection reset'
+    } else {
+      console.error('IMPLEMENT ME')
+      console.error(error)
+      console.error(error.code)
+    }
+
+    eventEmitter.emit('response', {statusCode, statusMessage}, req)
+    localReq.off('response', onLocalResponse)
+    req.tunnelSocket.emit('request-error', req.requestId, error && error.message)
+    tunnelRequest.destroy(error)
+  }
+  const onUpgrade = (localRes, localSocket, localHead) => {
+    if (localHead && localHead.length) {
+      localSocket.unshift(localHead)
+    }
+
+    const tunnelResponse = new TunnelResponse({
+      responseId: req.requestId,
+      socket: req.tunnelSocket,
+      duplex: 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)
+  }
+}

package/src/net/http/TunnelResponse.js

@@ -0,0 +1,119 @@
+import {Duplex} from "stream";
+
+export class TunnelResponse extends Duplex {
+
+  /**
+   *
+   */
+  #socket
+
+  /**
+   * uuid v4 request/response id
+   * @type {string}
+   */
+  #responseId
+
+  constructor({socket, responseId, duplex}) {
+
+    super();
+    this.#socket = socket;
+    this.#responseId = responseId;
+
+    if (duplex) {
+      this.#bindEvents()
+    }
+  }
+
+  #onResponsePipe(responseId, data) {
+    if (this.#responseId === responseId) {
+      this.push(data);
+    }
+  }
+
+  #onResponsePipes(responseId, data) {
+    if (this.#responseId === responseId) {
+      data.forEach((chunk) => {
+        this.push(chunk);
+      });
+    }
+  }
+
+  #onResponsePipeError(responseId, error) {
+    if (this.#responseId === responseId) {
+      this.destroy(new Error(error));
+    }
+  }
+
+  #onResponsePipeEnd(responseId, data) {
+    if (this.#responseId === responseId) {
+      if (data) {
+        this.push(data);
+      }
+      this.push(null);
+    }
+  }
+
+  #bindEvents() {
+
+    const events = {
+      'response-pipe': this.#onResponsePipe.bind(this),
+      'response-pipes': this.#onResponsePipes.bind(this),
+      'response-pipe-error': this.#onResponsePipeError.bind(this),
+      'response-pipe-end': this.#onResponsePipeEnd.bind(this)
+    };
+
+    for (const [event, handler] of Object.entries(events)) {
+      this.#socket.on(event, handler);
+    }
+
+    this.once('close', () => {
+      console.log('CLOSING CALL')
+      for (const [event, handler] of Object.entries(events)) {
+        this.#socket.off(event, handler);
+      }
+    })
+  }
+
+  _write(chunk, encoding, callback) {
+    this.#socket.emit('response-pipe', this.#responseId, chunk);
+    this.#socket.io.engine.once('drain', callback)
+  }
+
+  _writev(chunks, callback) {
+    this.#socket.emit('response-pipes', this.#responseId, chunks);
+    this.#socket.io.engine.once('drain', callback)
+  }
+
+  _final(callback) {
+    this.#socket.emit('response-pipe-end', this.#responseId);
+    this.#socket.io.engine.once('drain', callback)
+  }
+
+  _destroy(e, callback) {
+    if (e) {
+      this.#socket.emit('response-pipe-error', this.#responseId, e && e.message);
+      this.#socket.io.engine.once('drain', callback)
+      return;
+    }
+    callback();
+  }
+
+  /**
+   * @param {number} statusCode
+   * @param {string} statusMessage
+   * @param {Object} headers
+   * @param {string} httpVersion
+   */
+  writeHead(statusCode, statusMessage, headers, httpVersion) {
+
+    this.#socket.emit('response', this.#responseId, {
+      statusCode,
+      statusMessage,
+      headers,
+      httpVersion,
+    });
+  }
+
+  _read(size) {
+  }
+}

package/src/tunnel-client/TunnelClient.js

@@ -0,0 +1,136 @@
+import {securedHttpClient} from "#lib/HttpClient";
+import {forwardTunnelRequestToProxyTarget} from "#src/net/http/TunnelRequest";
+import {io} from "socket.io-client";
+import EventEmitter from "node:events";
+import {ref} from "#src/core/Ref";
+import {isValidRemoteAddress} from "#commands/helper/BindArgs";
+import {createRequestFromRaw} from "#src/utils/httpFunction";
+
+export class TunnelClient extends EventEmitter {
+
+  /**
+   * @type {tunnelClientOptions}
+   */
+  #options
+  #socket
+  #latency = ref(0)
+
+  /**
+   * @param {tunnelClientOptions} options
+   */
+  constructor(options) {
+    super()
+    this.#options = options
+  }
+
+  get latency() {
+    return this.#latency
+  }
+
+  #bindEvents() {
+
+    const socket = this.#socket
+    const options = this.#options
+
+    socket.on('connect', () => {
+      if (socket.connected) {
+        this.emit('tunnel-connection-established')
+      }
+    })
+
+    socket.on('connect_error', (e) => {
+      this.emit('tunnel-connection-error', e)
+    })
+
+    socket.on('disconnect', () => {
+      this.emit('tunnel-connection-closed')
+    })
+
+    socket.on('request', ( /** string */ requestId, /** SocketIoRawRequestObject */ request) => {
+
+      const req = createRequestFromRaw(request, requestId, socket)
+      request.requestId = requestId
+      request.tunnelSocket = socket
+
+      if (!isValidRemoteAddress(req.remoteAddress, options)) {
+        this.emit('blocked', req.remoteAddress)
+        req.res.status(401).send(`Access denied for ip ${req.remoteAddress}`)
+        return;
+      }
+
+      const isWebSocket = request.headers.upgrade === 'websocket';
+
+      request.port = options.port;
+      request.hostname = options.host; // TODO hostanme : www.foo.bar.de vs host: www.foo.bar:80
+      request.rejectUnauthorized = false
+
+      if (options.origin) {
+        request.headers.host = options.origin;
+      } else {
+        request.headers.host = request.hostname
+      }
+
+      if (!isWebSocket) {
+        this.emit('request', request)
+      }
+
+      forwardTunnelRequestToProxyTarget(request, this, this.#options)
+    })
+  }
+
+  async #keepAlive() {
+    const ping = () => {
+      const start = Date.now();
+      this.#socket.volatile.emit('ping', () => {
+        this.#latency.value = Date.now() - start;
+      });
+    }
+
+    while (this.#latency.value === 0) {
+      ping()
+      await new Promise((resolve) => setTimeout((resolve), 100))
+    }
+
+    setInterval(ping, 5000)
+  }
+
+  async init(dashboard) {
+
+    const params = await this.#createParameters(dashboard)
+    this.#socket = io(this.#options.server, params)
+    this.#bindEvents()
+    this.#keepAlive();
+    return this
+  }
+
+  async #createParameters(dashboard) {
+    const options = this.#options
+    const webSocketCapturePath = await securedHttpClient(options.authToken).get('/capture_path')
+
+    if (webSocketCapturePath.error) {
+      dashboard.destroy()
+      if (webSocketCapturePath.error?.message === 'Request failed with status code 401') {
+        console.error('missing authorization, check your registration and try again')
+      } else {
+        console.error('could not connect to remote server. pls try again later')
+      }
+
+      process.exit(1)
+    }
+
+    const initParams = {
+      path: webSocketCapturePath.data,
+      transports: ['websocket'],
+      auth: {
+        token: options.authToken,
+      },
+      extraHeaders: {},
+    };
+
+    if (options.path) {
+      initParams.extraHeaders['path-prefix'] = options.path;
+    }
+
+    return initParams
+  }
+}

package/src/utils/arrayFunctions.js

@@ -0,0 +1,45 @@
+/**
+ * Removes duplicate elements from an array.
+ * @param {any[]} value - The array from which to remove duplicates.
+ * @returns {any[]|null} - A new array with unique elements, or null if the input is not an array.
+ */
+export const arrayUnique = (value) => {
+  if (!Array.isArray(value)) {
+    return null
+  }
+  return Array.from(new Set(value))
+}
+
+/**
+ * @template A
+ * @template B
+ * Merges two arrays into one.
+ * @param {A[]} arr1 - The first array.
+ * @param {B[]} arr2 - The second array.
+ * @returns {[A, B]} - A new array containing elements from both input arrays.
+ */
+export const arrayMerge = (arr1, arr2) => {
+  arr1 ??= []
+  arr2 ??= []
+  return [...arr1, ...arr2]
+}
+
+/**
+ * Subtracts elements of the second array from the first array.
+ * @param {any[]} arr1 - The array from which to subtract elements.
+ * @param {any[]} arr2 - The array containing elements to subtract.
+ * @returns {any[]} - A new array containing elements from arr1 that are not in arr2.
+ */
+export const arraySub = (arr1, arr2) => {
+  arr1 ??= []
+  arr2 ??= []
+  return arr1.filter(x => !arr2.includes(x))
+}
+
+export const arrayRemoveEntry = (array, search) => {
+  const delPos = array.indexOf(search)
+  if (delPos > -1) {
+    array = [...array.slice(0, delPos), ...array.slice(delPos + 1)]
+  }
+  return array
+}

package/src/utils/checkFunctions.js

@@ -0,0 +1,161 @@
+import {InvalidArgumentError} from "commander"
+import {ipV4} from "#src/net/IPV4";
+import {isSharedArg} from "#commands/helper/SharedArg";
+
+/**
+ * Validate and format an IPv4 address with CIDR notation.
+ * This function checks if the provided value is a valid IPv4 address with or without CIDR suffix.
+ * If valid, it returns the address formatted with its CIDR suffix.
+ * If invalid, it throws an InvalidArgumentError with an appropriate message.
+ *
+ * @param {string} value - The IPv4 address (with or without CIDR) to validate.
+ * @returns {string} - The validated and formatted IPv4 address with CIDR suffix.
+ * @throws {InvalidArgumentError} - If the IPv4 address is not valid.
+ */
+export const checkIpV4Cidr = (value) => {
+  const val = ipV4(value)
+  if (!val.isValid) {
+    throw new InvalidArgumentError('The provided value must be a valid IPv4 address, with or without CIDR notation.')
+  }
+  return `${val}/${val.cidrSuffix}`
+}
+/**
+ * Checks if the value is an integer.
+ * @param {any} value - The value to check.
+ * @param {string} [errorMessage='Value must be an integer'] - The error message to throw if validation fails.
+ * @returns {number} - The validated integer.
+ * @throws {InvalidArgumentError} - If the value is not a valid integer.
+ */
+export const checkInt = (value, errorMessage = 'Value must be an integer') => {
+  value = value.toString()
+
+  if (!/^\d+$/.test(value)) {
+    throw new InvalidArgumentError(errorMessage);
+  }
+
+  return parseInt(value)
+}
+/**
+ * Checks if the value is a valid URL.
+ * @param {string} value - The value to check.
+ * @returns {string} - The validated URL.
+ * @throws {InvalidArgumentError} - If the value is not a valid URL.
+ */
+export const checkUrl = (value) => {
+  try {
+    return new URL(value).toString()
+  } catch (e) {
+    throw new InvalidArgumentError('Invalid URL')
+  }
+}
+/**
+ * Checks if the value is a valid host.
+ * @param {Ref|*} valueOrSharedArg - The value or shared argument to check.
+ * @param {boolean} [isArgument=false] - Whether the value is an argument.
+ * @param {*} [value] - The value to check.
+ * @returns {string} - The validated host.
+ * @throws {InvalidArgumentError} - If the value is not a valid host.
+ */
+export const checkHost = (valueOrSharedArg, isArgument = false, value) => {
+  if (isSharedArg(valueOrSharedArg)) {
+    const {url, host} = valueOrSharedArg.value
+    if (url) {
+      throw new InvalidArgumentError('You must not set a host if the port argument is a URL')
+    } else if (host) {
+      throw new InvalidArgumentError('You must not set a host argument if the host option has been set')
+    }
+  } else {
+    value = valueOrSharedArg
+    valueOrSharedArg = undefined
+  }
+
+  const check = new URL('http://localhost')
+  check.hostname = value
+
+  if (check.hostname !== value.toLowerCase()) {
+    throw new InvalidArgumentError('Invalid host');
+  }
+  if (isSharedArg(valueOrSharedArg) && !isArgument) {
+    valueOrSharedArg.value.host = check.host
+  }
+
+  return check.host
+}
+/**
+ * Checks if the value is a valid port.
+ * @param {Ref|*} valueOrSharedArg - The value or shared argument to check.
+ * @param {boolean} [isArgument=false] - Whether the value is an argument.
+ * @param {*} [value] - The value to check.
+ * @returns {number|Ref} - The validated port or shared argument with port.
+ * @throws {InvalidArgumentError} - If the value is not a valid port.
+ */
+export const checkPort = (valueOrSharedArg, isArgument = false, value) => {
+  const handleUrlArg = (value) => {
+    try {
+      const url = new URL(value)
+
+      let port = url.port
+      const protocol = url.protocol.substring(0, url.protocol.length - 1)
+
+      if (!port) {
+        if (protocol === 'http') {
+          port = 80
+        } else if (protocol === 'https') {
+          port = 443
+        }
+        url.port = port.toString()
+      }
+
+      valueOrSharedArg.value.url = {
+        protocol,
+        host: url.hostname,
+        port: parseInt(port)
+      }
+
+      return port
+    } catch (e) {
+      return null
+    }
+  }
+
+  let portFromUrl
+
+  if (isSharedArg(valueOrSharedArg)) {
+    const {url, port, host} = valueOrSharedArg.value
+    portFromUrl = isArgument ? handleUrlArg(value) : null
+
+    if (host && portFromUrl) {
+      throw new InvalidArgumentError('You must not set a URL as port argument if the host option is already set')
+    } else if (port) {
+      if (portFromUrl) {
+        throw new InvalidArgumentError('You must not set a port option if the port argument is a URL')
+      }
+      throw new InvalidArgumentError('You must not set a port option if the port argument is set')
+    } else if (url) {
+      if (port) {
+        throw new InvalidArgumentError('You must not set a port option if the port argument is a URL')
+      }
+      throw new InvalidArgumentError('Unexpected: You must not set a port argument')
+    }
+
+    value = portFromUrl ?? value
+  } else {
+    value = valueOrSharedArg
+    valueOrSharedArg = undefined
+  }
+
+  value = checkInt(value, 'Port must be a valid integer')
+
+  if (value > 65535) {
+    throw new InvalidArgumentError('Port exceeds maximum value of 65535');
+  }
+
+  if (isSharedArg(valueOrSharedArg)) {
+    if (!portFromUrl) {
+      valueOrSharedArg.value.port = value
+    }
+    return valueOrSharedArg
+  }
+
+  return value
+}

package/src/utils/cliFunctions.js

@@ -0,0 +1,62 @@
+import {stdout} from 'node:process';
+import EventEmitter from "node:events";
+import {spawn} from "child_process";
+
+export const setCursorVisibility = (visible) => {
+  if (visible) {
+    stdout.write('\x1B[?25h');
+  } else {
+    stdout.write('\x1B[?25l');
+  }
+}
+
+export const clearTerminal = () => {
+  stdout.write('\x1B[2J\x1B[0f');
+}
+
+
+/**
+ * Runs a child process and proxies its output.
+ * @param {string} pathToExecutable - Relative or absolute path to the executable script
+ * @returns {Promise<number|null>} - Exit code of the child process
+ */
+export const proxyChildProcess = (pathToExecutable) => {
+
+  const eventEmitter = new EventEmitter()
+  const createSpawnProcessPromise = () => {
+    const onError = (error) => {
+      eventEmitter.emit('close', 1)
+    }
+
+    const onClose = (code) => {
+      if (code === null) {
+        clearTerminal()
+      }
+      eventEmitter.emit('close', code)
+    }
+
+    const onMessage = (message) => {
+      if (message === 'restart') {
+        child.off('close', onClose)
+        child.kill()
+        setTimeout(() => {
+          eventEmitter.emit('spawn')
+        }, 10)
+      }
+    }
+
+    const child = spawn('node', [pathToExecutable], {
+      stdio: ['inherit', 'inherit', 'inherit', 'ipc'] // Proxy standard output and error to the main process, enable IPC channel
+    })
+      .on('close', onClose)
+      .on('error', onError)
+      .on('message', onMessage)
+  }
+
+  eventEmitter.on('spawn', () => createSpawnProcessPromise(pathToExecutable))
+
+  return new Promise((resolve) => {
+    eventEmitter.once('close', resolve)
+    eventEmitter.emit('spawn')
+  })
+}

package/src/utils/createRequest.js

@@ -0,0 +1,12 @@
+import {Socket} from "socket.io-client";
+import {IncomingRequest} from "#lib/Tunnel/IncomingRequest";
+
+/**
+ * @param {IncomingSocketIoRequest} incomingSocketIoRequest
+ * @param {RequestId} requestId
+ * @param {Socket} socket
+ * @returns {IncomingRequest}
+ */
+export const createRequestFromSocketIoRequest = (incomingSocketIoRequest, requestId, socket) => {
+  return new IncomingRequest(incomingSocketIoRequest, requestId, socket)
+}