tunli 0.0.20 → 0.0.22

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.22",
   "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

@@ -10,6 +10,7 @@ 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 {proxy} from "#lib/Proxy";
 
 /**
  * @callback httpCommandExec
@@ -61,6 +62,7 @@ const exec = (configRef, cmd, program) => {
 
     options.port ??= port
     options.host ??= host
+    options.protocol ??= protocol ?? 'http'
 
     const save = options.save
     delete options.save
@@ -90,12 +92,18 @@ const exec = (configRef, cmd, program) => {
       path: undefined,
       allowCidr: options.allowCidr ?? config.allowCidr,
       denyCidr: options.denyCidr ?? config.denyCidr,
-      protocol: protocol ?? 'http'
+      protocol: options.protocol
     }
 
+    const useDashboard = process.env.DASHBOARD !== 'off'
+
     const client = new TunnelClient(clientOptions)
-    const dashboard = initDashboard(client, clientOptions, config)
+    const dashboard = useDashboard ? initDashboard(client, clientOptions, config) : null
     await client.init(dashboard)
+
+    if (!useDashboard) {
+      console.log(clientOptions)
+    }
   }
 }
 /**
@@ -116,9 +124,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/lib/Proxy.js

@@ -0,0 +1,42 @@
+import {ConfigManager} from "#src/config/ConfigManager";
+import {TunnelClient} from "#src/tunnel-client/TunnelClient";
+import {renewProxyUrlRegistration} from "#lib/Flow/proxyUrl";
+
+const prepareOptions = async (options) => {
+
+  options ??= {}
+  const localConf = ConfigManager.loadLocalOnly()
+  const globalConf = ConfigManager.loadGlobalOnly()
+
+  const authToken = globalConf.authToken
+
+  let preparedOptions = {authToken, ...localConf.dump(), ...options}
+
+  preparedOptions.server = await renewProxyUrlRegistration(preparedOptions.proxyURL, preparedOptions.authToken)
+  preparedOptions.denyCidr ??= []
+  preparedOptions.allowCidr ??= []
+
+  console.log(preparedOptions)
+
+  return preparedOptions
+}
+
+/**
+ *
+ * @param {tunliProxyOptions} options
+ */
+export const proxy = async (options) => {
+
+  options = await prepareOptions(options)
+  const client = new TunnelClient(options)
+
+  await client.init()
+  console.log('INIT')
+  return options
+}
+
+const tunli = {
+  proxy
+}
+
+export default tunli

package/src/net/http/TunnelRequest.js

@@ -109,11 +109,15 @@ export const forwardTunnelRequestToProxyTarget = (req, eventEmitter, options) =>
   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,
@@ -175,3 +179,51 @@ export const forwardTunnelRequestToProxyTarget = (req, eventEmitter, options) =>
     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/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()
@@ -94,6 +94,10 @@ export class TunnelClient extends EventEmitter {
     setInterval(ping, 5000)
   }
 
+  /**
+   * @param [dashboard]
+   * @return {Promise<TunnelClient>}
+   */
   async init(dashboard) {
 
     const params = await this.#createParameters(dashboard)
@@ -108,7 +112,7 @@ export class TunnelClient extends EventEmitter {
     const webSocketCapturePath = await securedHttpClient(options.authToken).get('/capture_path')
 
     if (webSocketCapturePath.error) {
-      dashboard.destroy()
+      dashboard?.destroy()
       if (webSocketCapturePath.error?.message === 'Request failed with status code 401') {
         console.error('missing authorization, check your registration and try again')
       } else {

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
@@ -110,3 +111,8 @@ export type keypressEventDetails = {
 export interface keypressEventListener {
   (char: string, details: keypressEventDetails): void
 }
+
+
+export type tunliProxyOptions = {
+
+}