tunli 0.0.19

package/src/commands/CommandConfig.js

@@ -0,0 +1,57 @@
+import {Command} from "commander";
+import {ref} from "#src/core/Ref";
+import {allowDenyCidrCommand} from "#commands/SubCommand/AllowDenyCidrCommand";
+import {portCommand} from "#commands/SubCommand/PortCommand";
+import {hostCommand} from "#commands/SubCommand/HostCommand";
+import {selectConfigOption} from "#commands/Option/SelectConfigOption";
+import {addExample, extendUsage} from "#commands/utils";
+
+/**
+ *
+ * @param {Ref} configRef
+ * @param {Command} program
+ * @returns {(function(*, *, *): void)|*}
+ */
+const exec = (configRef, program) => {
+
+  return async (key, value, options) => {
+
+    /** @type {LocalConfig|GlobalConfig} */
+    const config = configRef.value
+
+    const maxKeyLength = Math.max(...Object.keys(config.dump()).map(x => x.length))
+    console.log('location: ', config.configPath, "\n")
+    for (const [k, v] of Object.entries(config.dump())) {
+      console.log(k.padEnd(maxKeyLength, ' '), '=', v)
+      console.log(''.padEnd(maxKeyLength + 3 + (v?.length ?? 9), '-'))
+    }
+  }
+}
+/**
+ *
+ * @param {Command} program
+ */
+export const createCommandConfig = (program) => {
+
+  const configRef = ref()
+
+  const cmd = new Command('config')
+
+  cmd.addCommand(allowDenyCidrCommand('allowCidr', cmd, configRef))
+  cmd.addCommand(allowDenyCidrCommand('denyCidr', cmd, configRef))
+  cmd.addCommand(portCommand(configRef))
+  cmd.addCommand(hostCommand(configRef))
+
+  selectConfigOption(cmd, configRef, true)
+    .action(exec(configRef, program));
+
+  extendUsage(program, cmd)
+  //
+  addExample('config host localhost', 'Set the host for the local configuration')
+  addExample('config port 80', 'Set the port for the local configuration')
+  addExample('config', 'Show the local configuration')
+  addExample('config --global', 'Show the global configuration')
+
+  return cmd
+}
+

package/src/commands/CommandHTTP.js

