tunli 0.0.24 → 0.0.25

package/bin/tunli

@@ -5,7 +5,7 @@ import {exit} from 'node:process'
 import {resolve} from "path";
 import {dirnameFromMeta} from "#src/core/FS/utils";
 
-setCursorVisibility(false)
+if (process.env.TUNLI_DASHBOARD !== 'off') setCursorVisibility(false)
 const exitCode = await proxyChildProcess(resolve(dirnameFromMeta(import.meta), '../client.js'))
-setCursorVisibility(true)
+if (process.env.TUNLI_DASHBOARD !== 'off') setCursorVisibility(true)
 exit(exitCode)

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.24",
+  "version": "0.0.25",
   "main": "bin/tunli",
   "bin": {
     "tunli": "bin/tunli"
@@ -28,7 +28,6 @@
     "blessed": "^0.1.81",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
-    "https-proxy-agent": "^7.0.4",
     "socket.io-client": "^4.7.5"
   },
   "devDependencies": {

package/src/cli-app/Dashboard.js

@@ -7,140 +7,205 @@ import {getLatestVersion} from "#lib/Flow/getLatestVersion";
 import {exec} from 'child_process'
 import {checkGlobalInstallation, checkLocalInstallation} from "#src/utils/npmFunctions";
 
+export class Dashboard {
+
+  /**
+   * @type {TunnelClient}
+   */
+  #client
+  /**
+   * @type {tunnelClientOptions}
+   */
+  #options
+  /**
+   * @type {AppConfig}
+   */
+  #config
+  /**
+   * @type {Screen}
+   */
+  #screen
+  /**
+   * @type {Ref}
+   */
+  #forwardingUrl
+
+  /**
+   * @param {TunnelClient} client
+   * @param {tunnelClientOptions} options
+   * @param {AppConfig} config
+   */
+  constructor(client, options, config) {
+    this.#client = client
+    this.#options = options
+    this.#config = config
+  }
+
+  /**
+   * @param {string} value
+   */
+  set forwardingUrl(value) {
+    this.#forwardingUrl.value = value
+  }
+
+  /**
+   * @return {Screen}
+   */
+  get screen() {
+    return this.#screen
+  }
+
+  destroy() {
+    this.#screen.destroy()
+  }
+
+  init() {
+
+    const options = this.#options
+    const config = this.#config
+    const client = this.#client
+
+    const screen = createScreen()
+    this.#screen = screen
+    const packageJson = readJsonFile(searchFileInDirectoryTree('package.json', dirnameFromMeta(import.meta)))
+    const connectionStatus = ref(chalk.yellow('offline'))
+    const requestCount = ref(0)
+    const connectionDetails = ref('')
+    const forwardingUrl = ref(trimEnd(options.server, '/'))
+
+    this.#forwardingUrl = forwardingUrl
+
+    const allowedCidr = options.allowCidr.join(', ')
+    const deniedCidr = options.denyCidr.join(', ')
+
+    const blockedCount = ref(0)
+    const lastBlockedIp = ref('')
+    const availableUpdate = ref('')
+
+    getLatestVersion().then((version) => {
+      if (version && version !== packageJson.version) {
+        availableUpdate.value = chalk.yellow(`update available (version ${version}, Ctrl-U to update)`)
+
+        screen.onceKey('C-u', async (char, details) => {
+          availableUpdate.value = chalk.yellow('Updating...')
+          let modifier
+          if (await checkGlobalInstallation(packageJson.name)) {
+            modifier = ' -g'
+          } else if (!await checkLocalInstallation(packageJson.name)) {
+            availableUpdate.value = chalk.red('Update failed.')
+            return
+          }
+
+          const npmUpdateCommand = `npm${modifier} update ${packageJson.name} --registry https://registry.npmjs.org`
+
+          exec(npmUpdateCommand, (error, stdout, stderr) => {
+            if (error || stderr) {
+              availableUpdate.value = chalk.red('Update failed. Reason 2.')
+              return;
+            }
+            availableUpdate.value = chalk.green('Update done. Please restart tunli. (Ctrl+R to restart)')
+          })
+        })
+      }
+    })
+
+    screen.row(packageJson.name)
+    screen.row('(Ctrl+C to quit)', {
+      top: -1, right: 0
+    })
+
+    screen.row("")
+
+    const infoList = screen.list({minWidth: 30})
+
+    screen.row('HTTP Requests')
+    screen.line()
+
+    const accessLog = screen.list({
+      length: 30, reverse: true, minWidth: [undefined, 30], maxWidth: [undefined, screen.width - 35]
+    })
+
+    client.on('tunnel-connection-established', () => {
+      connectionStatus.value = chalk.bold(chalk.green('online'))
+      connectionDetails.value = ''
+      screen.render()
+    })
+
+    client.on('blocked', ip => {
+      blockedCount.value++
+      lastBlockedIp.value = ` (${ip})`
+    })
+    client.on('tunnel-connection-closed', () => {
+      connectionStatus.value = chalk.bold(chalk.red('offline'))
+      screen.render()
+    })
+
+    client.on('tunnel-connection-error', (error) => {
+      if (error.stopPropagation) {
+        return
+      }
+      connectionDetails.value = chalk.bold(chalk.red(` - ${error.message}`))
+      screen.render()
+    })
+
+    client.on('response', (res, req) => {
+
+      const code = res.statusCode
+      let rspMsg = `${res.statusCode} ${res.statusMessage}`
+      if (code >= 500) {
+        rspMsg = chalk.red(rspMsg)
+      } else if (code >= 400) {
+        rspMsg = chalk.blueBright(rspMsg)
+      } else {
+        rspMsg = chalk.green(rspMsg)
+      }
+
+      rspMsg = chalk.bold(rspMsg)
+
+      requestCount.value++
+      accessLog.row(req.method, req.path, rspMsg)
+      screen.render()
+    })
+
+    screen.key('C-c', (char, details) => {
+      process.exit(0);
+    })
+
+    screen.key('C-r', (char, details) => {
+      process.send('restart')
+    })
+
+    const target = new URL(`${options.protocol}://${options.host}:${options.port}`)
+
+    infoList.row('Tunnel', concat(connectionStatus, connectionDetails))
+    infoList.row('Version', packageJson.version)
+    infoList.row(chalk.yellow('Update'), availableUpdate).if(() => availableUpdate)
+    infoList.row('Profile', config.profile)
+    infoList.row('Config', config.configPath)
+
+    if (allowedCidr || deniedCidr) infoList.row('')
+    if (allowedCidr) infoList.row('Allowed', allowedCidr)
+    if (deniedCidr) infoList.row('Denied', deniedCidr)
+    if (allowedCidr || deniedCidr) infoList.row('Blocked', concat(blockedCount, lastBlockedIp))
+
+    infoList.row('')
+    infoList.row('Latency', concat(client.latency, 'ms'))
+    infoList.row('Forwarding', concat(forwardingUrl, ` -> ${trimEnd(target.toString(), '/')}`))
+    infoList.row('Connections', requestCount)
+
+    screen.render();
+
+    return this
+  }
+}
+
 /**
- *
  * @param {TunnelClient} client
  * @param {tunnelClientOptions} options
  * @param {AppConfig} config
  */
 export const initDashboard = (client, options, config) => {
-
-  const screen = createScreen()
-  const packageJson = readJsonFile(searchFileInDirectoryTree('package.json', dirnameFromMeta(import.meta)))
-  const connectionStatus = ref(chalk.yellow('offline'))
-  const requestCount = ref(0)
-  const connectionDetails = ref('')
-
-  const allowedCidr = options.allowCidr.join(', ')
-  const deniedCidr = options.denyCidr.join(', ')
-
-  const blockedCount = ref(0)
-  const lastBlockedIp = ref('')
-  const availableUpdate = ref('')
-
-  getLatestVersion().then((version) => {
-    if (version && version !== packageJson.version) {
-      availableUpdate.value = chalk.yellow(`update available (version ${version}, Ctrl-U to update)`)
-
-      screen.onceKey('C-u', async (char, details) => {
-        availableUpdate.value = chalk.yellow('Updating...')
-        let modifier
-        if (await checkGlobalInstallation(packageJson.name)) {
-          modifier = ' -g'
-        } else if (!await checkLocalInstallation(packageJson.name)) {
-          availableUpdate.value = chalk.red('Update failed.')
-          return
-        }
-
-        const npmUpdateCommand = `npm${modifier} update ${packageJson.name} --registry https://registry.npmjs.org`
-
-        exec(npmUpdateCommand, (error, stdout, stderr) => {
-          if (error || stderr) {
-            availableUpdate.value = chalk.red('Update failed. Reason 2.')
-            return;
-          }
-          availableUpdate.value = chalk.green('Update done. Please restart tunli. (Ctrl+R to restart)')
-        })
-      })
-    }
-  })
-
-  screen.row(packageJson.name)
-  screen.row('(Ctrl+C to quit)', {
-    top: -1,
-    right: 0
-  })
-
-  screen.row("")
-
-  const infoList = screen.list({minWidth: 30})
-
-  screen.row('HTTP Requests')
-  screen.line()
-
-  const accessLog = screen.list({
-    length: 30,
-    reverse: true,
-    minWidth: [undefined, 30],
-    maxWidth: [undefined, screen.width - 35]
-  })
-
-  client.on('tunnel-connection-established', () => {
-    connectionStatus.value = chalk.bold(chalk.green('online'))
-    connectionDetails.value = ''
-    screen.render()
-  })
-
-  client.on('blocked', ip => {
-    blockedCount.value++
-    lastBlockedIp.value = ` (${ip})`
-  })
-  client.on('tunnel-connection-closed', () => {
-    connectionStatus.value = chalk.bold(chalk.red('offline'))
-    screen.render()
-  })
-
-  client.on('tunnel-connection-error', (error) => {
-    connectionDetails.value = chalk.bold(chalk.red(` - ${error.message}`))
-    screen.render()
-  })
-
-  client.on('response', (res, req) => {
-
-    const code = res.statusCode
-    let rspMsg = `${res.statusCode} ${res.statusMessage}`
-    if (code >= 500) {
-      rspMsg = chalk.red(rspMsg)
-    } else if (code >= 400) {
-      rspMsg = chalk.blueBright(rspMsg)
-    } else {
-      rspMsg = chalk.green(rspMsg)
-    }
-
-    rspMsg = chalk.bold(rspMsg)
-
-    requestCount.value++
-    accessLog.row(req.method, req.path, rspMsg)
-    screen.render()
-  })
-
-  screen.key('C-c', (char, details) => {
-    process.exit(0);
-  })
-
-  screen.key('C-r', (char, details) => {
-    process.send('restart')
-  })
-
-  const target = new URL(`${options.protocol}://${options.host}:${options.port}`)
-
-  infoList.row('Tunnel', concat(connectionStatus, connectionDetails))
-  infoList.row('Version', packageJson.version)
-  infoList.row(chalk.yellow('Update'), availableUpdate).if(() => availableUpdate)
-  infoList.row('Profile', config.profile)
-  infoList.row('Config', config.configPath)
-
-  if (allowedCidr || deniedCidr) infoList.row('')
-  if (allowedCidr) infoList.row('Allowed', allowedCidr)
-  if (deniedCidr) infoList.row('Denied', deniedCidr)
-  if (allowedCidr || deniedCidr) infoList.row('Blocked', concat(blockedCount, lastBlockedIp))
-
-  infoList.row('')
-  infoList.row('Latency', concat(client.latency, 'ms'))
-  infoList.row('Forwarding', `${trimEnd(options.server, '/')} -> ${trimEnd(target.toString(), '/')}`)
-  infoList.row('Connections', requestCount)
-
-  screen.render();
-
-  return screen
+  const dashboard = new Dashboard(client, options, config)
+  dashboard.init()
+  return dashboard
 }

package/src/commands/CommandHTTP.js

@@ -10,7 +10,48 @@ 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";
+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
@@ -48,15 +89,6 @@ const exec = (configRef, cmd, program) => {
       process.exit()
     }
 
-    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
@@ -69,6 +101,8 @@ const exec = (configRef, cmd, program) => {
     options.host ??= host
     options.protocol ??= protocol ?? 'http'
 
+    await computeProxyURL(config, options)
+
     const save = options.save
     delete options.save
 
@@ -100,9 +134,23 @@ const exec = (configRef, cmd, program) => {
       protocol: options.protocol
     }
 
-    const useDashboard = process.env.DASHBOARD !== 'off'
+    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)
 

package/src/config/ConfigAbstract.js

@@ -1,4 +1,4 @@
-import {existsSync, writeFileSync} from "fs"
+import {existsSync, readFileSync, writeFileSync} from "fs"
 import {dirname} from 'path'
 import {ensureDirectoryExists} from "#src/core/FS/utils";
 import {PropertyConfig} from "#src/config/PropertyConfig";
@@ -268,6 +268,30 @@ export class ConfigAbstract {
     return this
   }
 
+  /**
+   * @param {{[p:string]: any}} value
+   * @return {ConfigAbstract}
+   */
+  update(value) {
+    ensureDirectoryExists(dirname(this.#path))
+
+    const isSystem = this.#data === this.#profileData.system
+    const profileData = JSON.parse(readFileSync(this.#path, 'utf-8'))
+    profileData.system ??= {}
+    profileData.profile ??= {}
+    profileData.profile[this.profile] ??= {}
+
+    const updateData = isSystem ? profileData.system : profileData.profile[this.profile]
+
+    for (const [k, v] of Object.entries(value)) {
+      updateData[k] = v
+      this[k] = v
+    }
+
+    writeFileSync(this.#path, JSON.stringify(profileData, null, 2) + "\n")
+    return this
+  }
+
   /**
    * Use the system configuration.
    * @returns {ConfigAbstract} - The instance of the configuration.

package/src/config/GlobalLocalShardConfigAbstract.js

@@ -1,4 +1,4 @@
-import {checkHost, checkInArray, checkIpV4Cidr, checkPort, checkUrl} from "#src/utils/checkFunctions";
+import {checkHost, checkInArray, checkIpV4Cidr, checkMd5, 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";
@@ -20,6 +20,19 @@ export class GlobalLocalShardConfigAbstract extends ConfigAbstract {
         return val.map(checkIpV4Cidr)
       }
     }),
+    proxyURLs: property({
+      defaultValue: {},
+      visibility: VISIBILITY_PUBLIC,
+      writeable: true,
+      type: Array,
+      validate(val) {
+        const final = {}
+        for (const [hash, proxyURL] of Object.entries(val)) {
+          final[checkMd5(hash)] = checkUrl(proxyURL)
+        }
+        return final
+      }
+    }),
     proxyURL: property({
       visibility: VISIBILITY_PUBLIC,
       writeable: true,

package/src/tunnel-client/TunnelClient.js

@@ -95,7 +95,7 @@ export class TunnelClient extends EventEmitter {
   }
 
   /**
-   * @param [dashboard]
+   * @param {Dashboard} [dashboard]
    * @return {Promise<TunnelClient>}
    */
   async init(dashboard) {
@@ -107,6 +107,10 @@ export class TunnelClient extends EventEmitter {
     return this
   }
 
+  /**
+   * @param {Dashboard} dashboard
+   * @return {Promise<{path: any, transports: string[], auth: {token: string}, extraHeaders: {}}>}
+   */
   async #createParameters(dashboard) {
     const options = this.#options
     const webSocketCapturePath = await securedHttpClient(options.authToken).get('/capture_path')

package/src/utils/checkFunctions.js

@@ -170,4 +170,13 @@ export const checkInArray = (val, arr) => {
   }
 
   return val
+}
+
+export const checkMd5 = (hash) => {
+
+  if (!hash?.match(/^[0-9a-f]{32}$/i)) {
+    throw new InvalidArgumentError(`Value is not a valid md5 hash`)
+  }
+
+  return hash.toLowerCase()
 }

package/src/utils/hashFunctions.js

@@ -0,0 +1,9 @@
+import {createHash} from 'crypto'
+
+/**
+ * @param {string|Object<toString>} value
+ * @return {string}
+ */
+export const md5 = (value) => {
+  return createHash('md5').update(value.toString()).digest('hex')
+}

package/types/index.d.ts

@@ -32,8 +32,8 @@ export type cliListOption = {
   minLength?: number
   length?: number
   reverse?: boolean
-  minWidth?: number | Array<number|string|boolean>
-  maxWidth?: number | Array<number|string|boolean>
+  minWidth?: number | Array<number | string | boolean>
+  maxWidth?: number | Array<number | string | boolean>
 }
 
 export type profileDump = {}
@@ -53,6 +53,7 @@ export interface AppConfig {
   host: string
   authToken: string
   proxyURL: proxyURL
+  proxyURLs: proxyURL[]
   path: undefined
   origin: string
   denyCidr?: ipCidr[]
@@ -70,6 +71,8 @@ export interface AppConfig {
 
   save(): this
 
+  update(value: { [p: string]: any }): this
+
   useSystem(): AppConfig
 
   use(profile: profileAlias): AppConfig
@@ -113,6 +116,4 @@ export interface keypressEventListener {
 }
 
 
-export type tunliProxyOptions = {
-
-}
+export type tunliProxyOptions = {}