tunli 0.0.19

package/src/core/Ref.js

@@ -0,0 +1,70 @@
+import EventEmitter from 'node:events'
+
+/**
+ * A class representing a reference to a value.
+ * This class is useful for creating mutable references to values,
+ * allowing for controlled access and modification.
+ */
+export class Ref extends EventEmitter {
+
+  /**
+   * @type {any}
+   * Private field to store the value.
+   */
+  #value
+
+  /**
+   * Constructor for the Ref class.
+   * If the provided value is an instance of Ref, it uses its value.
+   * Otherwise, it stores the provided value.
+   * @param {any} value - The value to store.
+   */
+  constructor(value) {
+    super()
+    if (value instanceof Ref) {
+      this.#value = value.#value
+    } else {
+      this.#value = { value }
+    }
+  }
+
+  /**
+   * Getter for the stored value.
+   * @returns {any} - The stored value.
+   */
+  get value() {
+    return this.#value.value
+  }
+
+  /**
+   * Setter for the stored value.
+   * @param {any} value - The new value.
+   */
+  set value(value) {
+    const oldValue = this.#value.value
+    this.#value.value = value
+    // Emit an event if the value has changed
+    if (oldValue !== value) {
+      this.emit('update', value, oldValue)
+    }
+  }
+}
+
+/**
+ * @template T
+ * Creates a new Ref instance.
+ * @param {T} [value] - The value to store.
+ * @returns {Ref} - A new Ref instance.
+ */
+export const ref = (value) => {
+  return new Ref(value)
+}
+
+/**
+ * Checks if the value is an instance of Ref.
+ * @param {any} value - The value to check.
+ * @returns {boolean} - True if the value is an instance of Ref, otherwise false.
+ */
+export const isRef = (value) => {
+  return value instanceof Ref
+}

package/src/lib/Flow/getCurrentIp.js

@@ -0,0 +1,18 @@
+import {httpClient} from "#lib/HttpClient";
+import {checkIpV4Cidr} from "#src/utils/checkFunctions";
+
+export const getCurrentIp = async () => {
+  const {data, error} = await httpClient.get(`/ip`);
+
+  if (error) {
+    console.error(error)
+    process.exit(1)
+  }
+
+  try {
+    return checkIpV4Cidr(data)
+  } catch {
+    console.log(`invalid ip v4 address "${data}"`)
+    process.exit(1)
+  }
+}

package/src/lib/Flow/getLatestVersion.js

@@ -0,0 +1,13 @@
+import {npmApiClient} from "#lib/HttpClient";
+
+export const getLatestVersion = async () => {
+
+  await new Promise(resolve => setTimeout(resolve, 2000))
+  const {data, error} = await npmApiClient.get('/-/package/tunli/dist-tags')
+
+  if (error) {
+    return false
+  }
+
+  return data.latest
+}

package/src/lib/Flow/proxyUrl.js

@@ -0,0 +1,32 @@
+import {securedHttpClient} from "#lib/HttpClient";
+import {SERVER_HOST} from "#lib/defs";
+
+export const requestNewProxyUrl = async (token) => {
+
+  const {data, error} = await securedHttpClient(token).get('/create');
+
+  if (error) {
+    console.error('Auth failed as server response error, status: ', error);
+    process.exit(1)
+  }
+
+  return `https://${data}.${SERVER_HOST}`
+}
+
+export const renewProxyUrlRegistration = async (proxyUrl, token) => {
+
+  const subDomain = new URL(proxyUrl).hostname.split('.', 1)[0]
+
+  const {data, error} = await securedHttpClient(token).get(`/renew/${subDomain}`);
+
+  if (data === false) {
+    return false
+  }
+
+  if (!data) {
+    console.error('Renew failed, request a new URL', error);
+    process.exit(1)
+  }
+
+  return proxyUrl
+}

package/src/lib/Flow/validateAuthToken.js

@@ -0,0 +1,19 @@
+import {Command} from "commander";
+import {Ref} from "#src/core/Ref";
+
+
+/**
+ * @param {Ref} configRef
+ * @param {Command} cmd
+ */
+export const validateAuthToken = (cmd, configRef) => {
+  cmd.hook('preAction', (thisCommand, actionCommand) => {
+
+    /** @type {LocalConfig|GlobalConfig} */
+    const config = configRef.value
+
+    if (!config.authToken) {
+      actionCommand.error("error: Missing authToken. Please run register firstly");
+    }
+  })
+}

package/src/lib/HttpClient.js

@@ -0,0 +1,61 @@
+import axios from "axios";
+import {AUTH_SERVER_URL} from "#lib/defs";
+
+const createClient = (options = {}) => {
+
+  const defaultOptions = {
+    baseURL: AUTH_SERVER_URL,
+    headers: {
+      'user-agent': 'tunli/1.0'
+    }
+  }
+
+  const headers = {...defaultOptions.headers, ...options.headers ?? {}};
+  options = {...defaultOptions, ...options, headers};
+
+  const httpClient = axios.create(options)
+  httpClient.interceptors.response.use((response) => {
+      return {
+        data: response.data
+      }
+    },
+    (error) => {
+      if (error.code === 'ECONNREFUSED') {
+        console.error('Connection refused to', error.config.url);
+      }
+      const message = error.response?.data ? error.response?.data : null
+      return Promise.resolve({
+        error: message ?? {
+          code: error.code,
+          message: error.message
+        }
+      });
+    });
+
+  return httpClient
+}
+
+
+/**
+ * @type {AxiosInstance}
+ */
+export const httpClient = createClient();
+
+/**
+ * @type {AxiosInstance}
+ */
+export const npmApiClient = createClient({
+  baseURL: 'https://registry.npmjs.org/'
+});
+
+/**
+ * @param {string} token - Der Authentifizierungs-Token.
+ * @returns {AxiosInstance} - Eine konfigurierte Axios-Instanz mit Authentifizierung.
+ */
+export const securedHttpClient = (token) => {
+  return createClient({
+    headers: {
+      authorization: `Bearer ${token}`,
+    },
+  })
+}