@@ -0,0 +1,131 @@
+import {Command} from "commander";
+import {checkHost, checkPort} from "#src/utils/checkFunctions";
+import {isSharedArg, sharedArg} from "#commands/helper/SharedArg";
+import {addExample, validateArrayArguments, validateIpV4} from "#commands/utils";
+import {bindArgs} from "#commands/helper/BindArgs";
+import {ref} from "#src/core/Ref";
+import {selectConfigOption} from "#commands/Option/SelectConfigOption";
+import {TunnelClient} from "#src/tunnel-client/TunnelClient";
+import {renewProxyUrlRegistration, requestNewProxyUrl} from "#lib/Flow/proxyUrl";
+import {getCurrentIp} from "#lib/Flow/getCurrentIp";
+import {arrayUnique} from "#src/utils/arrayFunctions";
+import {initDashboard} from "#src/cli-app/Dashboard";
+
+/**
+ * @callback httpCommandExec
+ * @param {number} port
+ * @param {string} host
+ * @param {tunnelClientOptions} options
+ * @returns {Promise<void>}
+ */
+
+/**
+ * @param {Ref} configRef
+ * @returns {httpCommandExec}
+ */
+const exec = (configRef, cmd, program) => {
+
+  return async (port, host, options) => {
+
+    let protocol
+
+    if (['http', 'https'].includes(cmd.parent.args[0])) {
+      protocol = cmd.parent.args[0]
+    }
+
+    /** @type {AppConfig} */
+    const config = configRef.value
+
+    if (options.self) {
+      options.allowCidr ??= []
+      options.allowCidr.push(await getCurrentIp())
+      options.allowCidr = arrayUnique(options.allowCidr)
+    }
+
+    if (config.proxyURL) {
+      config.proxyURL = await renewProxyUrlRegistration(config.proxyURL, config.authToken)
+    }
+
+    if (!config.proxyURL) {
+      config.proxyURL = await requestNewProxyUrl(config.authToken)
+      options.save ??= true
+    }
+
+    if (isSharedArg(port)) {
+      protocol ??= port.value.url?.protocol
+      host ??= port.value.host ?? port.value.url?.host
+      port = port.value.port ?? port.value.url?.port
+      options.port ??= port
+      options.host ??= host
+    }
+
+    options.port ??= port
+    options.host ??= host
+
+    const save = options.save
+    delete options.save
+
+    if (save && save !== true) {
+      config.copyCurrentProfileTo(save).use(save)
+    }
+
+    for (const [k, v] of Object.entries(options)) {
+      if (v !== undefined) {
+        config[k] = v
+      }
+    }
+
+    if (save) {
+      config.save()
+    }
+
+    /**
+     * @type {tunnelClientOptions}
+     */
+    const clientOptions = {
+      port: options.port ?? config.port,
+      host: options.host ?? config.host,
+      authToken: config.authToken,
+      server: config.proxyURL,
+      path: undefined,
+      allowCidr: options.allowCidr ?? config.allowCidr,
+      denyCidr: options.denyCidr ?? config.denyCidr,
+      protocol: protocol ?? 'http'
+    }
+
+    const client = new TunnelClient(clientOptions)
+    const dashboard = initDashboard(client, clientOptions, config)
+    await client.init(dashboard)
+  }
+}
+/**
+ * @param {Command} program
+ */
+export const createCommandHTTP = (program) => {
+
+  const configRef = ref()
+  const cmd = new Command('http')
+  cmd.alias('https')
+
+  selectConfigOption(cmd, configRef)
+  // validateAuthToken(cmd, configRef)
+
+  const sharedArgument = sharedArg({})
+  cmd.argument('[PORT]', 'port welcher durch den proxy erreichbar sein soll (default: "80")', bindArgs(checkPort, sharedArgument, true))
+  cmd.argument('[HOST]', 'host welcher durch den proxy erreichbar sein soll (default: "localhost"/"config.value")', bindArgs(checkHost, sharedArgument, true))
+
+  cmd.option('--host <string>', 'setting hostname', bindArgs(checkHost, sharedArgument, false))
+  cmd.option('--port <string>', 'setting port', bindArgs(checkPort, sharedArgument, false))
+  cmd.option('--allow-cidr <string>', 'allow-cidr', validateArrayArguments(validateIpV4))
+  cmd.option('--deny-cidr <string>', 'deny-cidr', validateArrayArguments(validateIpV4))
+  cmd.option('--self', 'allow self only', false)
+  cmd.option('--save [alias]', 'save current settings as alias/local')
+  cmd.action(exec(configRef, cmd, program))
+
+  addExample('http localhost:80', 'HTTP Forward to localhost:80')
+  addExample('', 'Forward to port from default config, host from default config')
+  // extendUsage(program, cmd)
+  // .option('-o, --origin <string>', 'change request origin')
+
+  return cmd
+}

package/src/commands/CommandInvite.js

@@ -0,0 +1,38 @@
+import {Command} from "commander";
+import {httpClient, securedHttpClient} from "#lib/HttpClient";
+import {addExample, extendUsage} from "#commands/utils";
+import {ConfigManager} from "#src/config/ConfigManager";
+
+/**
+ *
+ * @returns {(function(): void)|*}
+ */
+const exec = () => {
+
+  return async () => {
+    const config = ConfigManager.loadSystem()
+    const {data, error} = await securedHttpClient(config.authToken).get('/invite')
+
+    if (error) {
+      console.error(error)
+      process.exit(1)
+    }
+
+    console.log('Done.', data)
+  }
+}
+
+/**
+ *
+ * @param {Command} program
+ */
+export const createCommandInvite = (program) => {
+
+  const cmd = new Command('invite')
+    .action(exec())
+
+  extendUsage(program, cmd)
+  addExample('invite', 'create sharable registration token')
+  return cmd
+
+}

package/src/commands/CommandRefresh.js

