tunli 0.0.27 → 0.2.0

package/src/commands/CommandConfig.js

@@ -1,59 +0,0 @@
-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";
-import {protocolCommand} from "#commands/SubCommand/ProtocolCommand";
-
-/**
- *
- * @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))
-  cmd.addCommand(protocolCommand(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

@@ -1,192 +0,0 @@
-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";
-import {md5} from "#src/utils/hashFunctions";
-
-
-/**
- *
- * @param {AppConfig} config
- * @param {tunnelClientOptions} options
- */
-const computeProxyURL = async (config, options) => {
-
-  // console.log(new URL(`${options.protocol}://${options.host ?? config.host}:${options.port ?? config.port}`).toString())
-
-  const targetUrlHash = md5(new URL(`${options.protocol}://${options.host ?? config.host}:${options.port ?? config.port}`))
-
-  if (config.profile === 'default') {
-    let proxyUrl = config.proxyURLs[targetUrlHash]
-
-    if (proxyUrl) {
-      proxyUrl = await renewProxyUrlRegistration(proxyUrl, config.authToken)
-    }
-
-    if (!proxyUrl) {
-      proxyUrl = await requestNewProxyUrl(config.authToken)
-      config.proxyURLs[targetUrlHash] = proxyUrl
-      config.update({proxyURLs: config.proxyURLs})
-    }
-
-    config.proxyURL = proxyUrl
-
-    console.log(config.proxyURL)
-    return
-  }
-
-  if (config.proxyURL) {
-    config.proxyURL = await renewProxyUrlRegistration(config.proxyURL, config.authToken)
-  }
-
-  if (!config.proxyURL) {
-    config.proxyURL = await requestNewProxyUrl(config.authToken)
-    config.update({proxyURL: config.proxyURL})
-  }
-}
-
-/**
- * @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.authToken) {
-      console.error("error: Missing authToken. Please run register firstly")
-      process.exit()
-    }
-
-    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
-    options.protocol ??= protocol ?? 'http'
-
-    await computeProxyURL(config, options)
-
-    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: options.protocol
-    }
-
-    const useDashboard = process.env.TUNLI_DASHBOARD !== 'off'
-
-    const client = new TunnelClient(clientOptions)
-
-    client.once('tunnel-connection-error', async (error) => {
-      error.stopPropagation = true
-      if (error.data?.connection_exists) {
-        clientOptions.server = await requestNewProxyUrl(config.authToken)
-
-        if (useDashboard) {
-          dashboard.forwardingUrl = clientOptions.server
-        }
-
-        await client.init()
-      }
-    })
-
-    const dashboard = useDashboard ? initDashboard(client, clientOptions, config) : null
-    await client.init(dashboard)
-
-    if (!useDashboard) {
-      console.log(clientOptions)
-    }
-  }
-}
-/**
- * @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, --allow-cidr <string>', 'allow-cidr', validateArrayArguments(validateIpV4))
-  cmd.option('--deny, --deny-cidr <string>', 'deny-cidr', validateArrayArguments(validateIpV4))
-  cmd.option('--allow-self, --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

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

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

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

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

package/src/commands/Option/ProfileListOption.js

@@ -1,65 +0,0 @@
-import {Option} from "commander";
-import {ConfigManager} from "#src/config/ConfigManager";
-
-export const profileListOption = () => {
-  const option = new Option('-l, --list', 'profile list')
-  option.argParser(() => {
-    /**
-     * @param label
-     * @param {ConfigAbstract} config
-     * @return {string}
-     */
-    const createOutput = (label, config) => {
-      const profiles = [...config.profiles]
-      const maxLabelLength = Math.max(...profiles.map(x => x.length))
-      const whitespace = ''.padEnd(2)
-      const rows = [`${label}`, '']
-      // const rows = [`${label}${profiles.shift()}`]
-      const overview = {}
-      const proxyURLs = []
-      for (const profile of profiles) {
-
-        const info = config.use(profile)
-        const host = info.host
-        const port = info.port
-        const protocol = info.protocol
-        let proxyURL = info.proxyURL
-
-        let targetUrl = new URL(`${protocol}://${host}:${port}`).toString()
-        if (proxyURL) {
-          proxyURL = proxyURL.substring(0, proxyURL.length - 1)
-        }
-
-        targetUrl = targetUrl.substring(0, targetUrl.length - 1)
-        proxyURLs.push(proxyURL.length)
-        overview[profile] = {
-          host,
-          port,
-          targetUrl,
-          proxyURL
-        }
-      }
-
-      const maxProxyUrlLength = Math.max(...proxyURLs)
-
-      for (const profile of profiles) {
-        let {targetUrl, proxyURL} = overview[profile]
-        proxyURL = proxyURL.padEnd(maxProxyUrlLength)
-        rows.push(`${whitespace}${profile.padEnd(maxLabelLength)}    ${proxyURL} -> ${targetUrl}`)
-      }
-
-      return rows.join("\n") + "\n"
-    }
-    const localConf = ConfigManager.loadLocalOnly()
-    const globalConf = ConfigManager.loadGlobalOnly()
-
-    if (localConf.exists()) {
-      console.log(createOutput('Alias local config:  ', localConf))
-    }
-    if (globalConf.exists()) {
-      console.log(createOutput('Alias global config:  ', globalConf))
-    }
-    process.exit()
-  })
-  return option
-}

package/src/commands/Option/SelectConfigOption.js

@@ -1,52 +0,0 @@
-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('--local, --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

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

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

@@ -1,20 +0,0 @@
-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/SubCommand/ProtocolCommand.js

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

package/src/commands/helper/AliasResolver.js

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

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