tunli 0.0.21 → 0.0.22

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.21",
+  "version": "0.0.22",
   "main": "bin/tunli",
   "bin": {
     "tunli": "bin/tunli"

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
@@ -94,9 +95,15 @@ const exec = (configRef, cmd, program) => {
       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)
+    }
   }
 }
 /**

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

@@ -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/types/index.d.ts

@@ -111,3 +111,8 @@ export type keypressEventDetails = {
 export interface keypressEventListener {
   (char: string, details: keypressEventDetails): void
 }
+
+
+export type tunliProxyOptions = {
+
+}