tunli 0.0.27 → 0.2.0

package/src/net/http/IncomingMessage.js

@@ -1,92 +0,0 @@
-import {ServerResponse} from "#src/net/http/ServerResponse"
-import {Socket} from "socket.io-client"
-import {getRemoteAddress} from "#src/utils/httpFunction"
-
-/**
- * IncomingMessage class represents an HTTP request received by the server.
- */
-export class IncomingMessage {
-  /**
-   * @type {ServerResponse}
-   * @private
-   */
-  #res
-
-  /**
-   * @type {string}
-   * @private
-   */
-  #id
-
-  /**
-   * @type {Socket}
-   * @private
-   */
-  #socket
-
-  /**
-   * @type {string}
-   * @private
-   */
-  #remoteAddress
-
-  /**
-   * @type {string}
-   * @private
-   */
-  #url
-
-  /**
-   * Creates an instance of IncomingMessage.
-   * @param {SocketIoRawRequestObject} request - The raw request object.
-   * @param {string} requestId - The unique request identifier.
-   * @param {Socket} socket - The socket to communicate over.
-   */
-  constructor(request, requestId, socket) {
-    this.#url = request.path
-    this.#id = requestId
-    this.#socket = socket
-    this.#remoteAddress = getRemoteAddress(request)
-  }
-
-  /**
-   * Returns the URL path.
-   * @return {string}
-   */
-  get url() {
-    return this.#url
-  }
-
-  /**
-   * Returns the remote address.
-   * @return {string}
-   */
-  get remoteAddress() {
-    return this.#remoteAddress
-  }
-
-  /**
-   * Returns the unique request identifier.
-   * @return {string}
-   */
-  get id() {
-    return this.#id
-  }
-
-  /**
-   * Returns the socket associated with the request.
-   * @return {Socket}
-   */
-  get socket() {
-    return this.#socket
-  }
-
-  /**
-   * Returns the ServerResponse instance, creating it if necessary.
-   * @return {ServerResponse}
-   */
-  get res() {
-    this.#res ??= new ServerResponse(this)
-    return this.#res
-  }
-}

package/src/net/http/ServerResponse.js

@@ -1,126 +0,0 @@
-import {IncomingMessage} from "#src/net/http/IncomingMessage"
-import {TunnelResponse} from "#src/net/http/TunnelResponse"
-
-/**
- * ServerResponse class represents an HTTP response to be sent back to the client.
- */
-export class ServerResponse {
-
-  /**
-   * @type {IncomingMessage}
-   * @private
-   */
-  #req
-
-  /**
-   * @type {Object}
-   * @private
-   */
-  #headers = {}
-
-  /**
-   * @type {string}
-   * @private
-   */
-  #httpVersion = '1.1'
-
-  /**
-   * @type {TunnelResponse}
-   * @private
-   */
-  #res
-
-  /**
-   * @type {string}
-   * @private
-   */
-  #statusMessage = 'OK'
-
-  /**
-   * @type {number}
-   * @private
-   */
-  #statusCode = 200
-
-  /**
-   * Creates an instance of ServerResponse.
-   * @param {IncomingMessage} incomingMessage - The incoming message object.
-   */
-  constructor(incomingMessage) {
-    this.#req = incomingMessage
-    this.#res = new TunnelResponse({
-      responseId: incomingMessage.id,
-      socket: incomingMessage.socket,
-    })
-  }
-
-  /**
-   * Returns the associated IncomingMessage instance.
-   * @return {IncomingMessage}
-   */
-  get req() {
-    return this.#req
-  }
-
-  /**
-   * Sets the status code and message.
-   * @param {number} statusCode - The HTTP status code.
-   * @param {string} [statusMessage] - The HTTP status message.
-   * @return {ServerResponse}
-   */
-  status(statusCode, statusMessage) {
-    this.#statusMessage = statusMessage ?? {
-      200: 'OK',
-      201: 'Created',
-      202: 'Accepted',
-      204: 'No Content',
-      301: 'Moved Permanently',
-      302: 'Found',
-      304: 'Not Modified',
-      400: 'Bad Request',
-      401: 'Unauthorized',
-      403: 'Forbidden',
-      404: 'Not Found',
-      405: 'Method Not Allowed',
-      500: 'Internal Server Error',
-      501: 'Not Implemented',
-      502: 'Bad Gateway',
-      503: 'Service Unavailable',
-      504: 'Gateway Timeout'
-    }[statusCode] ?? 'Unknown Status'
-    this.#statusCode = statusCode
-    return this
-  }
-
-  /**
-   * Sends the response with the provided body.
-   * @param {string|Buffer} body - The body of the response.
-   * @return {ServerResponse}
-   */
-  send(body) {
-    this.#res.writeHead(this.#statusCode, this.#statusMessage, this.#headers, this.#httpVersion)
-    this.#res.write(body)
-    this.#res.end()
-    return this
-  }
-
-  /**
-   * Sets the headers for the response.
-   * @param {Object} headers - The headers to set.
-   * @return {ServerResponse}
-   */
-  headers(headers) {
-    this.#headers = headers
-    return this
-  }
-
-  /**
-   * Sets the HTTP version for the response.
-   * @param {string} httpVersion - The HTTP version to set.
-   * @return {ServerResponse}
-   */
-  httpVersion(httpVersion) {
-    this.#httpVersion = httpVersion
-    return this
-  }
-}