@@ -0,0 +1,35 @@
+import {Command} from "commander";
+import {selectConfigOption} from "#commands/Option/SelectConfigOption";
+import {ref} from "#src/core/Ref";
+import {validateAuthToken} from "#lib/Flow/validateAuthToken";
+import {requestNewProxyUrl} from "#lib/Flow/proxyUrl";
+
+/**
+ * @param {Ref} configRef
+ * @returns {(function(*, *): void)|*}
+ */
+const exec = (configRef) => {
+  return async () => {
+    /** @type {LocalConfig|GlobalConfig} */
+    const config = configRef.value
+    config.proxyURL = await requestNewProxyUrl(config.authToken)
+    config.save()
+    console.log('done')
+  }
+}
+/**
+ * @param {Command} program
+ */
+export const createCommandRefresh = (program) => {
+
+  const configRef = ref()
+  const cmd = new Command('refresh')
+
+  selectConfigOption(cmd, configRef)
+  validateAuthToken(cmd, configRef)
+
+  cmd.action(exec(configRef))
+  // extendUsage(program, cmd)
+
+  return cmd
+}

package/src/commands/CommandRegister.js

@@ -0,0 +1,48 @@
+import {Command} from "commander";
+import {httpClient} from "#lib/HttpClient";
+import {ConfigManager} from "#src/config/ConfigManager";
+
+/**
+ *
+ * @returns {(function(): void)|*}
+ */
+const exec = () => {
+
+  return async (options) => {
+
+    const forceRenew = options.f === true
+    const config = ConfigManager.loadSystem()
+
+    if (config.authToken && !forceRenew) {
+      console.log(`Auth token exists. use -f to renew: ${config.authToken}`)
+      process.exit()
+    }
+
+    const {data, error} = await httpClient.get('/register')
+
+    if (error) {
+      console.error(error)
+      process.exit(1)
+    }
+
+    config.authToken = data
+    config.save()
+    console.log('Done.',config.authToken)
+  }
+}
+
+
+/**
+ *
+ * @param {Command} program
+ */
+export const createCommandRegister = (program) => {
+
+  const cmd = new Command('register')
+    .option('-f', 'fore renew auth token')
+    .action(exec())
+
+  return cmd
+  // extendUsage(program, cmd)
+  // addExample('register', 'register call')
+}

package/src/commands/Option/DeleteOption.js

@@ -0,0 +1,6 @@
+import {Option} from "commander";
+
+export const deleteOption = (desc = 'delete config entry') => {
+  const option = new Option('--del', desc)
+  return option
+}

package/src/commands/Option/SelectConfigOption.js

@@ -0,0 +1,52 @@
+import {ConfigManager} from "#src/config/ConfigManager";
+
+/**
+ * @template T
+ * @param {T} command
+ * @param {Ref} [configRef]
+ * @param {boolean} strictMode
+ * @returns {T}
+ */
+export const selectConfigOption = (command, configRef, strictMode = false) => {
+
+  command.option('--global', 'Use the global configuration file (default)')
+    .option('--workdir', 'Use the configuration file for the current working directory')
+    .option('-p --alias <string>', 'setting alias name', 'default')
+
+  if (configRef) {
+    command.hook('preAction', (thisCommand, actionCommand) => {
+
+      let {alias, workdir, global} = thisCommand.opts()
+
+      if (strictMode) {
+        if (global) {
+          workdir = false
+        }
+        if (workdir) {
+          global = false
+        }
+        global ??= true
+        workdir ??= false
+      } else {
+        if (workdir) {
+          global ??= false
+        }
+        if (global) {
+          workdir ??= false
+        }
+        global ??= true
+        workdir ??= true
+      }
+
+      if (global && workdir) {
+        configRef.value = ConfigManager.loadCombined(alias)
+      } else if (global) {
+        configRef.value = ConfigManager.loadGlobalOnly(alias)
+      } else {
+        configRef.value = ConfigManager.loadLocalOnly(alias, !strictMode)
+      }
+    })
+  }
+
+  return command
+}

package/src/commands/SubCommand/AllowDenyCidrCommand.js

