pinggy 0.3.4 → 0.3.6

package/src/remote_management/handler.ts

@@ -1,244 +0,0 @@
-import {
-    ErrorCode,
-    Status,
-    newErrorResponse,
-    ErrorResponse,
-    newStatus,
-    TunnelStateType,
-    TunnelErrorCodeType,
-    newStats,
-    ErrorCodeType,
-    AdditionalForwarding
-} from "../types.js";
-import { DisconnectListener, TunnelManager } from "../tunnel_manager/TunnelManager.js";
-import { pinggyOptionsToTunnelConfig, tunnelConfigToPinggyOptions, TunnelConfig } from "./remote_schema.js";
-import { PinggyOptions, TunnelType, TunnelUsageType } from "@pinggy/pinggy";
-
-export interface TunnelResponse {
-    tunnelid: string;
-    remoteurls: string[];
-    tunnelconfig: TunnelConfig;
-    status: Status;
-    stats: TunnelUsageType;
-}
-
-interface TunnelHandler {
-    handleStart(config: TunnelConfig): Promise<TunnelResponse | ErrorResponse>;
-    handleUpdateConfig(config: TunnelConfig): Promise<TunnelResponse | ErrorResponse>;
-    handleList(): Promise<TunnelResponse[] | ErrorResponse>;
-    handleStop(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
-    handleGet(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
-    handleRestart(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
-    handleRegisterStatsListener(tunnelid: string, listener: (tunnelId: string, stats: TunnelUsageType) => void): void;
-    handleUnregisterStatsListener(tunnelid: string, listnerId: string): void;
-    handleGetTunnelStats(tunnelid: string): TunnelUsageType[] | ErrorResponse;
-    handleRegisterDisconnectListener(tunnelid: string, listener: DisconnectListener): void;
-    handleRemoveStoppedTunnelByTunnelId(tunnelId: string): boolean | ErrorResponse;
-    handleRemoveStoppedTunnelByConfigId(configId: string): boolean | ErrorResponse;
-}
-
-export class TunnelOperations implements TunnelHandler {
-    private tunnelManager: TunnelManager;
-
-    constructor() {
-        this.tunnelManager = TunnelManager.getInstance();  // Use singleton instance
-    }
-
-
-    private buildStatus(tunnelId: string, state: TunnelStateType, errorCode: TunnelErrorCodeType): Status {
-        const status = newStatus(state, errorCode, "");
-        try {
-            const managed = this.tunnelManager.getManagedTunnel("", tunnelId);
-            if (managed) {
-                status.createdtimestamp = managed.createdAt || "";
-                status.starttimestamp = managed.startedAt || "";
-                status.endtimestamp = managed.stoppedAt || "";
-            }
-        } catch (e) {
-            //ignore
-        }
-        return status;
-    }
-
-    // --- Helper to construct TunnelResponse ---
-    private async buildTunnelResponse(tunnelid: string, tunnelConfig: PinggyOptions, configid: string, tunnelName: string, additionalForwarding?: AdditionalForwarding[], serve?: string): Promise<TunnelResponse> {
-        const [status, stats, tlsInfo, greetMsg, remoteurls] = await Promise.all([
-            this.tunnelManager.getTunnelStatus(tunnelid),
-            this.tunnelManager.getLatestTunnelStats(tunnelid) || newStats(),
-            this.tunnelManager.getLocalserverTlsInfo(tunnelid),
-            this.tunnelManager.getTunnelGreetMessage(tunnelid),
-            this.tunnelManager.getTunnelUrls(tunnelid)
-        ]);
-
-        return {
-            tunnelid,
-            remoteurls,
-            tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg as string, additionalForwarding),
-            status: this.buildStatus(tunnelid, status as TunnelStateType, TunnelErrorCodeType.NoError),
-            stats
-        };
-    }
-
-    private error(code: ErrorCodeType, err: unknown, fallback: string): ErrorResponse {
-        return newErrorResponse({
-            code,
-            message: err instanceof Error ? err.message : fallback
-        });
-    }
-
-    // --- Operations ---
-    async handleStart(config: TunnelConfig): Promise<TunnelResponse | ErrorResponse> {
-
-        try {
-            // Convert TunnelConfig -> PinggyOptions
-            const opts = tunnelConfigToPinggyOptions(config);
-            const additionalForwardingParsed = config.additionalForwarding || [];
-            const { tunnelid, instance, tunnelName, additionalForwarding, serve } = await this.tunnelManager.createTunnel({
-                ...opts,
-                tunnelType: Array.isArray(config.type) ? config.type : (config.type ? [config.type] : [TunnelType.Http]),  // Temporary fix in future we will not use this field.
-                configid: config.configid,
-                tunnelName: config.configname,
-                additionalForwarding: additionalForwardingParsed,
-                serve: config.serve
-            });
-
-            this.tunnelManager.startTunnel(tunnelid);
-            const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-            const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName as string, additionalForwarding, serve);
-            return resp;
-        } catch (err) {
-            return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
-        }
-    }
-
-    async handleUpdateConfig(config: TunnelConfig): Promise<TunnelResponse | ErrorResponse> {
-        try {
-            const opts = tunnelConfigToPinggyOptions(config);
-            const tunnel = await this.tunnelManager.updateConfig({
-                ...opts,
-                tunnelType: Array.isArray(config.type) ? config.type : (config.type ? [config.type] : [TunnelType.Http]), // // Temporary fix in future we will not use this field.
-                configid: config.configid,
-                tunnelName: config.configname,
-                additionalForwarding: config.additionalForwarding || [],
-                serve: config.serve
-
-            });
-
-            if (!tunnel.instance || !tunnel.tunnelConfig)
-                throw new Error("Invalid tunnel state after configuration update");
-
-            return this.buildTunnelResponse(tunnel.tunnelid, tunnel.tunnelConfig, config.configid, tunnel.tunnelName as string, tunnel.additionalForwarding, tunnel.serve);
-        } catch (err) {
-            return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
-        }
-    }
-
-    async handleList(): Promise<TunnelResponse[] | ErrorResponse> {
-
-        try {
-            const tunnels = await this.tunnelManager.getAllTunnels();
-            if (tunnels.length === 0) {
-                return [];
-            }
-            return Promise.all(
-                tunnels.map(async (t) => {
-                    const rawStats = this.tunnelManager.getLatestTunnelStats(t.tunnelid) || newStats();
-                    const [status, tlsInfo, greetMsg] = await Promise.all([
-                        this.tunnelManager.getTunnelStatus(t.tunnelid),
-                        this.tunnelManager.getLocalserverTlsInfo(t.tunnelid),
-                        this.tunnelManager.getTunnelGreetMessage(t.tunnelid)
-                    ]);
-                    const pinggyOptions = status !== TunnelStateType.Closed && status !== TunnelStateType.Exited
-                        ? await this.tunnelManager.getTunnelConfig("", t.tunnelid)
-                        : t.tunnelConfig!;
-
-                    const tunnelConfig = pinggyOptionsToTunnelConfig(pinggyOptions, t.configid, t.tunnelName as string, tlsInfo, greetMsg, t.additionalForwarding, t.serve);
-
-                    return {
-                        tunnelid: t.tunnelid,
-                        remoteurls: t.remoteurls,
-                        status: this.buildStatus(t.tunnelid, status as TunnelStateType, TunnelErrorCodeType.NoError),
-                        stats: rawStats,
-                        tunnelconfig: tunnelConfig
-                    };
-                })
-            );
-        } catch (err) {
-            return this.error(ErrorCode.InternalServerError, err, "Failed to list tunnels");
-        }
-    }
-
-    async handleStop(tunnelid: string): Promise<TunnelResponse | ErrorResponse> {
-        try {
-            const { configid } = this.tunnelManager.stopTunnel(tunnelid);
-            const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-            if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-            return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, configid, managed.tunnelName as string, managed.additionalForwarding, managed.serve);
-        } catch (err) {
-            return this.error(ErrorCode.TunnelNotFound, err, "Failed to stop tunnel");
-        }
-    }
-
-    async handleGet(tunnelid: string): Promise<TunnelResponse | ErrorResponse> {
-        try {
-            const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-            if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-            return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName as string, managed.additionalForwarding, managed.serve);
-        } catch (err) {
-            return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
-        }
-    }
-
-    async handleRestart(tunnelid: string): Promise<TunnelResponse | ErrorResponse> {
-        try {
-            await this.tunnelManager.restartTunnel(tunnelid);
-            const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
-            if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
-            return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName as string, managed.additionalForwarding, managed.serve);
-        } catch (err) {
-            return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
-        }
-    }
-    handleRegisterStatsListener(tunnelid: string, listener: (tunnelId: string, stats: TunnelUsageType) => void): void {
-        this.tunnelManager.registerStatsListener(tunnelid, listener);
-    }
-
-    handleUnregisterStatsListener(tunnelid: string, listnerId: string): void {
-        this.tunnelManager.deregisterStatsListener(tunnelid, listnerId);
-    }
-
-    handleGetTunnelStats(tunnelid: string): TunnelUsageType[] | ErrorResponse {
-        try {
-            const stats = this.tunnelManager.getTunnelStats(tunnelid);
-            if (!stats) {
-                // if no stats found, return new stats object
-                return [newStats()];
-            }
-            return stats;
-        } catch (err) {
-            return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel stats");
-        }
-    }
-
-    handleRegisterDisconnectListener(tunnelid: string, listener: DisconnectListener): void {
-        this.tunnelManager.registerDisconnectListener(tunnelid, listener);
-    }
-
-    handleRemoveStoppedTunnelByConfigId(configId: string): boolean | ErrorResponse {
-        try {
-            return this.tunnelManager.removeStoppedTunnelByConfigId(configId);
-        } catch (err) {
-
-            return this.error(ErrorCode.InternalServerError, err, "Failed to remove stopped tunnel by configId");
-        }
-    }
-
-    handleRemoveStoppedTunnelByTunnelId(tunnelId: string): boolean | ErrorResponse {
-        try {
-            return this.tunnelManager.removeStoppedTunnelByTunnelId(tunnelId);
-        } catch (err) {
-
-            return this.error(ErrorCode.InternalServerError, err, "Failed to remove stopped tunnel by tunnelId");
-        }
-    }
-}