package/src/net/http/TunliRequest.js

@@ -1 +0,0 @@
-export class TunliRequest {}

package/src/net/http/TunliResponse.js

@@ -1 +0,0 @@
-export class TunliResponse {}

package/src/net/http/TunnelRequest.js

@@ -1,229 +0,0 @@
-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
-    }
-
-    if (!isWebSocket) rewriteResponse(localRes, options)
-
-    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)
-  }
-}
-
-
-/**
- * @param {Response<IncomingMessage>} localRes
- * @param {tunnelClientOptions} options
- */
-const rewriteResponse = (localRes, options) => {
-
-  options.proxyURL ??= options.server
-
-  const hostSearch = options.origin ?? options.host
-  const {protocol: protocolReplace, hostname: hostReplace} = new URL(options.proxyURL)
-  const baseURL = new URL(`${options.protocol}://${hostSearch}:${options.port}`).toString()
-
-  if (localRes.statusCode === 301) {
-    delete localRes.headers.location
-  }
-
-  let location = localRes.headers.location
-  let setCookie = localRes.headers['set-cookie']
-
-  if (!setCookie || !Array.isArray(setCookie)) {
-    setCookie = null
-  }
-
-  if (location) {
-    location = new URL(location, baseURL).toString()
-  }
-
-  if (location && location.charAt(0) !== '/' && location.startsWith(baseURL)) {
-    localRes.headers.location = location.replace(baseURL, options.proxyURL)
-  }
-
-  if (setCookie) {
-    localRes.headers['set-cookie'] = setCookie.map(cookie => {
-      return updateCookieDomain(cookie, hostReplace) // TODO MOVE THIS PART TO SERVER
-    })
-  }
-}
-
-function extractDomainFromCookieString(cookie) {
-  const domainMatch = cookie.match(/Domain=([^;]+)/);
-  return domainMatch ? domainMatch[1] : null;
-}
-
-function updateCookieDomain(cookie, newDomain) {
-  return cookie.replace(/Domain=[^;]+/, `Domain=${newDomain}`);
-}

package/src/net/http/TunnelResponse.js

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

@@ -1,144 +0,0 @@
-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)
-  }
-
-  /**
-   * @param {Dashboard} [dashboard]
-   * @return {Promise<TunnelClient>}
-   */
-  async init(dashboard) {
-
-    const params = await this.#createParameters(dashboard)
-    this.#socket = io(this.#options.server, params)
-    this.#bindEvents()
-    this.#keepAlive();
-    return this
-  }
-
-  /**
-   * @param {Dashboard} dashboard
-   * @return {Promise<{path: any, transports: string[], auth: {token: string}, extraHeaders: {}}>}
-   */
-  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
-  }
-}