tunli 0.0.19

package/README.md

@@ -0,0 +1,135 @@
+# Tunli
+
+Tunli is a Node.js application that creates HTTP tunnels to make local software projects accessible over the internet.
+This is particularly useful for developing and testing applications that need to be reachable from anywhere.
+
+## Installation
+
+To install Tunli, run the following command:
+
+```bash
+npm install -g tunli
+```
+
+## Usage
+
+Tunli can be used from the command line with various commands and options. Here are some of the key commands:
+
+### Display Help
+
+```bash
+tunli --help
+```
+
+### Configure and View Settings
+
+```bash
+tunli config
+tunli config host localhost
+tunli config port 80
+```
+
+### Create HTTP Tunnel
+
+```bash
+tunli http [PORT] [HOST]
+```
+
+Example:
+
+```bash
+tunli http localhost:80
+```
+
+### Registration and Authentication
+
+To use Tunli, you need to register and authenticate.
+
+#### Register
+
+```bash
+tunli register
+```
+
+#### Authenticate
+
+```bash
+tunli auth <TOKEN>
+```
+
+### Create an Invitation
+
+Generate a shareable registration token:
+
+```bash
+tunli invite
+```
+
+## Examples
+
+Here are some examples of how to use Tunli:
+
+- Set the host for the local configuration:
+
+  ```bash
+  tunli config host localhost
+  ```
+
+- Set the port for the local configuration:
+
+  ```bash
+  tunli config port 80
+  ```
+
+- Show the local configuration:
+
+  ```bash
+  tunli config
+  ```
+
+- Show the global configuration:
+
+  ```bash
+  tunli config --global
+  ```
+
+- Forward HTTP requests to `localhost:80`:
+
+  ```bash
+  tunli http localhost:80
+  ```
+
+- Create a shareable registration token:
+
+  ```bash
+  tunli invite
+  ```
+
+- Register this client with a given token:
+
+  ```bash
+  tunli auth <TOKEN>
+  ```
+
+## Dependencies
+
+Tunli relies on the following packages:
+
+- `axios`: ^1.7.2
+- `blessed`: ^0.1.81
+- `chalk`: ^5.3.0
+- `commander`: ^12.1.0
+- `https-proxy-agent`: ^7.0.4
+- `socket.io-client`: ^4.7.5
+
+## Development
+
+For development purposes, you can start the application using nodemon to automatically restart it on file changes:
+
+```bash
+npm run dev
+```
+
+## License
+
+Tunli is licensed under the GPL-3.0 License.

package/bin/tunli

@@ -0,0 +1,11 @@
+#!/bin/sh
+":" //# comment; exec /usr/bin/env node --harmony "$0" "$@"
+import {proxyChildProcess, setCursorVisibility} from '#src/utils/cliFunctions'
+import {exit} from 'node:process'
+import {resolve} from "path";
+import {dirnameFromMeta} from "#src/core/FS/utils";
+
+setCursorVisibility(false)
+const exitCode = await proxyChildProcess(resolve(dirnameFromMeta(import.meta), '../client.js'))
+setCursorVisibility(true)
+exit(exitCode)

package/client.js