package/src/lib/defs.js

@@ -0,0 +1,10 @@
+import {resolve} from "path";
+import {homedir} from "os";
+
+export const SERVER_HOST = 'tunli.app'
+export const CONFIG_DIR_NAME = '.tunli'
+
+export const AUTH_SERVER_URL = 'https://api.tunli.app'
+
+export const GLOBAL_CONFIG_DIR = resolve(homedir(), CONFIG_DIR_NAME);
+export const CONFIG_FILENAME = 'default.json'

package/src/net/IPV4.js

@@ -0,0 +1,139 @@
+export const ipV4 = (address) => {
+
+  if (address instanceof IPV4) {
+    return address
+  }
+  return new IPV4(address)
+}
+
+export class IPV4 {
+
+  #ipv4Address
+
+  /**
+   * @type {IPV4}
+   */
+  #subnet
+
+  /**
+   * @type {boolean}
+   */
+  #isValid
+
+  constructor(ipv4Address) {
+
+    this._ipv4Address = this.#ipv4Address = this.#prepare(ipv4Address)
+    this.#isValid = this.#ipv4Address !== null
+  }
+
+  /**
+   * @returns {boolean}
+   */
+  get isValid() {
+    return this.#isValid
+  }
+
+  /**
+   * @return {number|null}
+   */
+  get cidrSuffix() {
+    return this.#ipv4Address?.cidrSuffix ?? null
+  }
+
+  get subnetAddress() {
+    this.#subnet ??= this.#calculateSubnet()
+    return this.#subnet
+  }
+
+  #calculateSubnet() {
+
+    const mask = ipV4(~((1 << (32 - this.cidrSuffix)) - 1) >>> 0)
+    const octets = []
+
+    for (let i = 0; i < 4; i++) {
+      const maskPart = mask.#ipv4Address.octetsAsIntegers[i]
+      const ipPart = this.#ipv4Address.octetsAsIntegers[i]
+      octets.push(maskPart & ipPart)
+    }
+
+    return ipV4(octets.join('.'))
+  }
+
+  #prepare(ipv4Address) {
+
+    const typeOfAddress = typeof ipv4Address
+    let octets = []
+    let octetsAsIntegers = []
+    let octetsAsBinaryString = []
+    let ipv4AddressAsInt;
+    let ipv4AddressAsString;
+    let cidrSuffix = 32;
+
+    if (typeOfAddress === 'number') {
+      ipv4AddressAsInt = ipv4Address
+      const binaryRepresentation = ipv4Address.toString(2)
+      const chunkSize = 8
+      for (let i = binaryRepresentation.length; i > 0; i -= chunkSize) {
+        const octetAsBin = binaryRepresentation.substring(i - chunkSize, i).padStart(8, '0')
+        const octetAsInt = parseInt(octetAsBin, 2)
+
+        octetsAsBinaryString.unshift(octetAsBin);
+        octetsAsIntegers.unshift(octetAsInt);
+        octets.unshift(octetAsInt.toString());
+      }
+
+      ipv4AddressAsString = octets.join('.')
+    } else if (typeOfAddress === 'string') {
+
+      const parts = ipv4Address.split('/')
+      if (parts.length > 2) {
+        return null
+      } else if (parts.length === 2) {
+        cidrSuffix = parseInt(parts[1])
+        if (isNaN(cidrSuffix)) {
+          return null
+        }
+      }
+
+      octetsAsIntegers = parts[0].split('.').map(Number)
+      octets = octetsAsIntegers.map(x => x.toString())
+      ipv4AddressAsString = octets.join('.')
+      octetsAsBinaryString = octetsAsIntegers.map(x => x.toString(2).padStart(8, '0'))
+    } else {
+      return null
+    }
+
+    if (octetsAsIntegers.filter(x => x <= 255).length !== 4) {
+      return null
+    }
+
+    return {
+      asString: ipv4AddressAsString,
+      octets,
+      octetsAsIntegers,
+      octetsAsBinaryString,
+      asInt: ipv4AddressAsInt,
+      cidrSuffix
+    }
+  }
+
+  isInSubnet(subnet) {
+    subnet = ipV4(subnet)
+    const mask = ~((1 << (32 - subnet.cidrSuffix)) - 1) >>> 0;
+    return (this.toInteger() & mask) === (subnet.toInteger() & mask)
+  }
+
+  toString() {
+    return this.#ipv4Address?.asString ?? null
+  }
+
+  toInteger() {
+    if (!this.#ipv4Address) {
+      return null
+    }
+
+    this.#ipv4Address.asInt ??= parseInt(this.#ipv4Address.octetsAsBinaryString.join(''), 2)
+    return this.#ipv4Address.asInt
+  }
+}
+

package/src/net/http/IncomingMessage.js

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

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

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

package/src/net/http/TunliResponse.js

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