@@ -0,0 +1,28 @@
+import {Command} from "commander";
+import {addDelValuesAction} from "#commands/Action/addDelValuesAction";
+import {validateArrayArguments, validateIpV4} from "#commands/utils";
+
+/**
+ * @param {string} commandName
+ * @param {Command} configCommand
+ * @param {Ref} configRef
+ * @returns {Command}
+ */
+export const allowDenyCidrCommand = (commandName, configCommand, configRef) => {
+  const cmd = new Command(commandName)
+
+  cmd
+    .argument('[values...]', 'config value', validateArrayArguments(validateIpV4))
+    .option('-d --del [ip-address]', 'del values', validateArrayArguments(validateIpV4))
+    .option('-a --add [ip-address]', 'add values', validateArrayArguments(validateIpV4))
+    .action(addDelValuesAction(commandName, configRef))
+    .hook('preAction', (thisCommand, actionCommand) => {
+      const {del, add} = actionCommand.opts()
+
+      if (!actionCommand.args.length && !del && !add) {
+        // actionCommand.error("error: --add, --del oder values, einer muss mindestens gesetzt sein");
+      }
+    })
+
+  return cmd
+}

package/src/commands/SubCommand/HostCommand.js

@@ -0,0 +1,22 @@
+import {Command} from "commander";
+
+import {checkHost} from "#src/utils/checkFunctions";
+import {deleteOption} from "#commands/Option/DeleteOption";
+import {addGetDeleteValueAction} from "#commands/Action/addDelValuesAction";
+
+export const hostCommand = (configRef) => {
+  const cmd = new Command('host')
+
+
+  cmd.description('default forweard host (127.0.0.1)')
+    .argument('[HOST]', 'füge eine kurze beschreibung ein', checkHost)
+    .hook('preAction', (thisCommand, actionCommand) => {
+      if (thisCommand.args.length && thisCommand.opts().del) {
+        actionCommand.error("error: wenn delete dann keine argumente");
+      }
+    })
+    .addOption(deleteOption())
+    .action(addGetDeleteValueAction('host', configRef))
+
+  return cmd
+}

package/src/commands/SubCommand/PortCommand.js

@@ -0,0 +1,20 @@
+import {Command} from "commander";
+import {checkPort} from "#src/utils/checkFunctions";
+import {addGetDeleteValueAction} from "#commands/Action/addDelValuesAction";
+import {deleteOption} from "#commands/Option/DeleteOption";
+
+export const portCommand = (configRef) => {
+  const cmd = new Command('port')
+  cmd.description('default forweard port (80)')
+    .argument('[PORT]', 'set port for config', checkPort)
+    .action(addGetDeleteValueAction('port', configRef))
+    .addOption(deleteOption())
+
+  return cmd
+}
+
+//
+// if (!config.isPublic(configKey)) {
+//   console.error('Ungültiger Konfigurationsdirektive')
+//   process.exit()
+// }

package/src/commands/helper/AliasResolver.js

@@ -0,0 +1,13 @@
+export const argumentAliasResolver = () => {
+  let args = []
+  for (let i = 0; i < process.argv.length; i++) {
+    const arg = process.argv[i]
+    if (arg.charAt(0) === '@') {
+      args.push('--alias')
+      args.push(arg.substring(1))
+    } else {
+      args.push(arg)
+    }
+  }
+  return args
+}

package/src/commands/helper/BindArgs.js

@@ -0,0 +1,53 @@
+import {ipV4} from "#src/net/IPV4";
+
+/**
+ * Binds arguments to a function.
+ * @param {Function} fn - The function to bind arguments to.
+ * @param {...any} args - The arguments to bind.
+ * @returns {Function} - The bound function.
+ */
+export const bindArgs = (fn, ...args) => {
+  return fn.bind(null, ...args)
+}
+
+/**
+ * Validates a remote address against allowed and denied CIDR ranges.
+ * @param {string} remoteAddress - The remote address to check.
+ * @param {Object} options - The options containing allowCidr and denyCidr arrays.
+ * @param {ipCidr[]} options.allowCidr - Array of CIDR ranges that are allowed.
+ * @param {ipCidr[]} options.denyCidr - Array of CIDR ranges that are denied.
+ * @returns {boolean} - True if the address is valid, otherwise false.
+ */
+export const isValidRemoteAddress = (() => {
+  const cache = {}
+
+  /**
+   * Checks if a remote address is within a given subnet.
+   * Uses a cache to store results for performance improvement.
+   * @param {string} remoteAddress - The remote address to check.
+   * @param {string} subnet - The CIDR subnet to check against.
+   * @returns {boolean} - True if the remote address is in the subnet, otherwise false.
+   */
+  const isInSubnet = (remoteAddress, subnet) => {
+    return cache[`${remoteAddress}#${subnet}`] ??= ipV4(remoteAddress).isInSubnet(subnet)
+  }
+
+  return (remoteAddress, {allowCidr, denyCidr}) => {
+    // Check against denied CIDR ranges
+    for (const deny of denyCidr) {
+      if (isInSubnet(remoteAddress, deny)) {
+        return false
+      }
+    }
+
+    // Check against allowed CIDR ranges
+    for (const allow of allowCidr) {
+      if (isInSubnet(remoteAddress, allow)) {
+        return true
+      }
+    }
+
+    // If there are no allowed CIDR ranges, allow the address
+    return allowCidr.length === 0
+  }
+})();