@@ -0,0 +1,31 @@
+import {dirnameFromMeta, readJsonFile, searchFileInDirectoryTree} from "#src/core/FS/utils";
+import {program} from 'commander';
+import {createCommandHTTP} from "#commands/CommandHTTP";
+import {createCommandAuth} from "#commands/CommandAuth";
+import {createCommandConfig} from "#commands/CommandConfig";
+import {createCommandRegister} from "#commands/CommandRegister";
+import {createCommandRefresh} from "#commands/CommandRefresh";
+import {argumentAliasResolver} from "#commands/helper/AliasResolver";
+import {createCommandInvite} from "#commands/CommandInvite";
+import {addExamples, addUsage} from "#commands/utils";
+
+program
+  .name('tunli')
+  .description('HTTP tunnel client')
+  .option('-v, --version', 'version', () => {
+    const packageJson = readJsonFile(searchFileInDirectoryTree('package.json', dirnameFromMeta(import.meta)))
+    console.log(`tunli: ${packageJson.version}`)
+    process.exit()
+  })
+
+program.addCommand(createCommandConfig(program))
+program.addCommand(createCommandHTTP(program), {isDefault: true})
+program.addCommand(createCommandRegister(program))
+program.addCommand(createCommandRefresh(program))
+program.addCommand(createCommandInvite(program))
+program.addCommand(createCommandAuth(program))
+
+addExamples(program)
+addUsage(program)
+
+await program.parseAsync(argumentAliasResolver());

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "tunli",
+  "description": "Node.js application for creating HTTP tunnels to make local software projects accessible over the internet.",
+  "version": "0.0.19",
+  "main": "bin/tunli",
+  "bin": {
+    "tunli": "bin/tunli"
+  },
+  "scripts": {
+    "dev": "nodemon client.js"
+  },
+  "keywords": [
+    "HTTP tunnel",
+    "reverse proxy",
+    "remote access",
+    "local development",
+    "Node.js"
+  ],
+  "author": "Pascal Pfeifer <pascal@tunli.app>",
+  "imports": {
+    "#lib/*": "./src/lib/*.js",
+    "#commands/*": "./src/commands/*.js",
+    "#src/*": "./src/*.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "axios": "^1.7.2",
+    "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": {
+    "nodemon": "^3.1.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tunlijs/tunli-client"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "homepage": "https://tunli.app",
+  "bugs": {
+    "email": "dev@tunli.app",
+    "url": "https://github.com/tunlijs/tunli-client/issues"
+  },
+  "license": "GPL-3.0",
+  "readme": "README.md"
+}

package/src/cli-app/Dashboard.js

@@ -0,0 +1,146 @@
+import {concat, createScreen} from "#src/cli-app/helper/utils";
+import {dirnameFromMeta, readJsonFile, searchFileInDirectoryTree} from "#src/core/FS/utils";
+import {ref} from "#src/core/Ref";
+import {trimEnd} from "#src/utils/stringFunctions";
+import chalk from "chalk";
+import {getLatestVersion} from "#lib/Flow/getLatestVersion";
+import {exec} from 'child_process'
+import {checkGlobalInstallation, checkLocalInstallation} from "#src/utils/npmFunctions";
+
+/**
+ *
+ * @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
+}

package/src/cli-app/Screen.js

@@ -0,0 +1,135 @@
+import {List} from "#src/cli-app/elements/List/List";
+import EventEmitter from "node:events";
+import {Row} from "#src/cli-app/elements/Row";
+import {ElementNode} from "#src/cli-app/elements/ElementNode";
+import {arrayRemoveEntry} from "#src/utils/arrayFunctions";
+import {Line} from "#src/cli-app/elements/Line";
+
+export class Screen extends EventEmitter {
+
+  #screen
+
+  /**
+   * @type {ElementNode[]}
+   */
+  #elements = []
+
+  constructor(screen) {
+    super()
+    this.#screen = screen
+
+    for (const proxyFn of ['append']) {
+      this[proxyFn] = (...arg) => {
+        screen[proxyFn](...arg)
+      }
+    }
+
+    const ele = new ElementNode(this)
+    ele._cached.height = ele.height
+    ele._cached.top = ele.positionTop
+    this.#elements.push(ele)
+
+    this.on('delete-element', (ele) => {
+      this.#elements = arrayRemoveEntry(this.#elements, ele)
+    })
+
+    screen.on('keypress', (char, details) => this.emit('keypress', char, /** keypressEventDetails */ details))
+  }
+
+  get screen() {
+    return this.#screen
+  }
+
+  get children() {
+    return this.#elements
+  }
+
+  get width() {
+    return this.#screen.width
+  }
+
+  get height() {
+    return this.#screen.height
+  }
+
+  /**
+   * @param {string|array} key
+   * @param {keypressEventListener} callback
+   */
+  key(key, callback) {
+    this.#screen.key(key, callback)
+  }
+
+  /**
+   * @param {string|array} key
+   * @param {keypressEventListener} callback
+   */
+  onceKey(key, callback) {
+    this.#screen.onceKey(key, callback)
+  }
+
+  render() {
+    this.#screen.render()
+  }
+
+  destroy() {
+    this.#screen.destroy()
+  }
+
+  /**
+   *
+   * @param {ElementNode} ele
+   */
+  updateElement(ele) {
+
+    const heightChanged = ele._cached.height === ele.height
+    const topChanged = ele._cached.top === ele.positionTop
+
+    ele._cached.height = ele.height
+    ele._cached.top = ele.positionTop
+
+    if (heightChanged || topChanged) {
+      ele.nextElementSibling?.emit('prev-resize', ele)
+    }
+  }
+
+  /**
+   * @param {...cliListOption} [options]
+   * @returns {List}
+   */
+  list(options) {
+    const ele = new List(this)
+    ele.init(options)
+
+    ele._cached.height = ele.height
+    ele._cached.top = ele.positionTop
+
+    this.#elements.push(ele)
+    return ele
+  }
+
+  /**
+   * @param content
+   * @param [top]
+   * @param [right]
+   * @returns {Row}
+   */
+  row(content, {top, right} = {}) {
+    const ele = new Row(this)
+    ele.init(content, {top, right})
+    ele._cached.height = ele.height
+    ele._cached.top = ele.positionTop
+
+    this.#elements.push(ele)
+    return ele
+  }
+
+  line() {
+    const ele = new Line(this)
+    ele.init()
+    ele._cached.height = ele.height
+    ele._cached.top = ele.positionTop
+    this.#elements.push(ele)
+    return ele
+  }
+}