package/src/remote_management/remoteManagement.ts

@@ -1,226 +0,0 @@
-import WebSocket from "ws";
-import { logger } from "../logger.js";
-import { handleConnectionStatusMessage, WebSocketCommandHandler, WebSocketRequest } from "./websocket_handlers.js";
-import CLIPrinter from "../utils/printer.js";
-import { RemoteManagementState, RemoteManagementStatus } from "../types.js";
-
-const RECONNECT_SLEEP_MS = 5000; // 5 seconds
-const PING_INTERVAL_MS = 30000; // 30 seconds
-
-type RemoteManagementResult =
-  | { ok: true }
-  | { ok: false; error: unknown };
-
-interface RemoteManagementValues {
-  "remote-management"?: string;
-  "manage"?: string;
-}
-
-let _remoteManagementState: RemoteManagementState = {
-  status: "NOT_RUNNING",
-  errorMessage: "",
-};
-
-let _stopRequested = false;
-let currentWs: WebSocket | null = null;
-
-export function buildRemoteManagementWsUrl(manage?: string): string {
-  let baseUrl = (manage || "dashboard.pinggy.io").trim();
-  if (!(baseUrl.startsWith("ws://") || baseUrl.startsWith("wss://"))) {
-    baseUrl = "wss://" + baseUrl;
-  }
-  // Avoid duplicate slashes when concatenating
-  const trimmed = baseUrl.replace(/\/$/, "");
-  return `${trimmed}/backend/api/v1/remote-management/connect`;
-}
-
-function extractHostname(u: string): string {
-  try {
-    const url = new URL(u);
-    return url.host;
-  } catch {
-    return u;
-  }
-}
-
-function sleep(ms: number) {
-  return new Promise((res) => setTimeout(res, ms));
-}
-
-export async function parseRemoteManagement(values: RemoteManagementValues): Promise<RemoteManagementResult | void> {
-  const rmToken = values["remote-management"];
-  if (typeof rmToken === "string" && rmToken.trim().length > 0) {
-    const manageHost = values["manage"];
-    try {
-      await initiateRemoteManagement(rmToken, manageHost);
-      return { ok: true };
-    } catch (e) {
-      logger.error("Failed to initiate remote management:", e);
-      return { ok: false, error: e };
-    }
-  }
-}
-
-/**
- * Initiate remote management mode with a WebSocket connection.
- * - Connect with Authorization: Bearer <token>
- * - On HTTP 401: print Unauthorized and exit
- * - On other failures: retry every 15 seconds
- * - Keep running until closed or SIGINT
- */
-export async function initiateRemoteManagement(token: string, manage?: string): Promise<RemoteManagementState> {
-
-  if (!token || token.trim().length === 0) {
-    throw new Error("Remote management token is required (use --remote-management <TOKEN>)");
-  }
-
-  const wsUrl = buildRemoteManagementWsUrl(manage);
-  const wsHost = extractHostname(wsUrl);
-
-  logger.info("Remote management mode enabled.");
-
-  // Ensure process exits cleanly on Ctrl+C
-  _stopRequested = false;
-  const sigintHandler = () => { _stopRequested = true; };
-  process.once('SIGINT', sigintHandler);
-
-  const logConnecting = () => {
-    CLIPrinter.print(`Connecting to ${wsHost}`);
-    logger.info("Connecting to remote management", { wsUrl });
-  }
-
-
-  while (!_stopRequested) {
-    logConnecting();
-    setRemoteManagementState({ status: RemoteManagementStatus.Connecting, errorMessage: "" });
-    try {
-      await handleWebSocketConnection(wsUrl, wsHost, token);
-    } catch (error) {
-      logger.warn("Remote management connection error", { error: String(error) });
-
-    }
-    if (_stopRequested) break;
-    CLIPrinter.warn(`Remote management disconnected. Reconnecting in ${RECONNECT_SLEEP_MS / 1000} seconds...`);
-    logger.info("Reconnecting to remote management after disconnect");
-    await sleep(RECONNECT_SLEEP_MS);
-  }
-
-
-  process.removeListener('SIGINT', sigintHandler);
-  logger.info("Remote management stopped.");
-  return getRemoteManagementState();
-}
-
-async function handleWebSocketConnection(wsUrl: string, wsHost: string, token: string): Promise<void> {
-  return new Promise<void>((resolve) => {
-
-    const ws = new WebSocket(wsUrl, {
-      headers: { Authorization: `Bearer ${token}` },
-    });
-    // Tracking the ws for cleanup
-    currentWs = ws;
-
-    let heartbeat: NodeJS.Timeout | null = null;
-    let firstMessage = true;
-
-    /** Safely cleanup on any exit */
-    const cleanup = () => {
-      if (heartbeat) clearInterval(heartbeat);
-      currentWs = null;
-      resolve();
-    };
-
-    ws.once("open", () => {
-      CLIPrinter.success(`Connected to ${wsHost}`);
-
-      heartbeat = setInterval(() => {
-        if (ws.readyState === WebSocket.OPEN) ws.ping();
-      }, PING_INTERVAL_MS);
-    });
-
-    ws.on("ping", () => ws.pong());
-
-    ws.on("message", async (data) => {
-      try {
-        if (firstMessage) {
-          firstMessage = false;
-          const ok = handleConnectionStatusMessage(data);
-          if (!ok) ws.close();
-          return;
-        }
-        setRemoteManagementState({ status: RemoteManagementStatus.Running, errorMessage: "" });
-        const req = JSON.parse(data.toString("utf8")) as WebSocketRequest;
-        await new WebSocketCommandHandler().handle(ws, req);
-      } catch (e) {
-        logger.warn("Failed handling websocket message", { error: String(e) });
-      }
-    });
-
-    ws.on("unexpected-response", (_, res) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: `HTTP ${res.statusCode}` });
-      if (res.statusCode === 401) {
-        CLIPrinter.error("Unauthorized. Please enter a valid token.");
-        logger.error("Unauthorized (401) on remote management connect");
-      } else {
-        CLIPrinter.warn(`Unexpected HTTP ${res.statusCode}. Retrying...`);
-        logger.warn("Unexpected HTTP response", { statusCode: res.statusCode });
-      }
-      ws.close();
-    });
-
-    ws.on("close", (code, reason) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: "" });
-      logger.info("WebSocket closed", { code, reason: reason.toString() });
-      CLIPrinter.warn(`Disconnected (code: ${code}). Retrying...`);
-      cleanup();
-    });
-
-    ws.on("error", (err) => {
-      setRemoteManagementState({ status: RemoteManagementStatus.Error, errorMessage: err.message });
-      logger.warn("WebSocket error", { error: err.message });
-      CLIPrinter.error(err);
-      cleanup();
-    });
-  });
-
-}
-
-export async function closeRemoteManagement(timeoutMs = 10000): Promise<RemoteManagementState> {
-  _stopRequested = true;
-  try {
-    if (currentWs) {
-      try {
-        setRemoteManagementState({ status: RemoteManagementStatus.Disconnecting, errorMessage: "" });
-        currentWs.close();
-      } catch (e) {
-        logger.warn("Error while closing current remote management websocket", { error: String(e) });
-      }
-    }
-
-    const start = Date.now();
-    while (_remoteManagementState.status === "RUNNING") {
-      if (Date.now() - start > timeoutMs) {
-        logger.warn("Timed out waiting for remote management to stop");
-        break;
-      }
-      await sleep(200);
-    }
-  } finally {
-    // Ensure ws ref cleared
-    currentWs = null;
-    setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: "" });
-    return getRemoteManagementState();
-  }
-}
-
-
-export function getRemoteManagementState(): RemoteManagementState {
-  return _remoteManagementState;
-}
-
-function setRemoteManagementState(state: RemoteManagementState, errorMessage?: string) {
-  _remoteManagementState = {
-    status: state.status,
-    errorMessage: errorMessage || "",
-  };
-}

