pinggy 0.3.8 → 0.3.9

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { PinggyOptions, TunnelUsageType, TunnelInstance, TunnelType } from '@pinggy/pinggy';
+import { TunnelConfigurationV1, TunnelUsageType, TunnelInstance, TunnelType, RemoteManagementConfig } from '@pinggy/pinggy';
 import { Worker } from 'node:worker_threads';
 import { z } from 'zod';
 import winston from 'winston';
@@ -14,7 +14,7 @@ interface AdditionalForwarding {
 interface TunnelStatus {
     tunnelid: string;
     remoteurls: string[];
-    tunnelconfig: PinggyOptions;
+    tunnelconfig: TunnelConfigurationV1;
     status: Status;
     stats: TunnelUsageType;
 }
@@ -50,19 +50,9 @@ interface Status {
     endtimestamp: string;
     warnings: Warning[];
 }
-type FinalConfig = (PinggyOptions & {
-    configid: string;
-}) & {
-    tunnelType: string[];
+type FinalConfig = (TunnelConfigurationV1) & {
     conf?: string;
     saveconf?: string;
-    serve?: string;
-    remoteManagement?: string;
-    additionalForwarding?: AdditionalForwarding[];
-    manage?: string;
-    version?: boolean;
-    NoTUI?: boolean;
-    qrCode?: boolean;
 };
 type ErrorCodeType = "INVALID_REQUEST_METHOD" | "COULD_NOT_READ_BODY" | "INTERNAL_SERVER_ERROR" | "INVALID_DATA_FORMAT" | "ERROR_STARTING_TUNNEL" | "TUNNEL_WITH_ID_OR_CONFIG_ID_NOT_FOUND" | "TUNNEL_WITH_ID_OR_CONFIG_ID_ALREADY_RUNNING" | "WEBSOCKET_UPGRADE_FAILED" | "REMOTE_MANAGEMENT_ALREADY_RUNNING" | "REMOTE_MANAGEMENT_NOT_RUNNING" | "REMOTE_MANAGEMENT_DESERIALIZATION_FAILED";
 interface ErrorResponse {
@@ -93,12 +83,10 @@ interface RemoteManagementState {
 
 interface ManagedTunnel {
     tunnelid: string;
-    configid: string;
+    configId: string;
     tunnelName?: string;
     instance: TunnelInstance;
-    tunnelConfig?: PinggyOptions;
-    configWithForwarding?: PinggyOptions;
-    additionalForwarding?: AdditionalForwarding[];
+    tunnelConfig?: TunnelConfigurationV1;
     serveWorker?: Worker | null;
     warnings?: Warning[];
     serve?: string;
@@ -110,15 +98,24 @@ interface ManagedTunnel {
 }
 interface TunnelList {
     tunnelid: string;
-    configid: string;
+    configId: string;
     tunnelName?: string;
-    tunnelConfig: PinggyOptions;
+    tunnelConfig: TunnelConfigurationV1;
     remoteurls: string[];
-    additionalForwarding?: AdditionalForwarding[];
+    serve?: string;
+}
+interface TunnelCreationConfig extends TunnelConfigurationV1 {
+    tunnelid?: string;
+    tunnelName?: string;
+    serve?: string;
+}
+interface TunnelUpdateConfig extends TunnelConfigurationV1 {
+    tunnelName?: string;
     serve?: string;
 }
 type StatsListener = (tunnelId: string, stats: TunnelUsageType) => void;
 type ErrorListener = (tunnelId: string, errorMsg: string, isFatal: boolean) => void;
+type PollingErrorListener = (tunnelId: string, errorMsg: string) => void;
 type DisconnectListener = (tunnelId: string, error: string, messages: string[]) => void;
 type TunnelWorkerErrorListner = (tunnelid: string, error: Error) => void;
 type StartListener = (tunnelId: string, urls: string[]) => void;
@@ -127,16 +124,10 @@ type ReconnectingListener = (tunnelId: string, retryCnt: number) => void;
 type ReconnectionCompletedListener = (tunnelId: string, urls: string[]) => void;
 type ReconnectionFailedListener = (tunnelId: string, retryCnt: number) => void;
 interface ITunnelManager {
-    createTunnel(config: (PinggyOptions & {
-        configid: string;
-        tunnelid?: string;
-        tunnelName?: string;
-    }) & {
-        additionalForwarding?: AdditionalForwarding[];
-    }): Promise<ManagedTunnel>;
+    createTunnel(config: TunnelCreationConfig, buildConfig?: boolean): Promise<ManagedTunnel>;
     startTunnel(tunnelId: string): Promise<string[]>;
     stopTunnel(tunnelId: string): {
-        configid: string;
+        configId: string;
         tunnelid: string;
     };
     stopAllTunnels(): void;
@@ -144,22 +135,20 @@ interface ITunnelManager {
     getAllTunnels(): Promise<TunnelList[]>;
     getTunnelStatus(tunnelId: string): Promise<string>;
     getTunnelInstance(configId?: string, tunnelId?: string): TunnelInstance;
-    getTunnelConfig(configId?: string, tunnelId?: string): Promise<PinggyOptions>;
+    getTunnelConfig(configId?: string, tunnelId?: string): Promise<TunnelConfigurationV1>;
     restartTunnel(tunnelId: string): Promise<void>;
-    updateConfig(newConfig: PinggyOptions & {
-        configid: string;
-        additionalForwarding?: AdditionalForwarding[];
-        tunnelName?: string;
-    }): Promise<ManagedTunnel>;
+    updateConfig(newConfig: TunnelUpdateConfig, buildConfig: boolean): Promise<ManagedTunnel>;
     getManagedTunnel(configId?: string, tunnelId?: string): ManagedTunnel;
     getTunnelGreetMessage(tunnelId: string): Promise<string | null>;
     getTunnelStats(tunnelId: string): TunnelUsageType[] | null;
     getLatestTunnelStats(tunnelId: string): TunnelUsageType | null;
     registerStatsListener(tunnelId: string, listener: StatsListener): Promise<[string, string]>;
     registerErrorListener(tunnelId: string, listener: ErrorListener): Promise<string>;
+    registerPollingErrorListener(tunnelId: string, listener: PollingErrorListener): Promise<string>;
     registerWorkerErrorListner(tunnelId: string, listener: TunnelWorkerErrorListner): void;
     registerStartListener(tunnelId: string, listener: StartListener): Promise<string>;
     deregisterErrorListener(tunnelId: string, listenerId: string): void;
+    deregisterPollingErrorListener(tunnelId: string, listenerId: string): void;
     registerDisconnectListener(tunnelId: string, listener: DisconnectListener): Promise<string>;
     deregisterDisconnectListener(tunnelId: string, listenerId: string): void;
     deregisterStatsListener(tunnelId: string, listenerId: string): void;
@@ -182,6 +171,7 @@ declare class TunnelManager implements ITunnelManager {
     private tunnelStats;
     private tunnelStatsListeners;
     private tunnelErrorListeners;
+    private tunnelPollingErrorListeners;
     private tunnelDisconnectListeners;
     private tunnelWorkerErrorListeners;
     private tunnelStartListeners;
@@ -193,12 +183,9 @@ declare class TunnelManager implements ITunnelManager {
     static getInstance(): TunnelManager;
     /**
      * Creates a new managed tunnel instance with the given configuration.
-     * Builds the config with forwarding rules and creates the tunnel instance.
+     * Optionally builds the config with forwarding rules based on buildConfig flag.
      *
      * @param config - The tunnel configuration options
-     * @param config.configid - Unique identifier for the tunnel configuration
-     * @param config.tunnelid - Optional custom tunnel identifier. If not provided, a random UUID will be generated
-     * @param config.additionalForwarding - Optional array of additional forwarding configurations
      *
      * @throws {Error} When configId is invalid or empty
      * @throws {Error} When a tunnel with the given configId already exists
@@ -206,17 +193,7 @@ declare class TunnelManager implements ITunnelManager {
      * @returns {ManagedTunnel} A new managed tunnel instance containing the tunnel details,
      *                          status information, and statistics
      */
-    createTunnel(config: (PinggyOptions & {
-        tunnelType: string[] | undefined;
-    } & {
-        configid: string;
-        tunnelid?: string;
-        tunnelName?: string;
-    }) & {
-        additionalForwarding?: AdditionalForwarding[];
-    } & {
-        serve?: string;
-    }): Promise<ManagedTunnel>;
+    createTunnel(config: TunnelCreationConfig): Promise<ManagedTunnel>;
     /**
      * Internal method to create a tunnel with an already-processed configuration.
      * This is used by createTunnel, restartTunnel, and updateConfig to avoid config processing.
@@ -226,15 +203,6 @@ declare class TunnelManager implements ITunnelManager {
      * @private
      */
     private _createTunnelWithProcessedConfig;
-    /**
-     * Builds the Pinggy configuration by merging the default forwarding rule
-     * with additional forwarding rules from additionalForwarding array.
-     *
-     * @param config - The base Pinggy configuration
-     * @param additionalForwarding - Optional array of additional forwarding rules
-     * @returns Modified PinggyOptions
-     */
-    private buildPinggyConfig;
     /**
      * Start a tunnel that was created but not yet started
      */
@@ -250,7 +218,7 @@ declare class TunnelManager implements ITunnelManager {
      * - Logs the stop operation with tunnelId and configId
      */
     stopTunnel(tunnelId: string): {
-        configid: string;
+        configId: string;
         tunnelid: string;
     };
     /**
@@ -300,7 +268,7 @@ declare class TunnelManager implements ITunnelManager {
      * @returns The tunnel config
      * @throws Error if neither configId nor tunnelId is provided, or if tunnel is not found
      */
-    getTunnelConfig(configId?: string, tunnelId?: string): Promise<PinggyOptions>;
+    getTunnelConfig(configId?: string, tunnelId?: string): Promise<TunnelConfigurationV1>;
     /**
      * Restarts a tunnel with its current configuration.
      * This function will stop the tunnel if it's running and start it again.
@@ -319,14 +287,7 @@ declare class TunnelManager implements ITunnelManager {
      * @returns Promise resolving to the updated ManagedTunnel
      * @throws Error if the tunnel is not found or if the update process fails
      */
-    updateConfig(newConfig: PinggyOptions & {
-        tunnelType: string[] | undefined;
-    } & {
-        configid: string;
-        additionalForwarding?: AdditionalForwarding[];
-        tunnelName?: string;
-        serve?: string;
-    }): Promise<ManagedTunnel>;
+    updateConfig(newConfig: TunnelUpdateConfig): Promise<ManagedTunnel>;
     /**
      * Retrieve the ManagedTunnel object by either configId or tunnelId.
      * Throws an error if neither id is provided or the tunnel is not found.
@@ -347,6 +308,7 @@ declare class TunnelManager implements ITunnelManager {
      */
     registerStatsListener(tunnelId: string, listener: StatsListener): Promise<[string, string]>;
     registerErrorListener(tunnelId: string, listener: ErrorListener): Promise<string>;
+    registerPollingErrorListener(tunnelId: string, listener: PollingErrorListener): Promise<string>;
     registerDisconnectListener(tunnelId: string, listener: DisconnectListener): Promise<string>;
     registerWorkerErrorListner(tunnelId: string, listener: TunnelWorkerErrorListner): Promise<void>;
     registerStartListener(tunnelId: string, listener: StartListener): Promise<string>;
@@ -362,6 +324,7 @@ declare class TunnelManager implements ITunnelManager {
     */
     deregisterStatsListener(tunnelId: string, listenerId: string): void;
     deregisterErrorListener(tunnelId: string, listenerId: string): void;
+    deregisterPollingErrorListener(tunnelId: string, listenerId: string): void;
     deregisterDisconnectListener(tunnelId: string, listenerId: string): void;
     deregisterWillReconnectListener(tunnelId: string, listenerId: string): void;
     deregisterReconnectingListener(tunnelId: string, listenerId: string): void;
@@ -373,6 +336,8 @@ declare class TunnelManager implements ITunnelManager {
      * This callback will update stored stats and notify all registered listeners.
      */
     private setupStatsCallback;
+    private setupTunnelPollingErrorCallback;
+    private notifyPollingErrorListeners;
     private notifyErrorListeners;
     private setupErrorCallback;
     private setupDisconnectCallback;
@@ -417,7 +382,7 @@ declare const TunnelConfigSchema: z.ZodPipe<z.ZodObject<{
         username: z.ZodString;
         password: z.ZodString;
     }, z.core.$strip>>>;
-    bearerauth: z.ZodNullable<z.ZodString>;
+    bearerauth: z.ZodNullable<z.ZodArray<z.ZodString>>;
     configid: z.ZodString;
     configname: z.ZodString;
     greetmsg: z.ZodOptional<z.ZodString>;
@@ -426,7 +391,7 @@ declare const TunnelConfigSchema: z.ZodPipe<z.ZodObject<{
     fullRequestUrl: z.ZodBoolean;
     headermodification: z.ZodArray<z.ZodObject<{
         key: z.ZodString;
-        value: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        value: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
         type: z.ZodEnum<{
             add: "add";
             remove: "remove";
@@ -470,7 +435,7 @@ declare const TunnelConfigSchema: z.ZodPipe<z.ZodObject<{
         username: string;
         password: string;
     }[] | null;
-    bearerauth: string | null;
+    bearerauth: string[] | null;
     configid: string;
     configname: string;
     force: boolean;
@@ -479,7 +444,7 @@ declare const TunnelConfigSchema: z.ZodPipe<z.ZodObject<{
     headermodification: {
         key: string;
         type: "add" | "remove" | "update";
-        value?: string[] | undefined;
+        value?: string[] | null | undefined;
     }[];
     httpsOnly: boolean;
     internalwebdebuggerport: number;
@@ -511,7 +476,7 @@ declare const TunnelConfigSchema: z.ZodPipe<z.ZodObject<{
         username: string;
         password: string;
     }[] | null;
-    bearerauth: string | null;
+    bearerauth: string[] | null;
     configid: string;
     configname: string;
     force: boolean;
@@ -520,7 +485,7 @@ declare const TunnelConfigSchema: z.ZodPipe<z.ZodObject<{
     headermodification: {
         key: string;
         type: "add" | "remove" | "update";
-        value?: string[] | undefined;
+        value?: string[] | null | undefined;
     }[];
     httpsOnly: boolean;
     internalwebdebuggerport: number;
@@ -550,6 +515,56 @@ declare const TunnelConfigSchema: z.ZodPipe<z.ZodObject<{
     serve?: string | undefined;
 }>>;
 type TunnelConfig = z.infer<typeof TunnelConfigSchema>;
+/**
+ * V1 Tunnel Config Schema
+ */
+declare const TunnelConfigV1Schema: z.ZodObject<{
+    version: z.ZodString;
+    name: z.ZodString;
+    configId: z.ZodString;
+    serverAddress: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    autoReconnect: z.ZodOptional<z.ZodBoolean>;
+    reconnectInterval: z.ZodOptional<z.ZodNumber>;
+    maxReconnectAttempts: z.ZodOptional<z.ZodNumber>;
+    force: z.ZodBoolean;
+    keepAliveInterval: z.ZodOptional<z.ZodNumber>;
+    webDebugger: z.ZodString;
+    forwarding: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        listenAddress: z.ZodOptional<z.ZodString>;
+        address: z.ZodString;
+        type: z.ZodOptional<z.ZodEnum<{
+            http: TunnelType.Http;
+            tcp: TunnelType.Tcp;
+            tls: TunnelType.Tls;
+            udp: TunnelType.Udp;
+            tlstcp: TunnelType.TlsTcp;
+        }>>;
+    }, z.core.$strip>>]>;
+    ipWhitelist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    basicAuth: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        username: z.ZodString;
+        password: z.ZodString;
+    }, z.core.$strip>>>;
+    bearerTokenAuth: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    headerModification: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        type: z.ZodEnum<{
+            add: "add";
+            remove: "remove";
+            update: "update";
+        }>;
+    }, z.core.$strip>>>;
+    reverseProxy: z.ZodOptional<z.ZodBoolean>;
+    xForwardedFor: z.ZodOptional<z.ZodBoolean>;
+    httpsOnly: z.ZodOptional<z.ZodBoolean>;
+    originalRequestUrl: z.ZodOptional<z.ZodBoolean>;
+    allowPreflight: z.ZodOptional<z.ZodBoolean>;
+    serve: z.ZodOptional<z.ZodString>;
+    optional: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type TunnelConfigV1 = z.infer<typeof TunnelConfigV1Schema>;
 
 interface TunnelResponse {
     tunnelid: string;
@@ -558,10 +573,21 @@ interface TunnelResponse {
     status: Status;
     stats: TunnelUsageType;
 }
+interface TunnelResponseV2 {
+    tunnelid: string;
+    remoteurls: string[];
+    tunnelconfig: TunnelConfigV1;
+    status: Status;
+    stats: TunnelUsageType;
+    greetmsg?: string;
+}
 interface TunnelHandler {
     handleStart(config: TunnelConfig): Promise<TunnelResponse | ErrorResponse>;
+    handleStartV2(config: TunnelConfigV1): Promise<TunnelResponseV2 | ErrorResponse>;
     handleUpdateConfig(config: TunnelConfig): Promise<TunnelResponse | ErrorResponse>;
+    handleUpdateConfigV2(config: TunnelConfigV1): Promise<TunnelResponseV2 | ErrorResponse>;
     handleList(): Promise<TunnelResponse[] | ErrorResponse>;
+    handleListV2(): Promise<TunnelResponseV2[] | ErrorResponse>;
     handleStop(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
     handleGet(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
     handleRestart(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
@@ -577,9 +603,13 @@ declare class TunnelOperations implements TunnelHandler {
     constructor();
     private buildStatus;
     private buildTunnelResponse;
+    private buildTunnelResponseV2;
     private error;
     handleStart(config: TunnelConfig): Promise<TunnelResponse | ErrorResponse>;
+    handleStartV2(config: TunnelConfigV1): Promise<TunnelResponseV2 | ErrorResponse>;
     handleUpdateConfig(config: TunnelConfig): Promise<TunnelResponse | ErrorResponse>;
+    handleUpdateConfigV2(config: TunnelConfigV1): Promise<TunnelResponseV2 | ErrorResponse>;
+    handleListV2(): Promise<TunnelResponseV2[] | ErrorResponse>;
     handleList(): Promise<TunnelResponse[] | ErrorResponse>;
     handleStop(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
     handleGet(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
@@ -610,7 +640,7 @@ declare function enablePackageLogging(opts?: BaseLogConfigType): winston.Logger;
  * - On other failures: retry every 15 seconds
  * - Keep running until closed or SIGINT
  */
-declare function initiateRemoteManagement(token: string, manage?: string): Promise<RemoteManagementState>;
+declare function initiateRemoteManagement(remoteManagementConfig: RemoteManagementConfig): Promise<RemoteManagementState>;
 declare function closeRemoteManagement(timeoutMs?: number): Promise<RemoteManagementState>;
 declare function getRemoteManagementState(): RemoteManagementState;
 

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   getRemoteManagementState,
   initiateRemoteManagement,
   printer_default
-} from "./chunk-65R2GMKQ.js";
+} from "./chunk-JD3U36U5.js";
 import {
   enablePackageLogging
 } from "./chunk-HUN2MRZO.js";
@@ -104,7 +104,7 @@ async function verifyAndLoad() {
       process.exit(1);
     }
   }
-  await import("./main-2QDG7PWL.js");
+  await import("./main-VIBOPJ64.js");
 }
 verifyAndLoad().catch((err) => {
   printer_default.error(`Failed to start CLI:, ${err}`);

package/dist/{main-2QDG7PWL.js → main-VIBOPJ64.js}

@@ -10,7 +10,7 @@ import {
   isValidPort,
   parseRemoteManagement,
   printer_default
-} from "./chunk-65R2GMKQ.js";
+} from "./chunk-JD3U36U5.js";
 import {
   configureLogger,
   enablePackageLogging,
@@ -36,6 +36,7 @@ var cliOptions = {
   localport: { type: "string", short: "l", description: "Takes input as [protocol:][host:]port. Eg. --localport https://localhost:8000 OR -l 3000" },
   debugger: { type: "string", short: "d", description: "Port for web debugger. Eg. --debugger 4300 OR -d 4300" },
   token: { type: "string", description: "Token for authentication. Eg. --token TOKEN_VALUE" },
+  force: { type: "boolean", short: "f", description: "Forcefully close existing tunnels and establish a new tunnel" },
   // Logging options (CLI overrides env)
   loglevel: { type: "string", description: "Logging level: ERROR, INFO, DEBUG. Overrides PINGGY_LOG_LEVEL environment variable" },
   logfile: { type: "string", description: "Path to log file. Overrides PINGGY_LOG_FILE environment variable" },
@@ -51,7 +52,8 @@ var cliOptions = {
   // Remote Control
   "remote-management": { type: "string", description: "Enable remote management of tunnels with token. Eg. --remote-management API_KEY" },
   manage: { type: "string", description: "Provide a server address to manage tunnels. Eg --manage dashboard.pinggy.io" },
-  notui: { type: "boolean", description: "Disable TUI in remote management mode" },
+  noTui: { type: "boolean", description: "Disable TUI in remote management mode" },
+  notui: { type: "boolean", description: "hidden", hidden: true },
   // Misc
   version: { type: "boolean", description: "Print version" },
   // Help
@@ -117,8 +119,8 @@ var defaultOptions = {
 
 // src/cli/extendedOptions.ts
 import { isIP } from "net";
-function parseExtendedOptions(options, config) {
-  if (!options) return;
+function parseExtendedOptions(options, config, localServerTls) {
+  if (!options) return localServerTls;
   for (const opt of options) {
     const [key, value] = opt.replace(/^"|"$/g, "").split(/:(.+)/).filter(Boolean);
     switch (key) {
@@ -142,10 +144,16 @@ function parseExtendedOptions(options, config) {
           case "fullrequesturl":
             config.originalRequestUrl = true;
             break;
-          default:
-            printer_default.warn(`Unknown extended option "${key}"`);
-            logger.warn(`Warning: Unknown extended option "${key}"`);
+          default: {
+            if (value && (value.startsWith("localServerTls") || value.startsWith("localservertls"))) {
+              const parts = value.split(/:(.+)/);
+              localServerTls = parts[1] ? parts[1] : "";
+            } else {
+              printer_default.warn(`Unknown extended option "${value}"`);
+              logger.warn(`Warning: Unknown extended option "${value}"`);
+            }
             break;
+          }
         }
         break;
       case "w":
@@ -216,6 +224,7 @@ function parseExtendedOptions(options, config) {
         break;
     }
   }
+  return localServerTls;
 }
 function isValidIpV4Cidr(input) {
   if (input.includes("/")) {
@@ -338,9 +347,9 @@ function parseUsers(positionalArgs, explicitToken) {
   return { token, server, type, forceFlag, qrCode, remaining };
 }
 function parseType(finalConfig, values, inferredType) {
-  const t = inferredType || values.type || finalConfig.tunnelType;
+  const t = inferredType || values.type;
   if (t === TunnelType.Http || t === TunnelType.Tcp || t === TunnelType.Tls || t === TunnelType.Udp || t === TunnelType.TlsTcp) {
-    finalConfig.tunnelType = [t];
+    return t;
   }
 }
 function parseLocalPort(finalConfig, values) {
@@ -475,15 +484,14 @@ function parseAdditionalForwarding(forwarding) {
     return new Error("forwarding address incorrect: invalid local port");
   }
   return {
-    protocol,
-    remoteDomain: remoteDomainRaw,
-    remotePort,
-    localDomain,
-    localPort
+    type: protocol,
+    listenAddress: `${remoteDomainRaw}:${remotePort}`,
+    address: `${localDomain}:${localPort}`
   };
 }
-function parseReverseTunnelAddr(finalConfig, values) {
+function parseReverseTunnelAddr(finalConfig, values, primaryType) {
   const reverseTunnel = values.R;
+  let forwardingData = [];
   if ((!Array.isArray(reverseTunnel) || reverseTunnel.length === 0) && !values.localport && !finalConfig.forwarding) {
     return new Error("local port not specified. Please use '-h' option for help.");
   }
@@ -495,18 +503,21 @@ function parseReverseTunnelAddr(finalConfig, values) {
     if (slicedForwarding.length === 3) {
       const parsed = parseDefaultForwarding(forwarding);
       if (parsed instanceof Error) return parsed;
-      finalConfig.forwarding = `${parsed.localDomain}:${parsed.localPort}`;
+      forwardingData.push({
+        address: `${parsed.localDomain}:${parsed.localPort}`,
+        type: primaryType || TunnelType.Http
+      });
     } else if (slicedForwarding.length === 4) {
-      finalConfig.additionalForwarding ?? (finalConfig.additionalForwarding = []);
       const parsed = parseAdditionalForwarding(forwarding);
       if (parsed instanceof Error) return parsed;
-      finalConfig.additionalForwarding.push(parsed);
+      forwardingData.push(parsed);
     } else {
       return new Error(
         "Incorrect command line arguments: reverse tunnel address incorrect. Please use '-h' option for help."
       );
     }
   }
+  finalConfig.forwarding = forwardingData;
   return null;
 }
 function parseLocalTunnelAddr(finalConfig, values) {
@@ -542,7 +553,13 @@ function parseToken(finalConfig, explicitToken) {
   }
 }
 function parseArgs(finalConfig, remainingPositionals) {
-  parseExtendedOptions(remainingPositionals, finalConfig);
+  let localserverTls = "";
+  localserverTls = parseExtendedOptions(remainingPositionals, finalConfig, localserverTls);
+  if (localserverTls.length > 0 && finalConfig.forwarding) {
+    if (typeof finalConfig.forwarding[0] === "object" && "address" in finalConfig.forwarding[0]) {
+      finalConfig.forwarding[0].address = `https://${finalConfig.forwarding[0].address}`;
+    }
+  }
 }
 function storeJson(config, saveconf) {
   if (saveconf) {
@@ -580,7 +597,7 @@ function isSaveConfOption(values) {
 function parseServe(finalConfig, values) {
   const sv = values.serve;
   if (typeof sv !== "string" || sv.trim().length === 0) return null;
-  finalConfig.serve = sv;
+  finalConfig.optional.serve = sv;
   return null;
 }
 function parseAutoReconnect(finalConfig, values) {
@@ -618,21 +635,23 @@ async function buildFinalConfig(values, positionals) {
     ...defaultOptions,
     ...configFromFile || {},
     // Apply loaded config on top of defaults
-    configid: getRandomId(),
+    configId: getRandomId(),
     token: token || (configFromFile?.token || (typeof values.token === "string" ? values.token : "")),
     serverAddress: server || (configFromFile?.serverAddress || defaultOptions.serverAddress),
-    tunnelType: initialTunnel ? [initialTunnel] : configFromFile?.tunnelType || [TunnelType.Http],
-    NoTUI: values.notui || (configFromFile?.NoTUI || false),
-    qrCode: qrCode || (configFromFile?.qrCode || false),
-    autoReconnect: configFromFile?.autoReconnect ? configFromFile.autoReconnect : defaultOptions.autoReconnect
+    isQRCode: qrCode || (configFromFile?.isQRCode || false),
+    autoReconnect: configFromFile?.autoReconnect ? configFromFile.autoReconnect : defaultOptions.autoReconnect,
+    optional: {
+      serve: configFromFile?.optional?.serve || void 0,
+      noTui: values.noTui || values.notui || (configFromFile?.optional?.noTui || false)
+    }
   };
-  parseType(finalConfig, values, type);
+  type = parseType(finalConfig, values, type);
   parseToken(finalConfig, token || values.token);
   const dbgErr = parseDebugger(finalConfig, values);
   if (dbgErr instanceof Error) throw dbgErr;
   const lpErr = parseLocalPort(finalConfig, values);
   if (lpErr instanceof Error) throw lpErr;
-  const rErr = parseReverseTunnelAddr(finalConfig, values);
+  const rErr = parseReverseTunnelAddr(finalConfig, values, type);
   if (rErr instanceof Error) throw rErr;
   const lErr = parseLocalTunnelAddr(finalConfig, values);
   if (lErr instanceof Error) throw lErr;
@@ -640,7 +659,7 @@ async function buildFinalConfig(values, positionals) {
   if (serveErr instanceof Error) throw serveErr;
   const autoReconnectErr = parseAutoReconnect(finalConfig, values);
   if (autoReconnectErr instanceof Error) throw autoReconnectErr;
-  if (forceFlag) finalConfig.force = true;
+  if (forceFlag || values.force) finalConfig.force = true;
   parseArgs(finalConfig, remainingPositionals);
   storeJson(finalConfig, saveconf);
   return finalConfig;
@@ -2026,7 +2045,7 @@ async function launchTui(finalConfig, urls, greet, tunnel) {
   }
 }
 async function startCli(finalConfig, manager) {
-  if (!finalConfig.NoTUI && finalConfig.webDebugger === "") {
+  if (!finalConfig.optional?.noTui && finalConfig.webDebugger === "") {
     const freePort = await getFreePort(finalConfig.webDebugger || "");
     finalConfig.webDebugger = `localhost:${freePort}`;
   }
@@ -2034,7 +2053,7 @@ async function startCli(finalConfig, manager) {
     const manager2 = TunnelManager.getInstance();
     const tunnel = await manager2.createTunnel(finalConfig);
     printer_default.startSpinner("Connecting to Pinggy...");
-    if (!finalConfig.NoTUI) {
+    if (!finalConfig.optional?.noTui) {
       manager2.registerStatsListener(tunnel.tunnelid, (tunnelId, stats) => {
         globalThis.__PINGGY_TUNNEL_STATS__?.(stats);
       });
@@ -2153,14 +2172,14 @@ async function startCli(finalConfig, manager) {
         }
         printer_default.print(pico.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
         printer_default.print(pico.gray("\nPress Ctrl+C to stop the tunnel.\n"));
-        if (!finalConfig.NoTUI) {
+        if (!finalConfig.optional?.noTui) {
           await launchTui(finalConfig, TunnelData.urls, TunnelData.greet, tunnel);
         }
       });
     } catch (e) {
       logger.debug("Failed to register start listener", e);
     }
-    if (!finalConfig.NoTUI) {
+    if (!finalConfig.optional?.noTui) {
       await launchTui(finalConfig, TunnelData.urls, TunnelData.greet, tunnel);
     }
   } catch (err) {

package/jest.config.cjs

@@ -0,0 +1,13 @@
+const { createDefaultEsmPreset } = require('ts-jest');
+
+const presetConfig = createDefaultEsmPreset();
+
+/** @type {import("jest").Config} **/
+module.exports = {
+  ...presetConfig,
+  testEnvironment: "node",
+  moduleNameMapper: {
+    // This handles the .js extension in your TS imports
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinggy",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "license": "Apache-2.0",
   "type": "module",
   "description": "Create secure, shareable tunnels to your localhost and manage them from the command line. ",
@@ -14,7 +14,7 @@
     "build:tsc": "tsc",
     "build": "tsup",
     "start": "node dist/index.js",
-    "test": "jest --config jest.config.js",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "bump": "node scripts/bumpVersion.js --bump && npm install",
     "bump:minor": "node scripts/bumpVersion.js --bump --minor && npm install",
     "bump:major": "node scripts/bumpVersion.js --bump --major && npm install",
@@ -51,7 +51,7 @@
     ]
   },
   "dependencies": {
-    "@pinggy/pinggy": "^0.3.5",
+    "@pinggy/pinggy": "^0.3.8",
     "blessed": "^0.1.81",
     "clipboardy": "^5.0.0",
     "mime": "^4.1.0",