package/src/commands/helper/SharedArg.js

@@ -0,0 +1,32 @@
+import {Ref} from "#src/core/Ref";
+
+/**
+ * Class representing a shared argument, extending Ref.
+ */
+class SharedArg extends Ref {
+  /**
+   * Create a SharedArg instance.
+   * @param {*} value - The initial value for the shared argument.
+   */
+  constructor(value) {
+    super(value)
+  }
+}
+
+/**
+ * Create a new SharedArg instance.
+ * @param {*} value - The initial value for the shared argument.
+ * @returns {SharedArg} - The created SharedArg instance.
+ */
+export const sharedArg = (value) => {
+  return new SharedArg(value)
+}
+
+/**
+ * Check if a value is an instance of SharedArg.
+ * @param {SharedArg|*} value - The value to check.
+ * @returns {boolean} - True if the value is an instance of SharedArg, false otherwise.
+ */
+export const isSharedArg = (value) => {
+  return value instanceof SharedArg
+}

package/src/commands/utils.js

@@ -0,0 +1,96 @@
+import {Command} from "commander";
+import {checkIpV4Cidr} from "#src/utils/checkFunctions";
+
+export const validateArrayArguments = (validationCallback) => {
+
+  return (value, previous) => {
+    const ref = {value}
+    validationCallback(ref)
+    previous ??= []
+    previous.push(ref.value)
+    return previous
+  }
+}
+export const validateIpV4 = (ref) => {
+  ref.value = checkIpV4Cidr(ref.value)
+}
+
+const extendedUsages = []
+
+/**
+ * @param {Command} program
+ * @param {Command} command
+ */
+export const extendUsage = (program, command) => {
+
+  extendedUsages.push({program, command})
+
+}
+
+export const addUsage = (program) => {
+
+  const help = program.createHelp()
+
+  for (const {program, command} of extendedUsages) {
+    const usage = help.commandUsage(command)
+    const before = program.usage()
+    program.usage(before + "\n" + ''.padEnd(7, ' ') + usage)
+  }
+}
+
+/**
+ * Add examples to the command help text.
+ * @param {Command} program - The commander program instance.
+ */
+export const addExamples = (program) => {
+
+  const usage = program.usage()
+  program.usage('')
+
+  const maxRowLength = {
+    length: 0
+  }
+
+  const rows = [].slice.call(program.helpInformation().split("\n").map(x => {
+    x = x.trim()
+    const rowLength = x.length
+    if (rowLength > maxRowLength.length) {
+      maxRowLength.length = rowLength
+      maxRowLength.row = x
+    }
+    return x
+  }).filter(Boolean), 2)
+  program.usage(usage)
+
+  const maxWhitespaceLength = {
+    length: 0
+  }
+
+  for (const match of maxRowLength.row.matchAll(/(\s)+/g)) {
+    const whiteSpacesCount = match[0].length
+    if (whiteSpacesCount > maxWhitespaceLength.length) {
+      maxWhitespaceLength.length = whiteSpacesCount
+      maxWhitespaceLength.index = match.index
+    }
+  }
+
+  const padLength = maxWhitespaceLength.index + maxWhitespaceLength.length - 6
+  program.addHelpText('after', "\nExamples:")
+
+  for (const {example, description} of examples) {
+    const whitespaces = ''.padStart(padLength - example.length, ' ')
+    program.addHelpText('after', `  tunli ${example}${whitespaces}${description}`)
+  }
+}
+
+/**
+ * Adds an example to the list of examples.
+ * @param {string} example - The example command.
+ * @param {string} description - The description of the example.
+ */
+export const addExample = (example, description) => {
+  examples.push({
+    example, description
+  })
+}
+const examples = []