package/src/cli-app/elements/ElementNode.js

@@ -0,0 +1,97 @@
+import EventEmitter from "node:events";
+
+export class ElementNode extends EventEmitter {
+
+  _cached = {
+    top: null,
+    height: null
+  }
+
+  /**
+   * @type {ElementNode}
+   */
+  #nextElementSibling
+  /**
+   * @type {ElementNode}
+   */
+  #prevElementSibling
+  /**
+   * @type {Screen}
+   */
+  #screen
+  #height = 0
+
+
+  #detached = false
+  #offsetTop = 0;
+
+  /**
+   * @param {Screen} screen
+   */
+  constructor(screen) {
+    super()
+    this.#screen = screen
+
+    if (screen.children.length) {
+      const before = screen.children[screen.children.length - 1]
+      before.#nextElementSibling = this
+      this.#prevElementSibling = before
+    }
+
+    /**
+     * prev element postop and height
+     */
+    this.on('prev-resize', ({positionTop, height}) => {
+      this.emit('position-top', positionTop + height)
+      this.nextElementSibling?.emit('prev-resize', this)
+    })
+  }
+
+  get detached() {
+    return this.#detached
+  }
+
+  get nextElementSibling() {
+    return this.#nextElementSibling
+  }
+
+  get positionTop() {
+    if (this.#prevElementSibling) {
+      return this.#prevElementSibling.positionTop + this.#prevElementSibling.height + this.#offsetTop
+    }
+    return this.#offsetTop
+  }
+
+  set offsetTop(offsetTop) {
+    this.#offsetTop = offsetTop ?? 0
+  }
+
+  get screen() {
+    return this.#screen
+  }
+
+  get height() {
+    return this.#height
+  }
+
+  set height(height) {
+    const update = this.#height !== height
+    this.#height = height
+    if (update) {
+      this.emit('height', height)
+    }
+  }
+
+  delete() {
+
+    this.#screen.emit('delete-element', this)
+    this.emit('delete', this)
+    this.#detached = true
+    const next = this.#nextElementSibling
+
+    if (next) {
+      next.#prevElementSibling = this.#prevElementSibling
+      this.#nextElementSibling?.emit('prev-resize', this.#prevElementSibling)
+    }
+  }
+}

package/src/cli-app/elements/Line.js

@@ -0,0 +1,21 @@
+import {ElementNode} from "#src/cli-app/elements/ElementNode";
+import blessed from "blessed";
+
+export class Line extends ElementNode {
+
+  /**
+   * @param {("horizontal", "vertical")} orientation
+   */
+  init(orientation = 'horizontal') {
+
+    const line = blessed.line({
+      orientation
+    })
+
+    this.height = 1
+    this.on('position-top', (val) => line.top = val)
+    this.on('height', (val) => line.height = val)
+    this.on('delete', (val) => line.detach())
+    this.screen.append(line)
+  }
+}