package/src/remote_management/remote_schema.ts

@@ -1,176 +0,0 @@
-import { PinggyOptions, TunnelType } from "@pinggy/pinggy";
-import { z } from "zod";
-import { AdditionalForwarding } from "../types.js";
-
-
-export const HeaderModificationSchema = z.object({
-  key: z.string(),
-  value: z.array(z.string()).optional(),
-  type: z.enum(["add", "remove", "update"]),
-});
-
-export const AdditionalForwardingSchema = z.object({
-  remoteDomain: z.string().optional(),
-  remotePort: z.number().optional(),
-  localDomain: z.string(),
-  localPort: z.number(),
-});
-
-
-// TunnelConfig schema
-export const TunnelConfigSchema = z
-  .object({
-    allowPreflight: z.boolean().optional(),        // primary key
-    allowpreflight: z.boolean().optional(),        // legacy key
-    autoreconnect: z.boolean(),
-    basicauth: z.array(z.object({ username: z.string(), password: z.string() })).nullable(),
-    bearerauth: z.string().nullable(),
-    configid: z.string(),
-    configname: z.string(),
-    greetmsg: z.string().optional(),
-    force: z.boolean(),
-    forwardedhost: z.string(),
-    fullRequestUrl: z.boolean(),
-    headermodification: z.array(HeaderModificationSchema),
-    httpsOnly: z.boolean(),
-    internalwebdebuggerport: z.number(),
-    ipwhitelist: z.array(z.string()).nullable(),
-    localport: z.number(),
-    localsservertls: z.union([z.boolean(), z.string()]),
-    localservertlssni: z.string().nullable(),
-    regioncode: z.string(),
-    noReverseProxy: z.boolean(),
-    serveraddress: z.string(),
-    serverport: z.number(),
-    statusCheckInterval: z.number(),
-    token: z.string(),
-    tunnelTimeout: z.number(),
-    type: z.enum([
-        TunnelType.Http,
-        TunnelType.Tcp,
-        TunnelType.Udp,
-        TunnelType.Tls,
-        TunnelType.TlsTcp
-    ]),
-    webdebuggerport: z.number(),
-    xff: z.string(),
-    additionalForwarding: z.array(AdditionalForwardingSchema).optional(),
-    serve: z.string().optional(),
-  })
-  .superRefine((data, ctx) => {
-    if (data.allowPreflight === undefined && data.allowpreflight === undefined) {
-      ctx.addIssue({
-        code: "custom",
-        message: "Either allowPreflight or allowpreflight is required",
-        path: ["allowPreflight"],
-      });
-    }
-  })
-  .transform((data) => ({
-    ...data,
-    allowPreflight: data.allowPreflight ?? data.allowpreflight,
-    allowpreflight: data.allowPreflight ?? data.allowpreflight,
-  }));
-
-
-/**
- * Schema for the payload used to manage tunnels using websocket.
- *
- * @remarks
- * This schema is intended for input validation (e.g. API request bodies or remote management socket data)
- * and enforces structural and primitive constraints but does not
- * perform side effects.
- */
-
-export const StartSchema = z.object({
-  tunnelID: z.string().nullable().optional(),
-  tunnelConfig: TunnelConfigSchema,
-});
-
-export const StopSchema = z.object({
-  tunnelID: z.string().min(1),
-});
-
-export const GetSchema = StopSchema;
-export const RestartSchema = StopSchema;
-
-export const UpdateConfigSchema = z.object({
-  tunnelConfig: TunnelConfigSchema,
-});
-
-export type TunnelConfig = z.infer<typeof TunnelConfigSchema>;
-
-export function tunnelConfigToPinggyOptions(config: TunnelConfig): PinggyOptions {
-  return {
-    token: config.token || "",
-    serverAddress: config.serveraddress || "free.pinggy.io",
-    forwarding: `${config.forwardedhost || "localhost"}:${config.localport}`,
-    webDebugger: config.webdebuggerport ? `localhost:${config.webdebuggerport}` : "",
-    ipWhitelist: config.ipwhitelist || [],
-    basicAuth: config.basicauth ? config.basicauth : [],
-    bearerTokenAuth: config.bearerauth ? [config.bearerauth] : [],
-    headerModification: config.headermodification,
-    xForwardedFor: !!config.xff,
-    httpsOnly: config.httpsOnly,
-    originalRequestUrl: config.fullRequestUrl,
-    allowPreflight: config.allowPreflight,
-    reverseProxy: config.noReverseProxy,
-    force: config.force,
-    autoReconnect: config.autoreconnect,
-    optional: {
-      sniServerName: config.localservertlssni || "",
-    },
-  };
-}
-
-export function pinggyOptionsToTunnelConfig(opts: PinggyOptions, configid: string, configName: string, localserverTls?: string | boolean, greetMsg?: string | null, additionalForwarding?: AdditionalForwarding[], serve?: string): TunnelConfig {
-
-  const forwarding: string = Array.isArray(opts.forwarding) ? String(opts.forwarding[0].address).replace("//", "").replace(/\/$/, "") : String(opts.forwarding).replace("//", "").replace(/\/$/, "");
-  const parsedForwardedHost = forwarding.split(":").length == 3 ? forwarding.split(":")[1] : forwarding.split(":")[0];
-  const parsedLocalPort = forwarding.split(":").length == 3 ? parseInt(forwarding.split(":")[2], 10) : parseInt(forwarding.split(":")[1], 10);
-
-  const tunnelType =
-    (Array.isArray(opts.forwarding) ? opts.forwarding[0]?.type : undefined) ?? TunnelType.Http;
-
-
-  const parsedTokens: string[] = opts.bearerTokenAuth ? (Array.isArray(opts.bearerTokenAuth)
-    ? opts.bearerTokenAuth : (JSON.parse(opts.bearerTokenAuth) as string[])) : [];
-  return {
-    allowPreflight: opts.allowPreflight ?? false,
-    allowpreflight: opts.allowPreflight ?? false,
-    autoreconnect: opts.autoReconnect ?? false,
-    basicauth: opts.basicAuth && Object.keys(opts.basicAuth).length
-      ? opts.basicAuth
-      : null,
-    bearerauth: parsedTokens.length ? parsedTokens.join(',') : null,
-    configid: configid,
-    configname: configName,
-    greetmsg: greetMsg || "",
-    force: opts.force ?? false,
-    forwardedhost: parsedForwardedHost || "localhost",
-    fullRequestUrl: opts.originalRequestUrl ?? false,
-    headermodification: opts.headerModification || [], //structured list
-    httpsOnly: opts.httpsOnly ?? false,
-    internalwebdebuggerport: 0,
-    ipwhitelist: opts.ipWhitelist
-      ? (Array.isArray(opts.ipWhitelist)
-        ? opts.ipWhitelist
-        : JSON.parse(opts.ipWhitelist) as string[])
-      : null,
-    localport: parsedLocalPort || 0,
-    localservertlssni: null,
-    regioncode: "",
-    noReverseProxy: opts.reverseProxy ?? false,
-    serveraddress: opts.serverAddress || "free.pinggy.io",
-    serverport: 0,
-    statusCheckInterval: 0,
-    token: opts.token || "",
-    tunnelTimeout: 0,
-    type: tunnelType,
-    webdebuggerport: Number(opts.webDebugger?.split(":")[0]) || 0,
-    xff: opts.xForwardedFor ? "1" : "",
-    localsservertls: localserverTls || false,
-    additionalForwarding: additionalForwarding || [],
-    serve: serve || "",
-  };
-}