tunli 0.0.20 → 0.0.21

package/client.js

@@ -8,6 +8,7 @@ import {createCommandRefresh} from "#commands/CommandRefresh";
 import {argumentAliasResolver} from "#commands/helper/AliasResolver";
 import {createCommandInvite} from "#commands/CommandInvite";
 import {addExamples, addUsage} from "#commands/utils";
+import {profileListOption} from "#commands/Option/ProfileListOption";
 
 program
   .name('tunli')
@@ -17,6 +18,7 @@ program
     console.log(`tunli: ${packageJson.version}`)
     process.exit()
   })
+  .addOption(profileListOption())
 
 program.addCommand(createCommandConfig(program))
 program.addCommand(createCommandHTTP(program), {isDefault: true})

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tunli",
   "description": "Node.js application for creating HTTP tunnels to make local software projects accessible over the internet.",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "main": "bin/tunli",
   "bin": {
     "tunli": "bin/tunli"

package/src/commands/CommandConfig.js

@@ -5,6 +5,7 @@ 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";
 
 /**
  *
@@ -41,6 +42,7 @@ export const createCommandConfig = (program) => {
   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));

package/src/commands/CommandHTTP.js

@@ -61,6 +61,7 @@ const exec = (configRef, cmd, program) => {
 
     options.port ??= port
     options.host ??= host
+    options.protocol ??= protocol ?? 'http'
 
     const save = options.save
     delete options.save
@@ -90,7 +91,7 @@ const exec = (configRef, cmd, program) => {
       path: undefined,
       allowCidr: options.allowCidr ?? config.allowCidr,
       denyCidr: options.denyCidr ?? config.denyCidr,
-      protocol: protocol ?? 'http'
+      protocol: options.protocol
     }
 
     const client = new TunnelClient(clientOptions)
@@ -116,9 +117,9 @@ export const createCommandHTTP = (program) => {
 
   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('--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))
 

package/src/commands/Option/ProfileListOption.js

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

@@ -10,7 +10,7 @@ import {ConfigManager} from "#src/config/ConfigManager";
 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('--local, --workdir', 'Use the configuration file for the current working directory')
     .option('-p --alias <string>', 'setting alias name', 'default')
 
   if (configRef) {

package/src/commands/SubCommand/ProtocolCommand.js

@@ -0,0 +1,21 @@
+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/config/ConfigAbstract.js

@@ -1,4 +1,4 @@
-import {writeFileSync} from "fs"
+import {existsSync, writeFileSync} from "fs"
 import {dirname} from 'path'
 import {ensureDirectoryExists} from "#src/core/FS/utils";
 import {PropertyConfig} from "#src/config/PropertyConfig";
@@ -143,6 +143,17 @@ export class ConfigAbstract {
     return this.#activeProfile
   }
 
+  /**
+   * @return {string[]}
+   */
+  get profiles() {
+    return Object.keys(this.#profileData.profile)
+  }
+
+  exists() {
+    return existsSync(this.#path)
+  }
+
   /**
    * Prepare the configuration by defining properties.
    * @param {{[p: string]: PropertyConfig}} propertyConfig - The configuration properties.

package/src/config/GlobalLocalShardConfigAbstract.js

@@ -1,4 +1,4 @@
-import {checkHost, checkIpV4Cidr, checkPort, checkUrl} from "#src/utils/checkFunctions";
+import {checkHost, checkInArray, checkIpV4Cidr, checkPort, checkUrl} from "#src/utils/checkFunctions";
 import {ConfigAbstract, VISIBILITY_PUBLIC} from "#src/config/ConfigAbstract";
 import {property} from "#src/config/PropertyConfig";
 import {ConfigManager} from "#src/config/ConfigManager";
@@ -58,6 +58,15 @@ export class GlobalLocalShardConfigAbstract extends ConfigAbstract {
         return checkHost(val)
       }
     }),
+    protocol: property({
+      visibility: VISIBILITY_PUBLIC,
+      writeable: true,
+      type: String,
+      defaultValue: 'http',
+      validate(val) {
+        return checkInArray(val, ['http', 'https'])
+      }
+    }),
   }
 
   /**

package/src/tunnel-client/TunnelClient.js

@@ -16,7 +16,7 @@ export class TunnelClient extends EventEmitter {
   #latency = ref(0)
 
   /**
-   * @param {tunnelClientOptions} options
+   * @param {...tunnelClientOptions} options
    */
   constructor(options) {
     super()

package/src/utils/checkFunctions.js

@@ -159,3 +159,15 @@ export const checkPort = (valueOrSharedArg, isArgument = false, value) => {
 
   return value
 }
+
+export const checkProtocol = (value) => {
+  return checkInArray(value, ['http', 'https'])
+}
+
+export const checkInArray = (val, arr) => {
+  if (!arr.includes(val)) {
+    throw new InvalidArgumentError(`Value must be one of (${arr.join(', ')})`)
+  }
+
+  return val
+}

package/types/index.d.ts

@@ -48,6 +48,7 @@ interface ConfigAbstract {
 
 export interface AppConfig {
 
+  protocol: protocol
   port: number
   host: string
   authToken: string