pinggy 0.2.3 → 0.3.0

package/.github/workflows/publish-binaries.yml

@@ -36,59 +36,6 @@ jobs:
       - name: Run caxa build to produce `bin/`
         run: make pack
 
-      - name: Import Code Signing Certificate
-        env:
-          MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
-          MACOS_CERTIFICATE_PWD: ${{ secrets.MACOS_CERTIFICATE_PWD }}
-        run: |
-          # Create temporary keychain
-          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
-          KEYCHAIN_PASSWORD=$(openssl rand -base64 32)
-          
-          # Decode certificate and import to keychain
-          echo "$MACOS_CERTIFICATE" | base64 --decode > certificate.p12
-          security create-keychain -p "$KEYCHAIN_PASSWORD" "$KEYCHAIN_PATH"
-          security set-keychain-settings -lut 21600 "$KEYCHAIN_PATH"
-          security unlock-keychain -p "$KEYCHAIN_PASSWORD" "$KEYCHAIN_PATH"
-          security import certificate.p12 -k "$KEYCHAIN_PATH" -P "$MACOS_CERTIFICATE_PWD" -T /usr/bin/codesign
-          security list-keychain -d user -s "$KEYCHAIN_PATH"
-          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "$KEYCHAIN_PASSWORD" "$KEYCHAIN_PATH"
-          
-          # Clean up certificate file
-          rm certificate.p12
-      
-      - name: Code Sign Binary
-        env:
-          DEVELOPER_ID: ${{ secrets.MACOS_DEVELOPER_ID }}
-        run: |
-          FILE=$(ls bin)
-          echo "Code signing: $FILE"
-          codesign --force --options runtime --sign "$DEVELOPER_ID" --timestamp "bin/$FILE"
-          codesign --verify --verbose "bin/$FILE"
-      
-      - name: Notarize Binary (Optional)
-        env:
-          APPLE_ID: ${{ secrets.APPLE_ID }}
-          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-        run: |
-          FILE=$(ls bin)
-          
-          # Create a zip for notarization
-          ditto -c -k --keepParent "bin/$FILE" "bin/$FILE.zip"
-          
-          # Submit for notarization
-          xcrun notarytool submit "bin/$FILE.zip" \
-            --apple-id "$APPLE_ID" \
-            --password "$APPLE_APP_SPECIFIC_PASSWORD" \
-            --team-id "$APPLE_TEAM_ID" \
-            --wait
-          
-          # Remove zip file
-          rm "bin/$FILE.zip"
-          
-          echo "Notarization complete"
-
       - name: Show bin directory
         run: ls -R ./bin
 
@@ -109,14 +56,6 @@ jobs:
 
           echo "Uploading $FILE to GitHub Release…"
           gh release upload "$VERSION" "bin/$FILE" --clobber
-
-      - name: Cleanup Keychain
-        if: always()
-        run: |
-          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
-          if [ -f "$KEYCHAIN_PATH" ]; then
-            security delete-keychain "$KEYCHAIN_PATH"
-          fi
   
   Windows:
     name: Build on ${{ matrix.name }} and upload
@@ -205,6 +144,59 @@ jobs:
 
       - name: Run caxa build to produce `bin/`
         run: make pack
+
+      - name: Import Code Signing Certificate
+        env:
+          MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
+          MACOS_CERTIFICATE_PWD: ${{ secrets.MACOS_CERTIFICATE_PWD }}
+        run: |
+          # Create temporary keychain
+          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
+          KEYCHAIN_PASSWORD=$(openssl rand -base64 32)
+          
+          # Decode certificate and import to keychain
+          echo "$MACOS_CERTIFICATE" | base64 --decode > certificate.p12
+          security create-keychain -p "$KEYCHAIN_PASSWORD" "$KEYCHAIN_PATH"
+          security set-keychain-settings -lut 21600 "$KEYCHAIN_PATH"
+          security unlock-keychain -p "$KEYCHAIN_PASSWORD" "$KEYCHAIN_PATH"
+          security import certificate.p12 -k "$KEYCHAIN_PATH" -P "$MACOS_CERTIFICATE_PWD" -T /usr/bin/codesign
+          security list-keychain -d user -s "$KEYCHAIN_PATH"
+          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "$KEYCHAIN_PASSWORD" "$KEYCHAIN_PATH"
+          
+          # Clean up certificate file
+          rm certificate.p12
+      
+      - name: Code Sign Binary
+        env:
+          DEVELOPER_ID: ${{ secrets.MACOS_DEVELOPER_ID }}
+        run: |
+          FILE=$(ls bin)
+          echo "Code signing: $FILE"
+          codesign --force --options runtime --sign "$DEVELOPER_ID" --timestamp "bin/$FILE"
+          codesign --verify --verbose "bin/$FILE"
+      
+      - name: Notarize Binary (Optional)
+        env:
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: |
+          FILE=$(ls bin)
+          
+          # Create a zip for notarization
+          ditto -c -k --keepParent "bin/$FILE" "bin/$FILE.zip"
+          
+          # Submit for notarization
+          xcrun notarytool submit "bin/$FILE.zip" \
+            --apple-id "$APPLE_ID" \
+            --password "$APPLE_APP_SPECIFIC_PASSWORD" \
+            --team-id "$APPLE_TEAM_ID" \
+            --wait
+          
+          # Remove zip file
+          rm "bin/$FILE.zip"
+          
+          echo "Notarization complete"
       
       - name: See bin directory
         run: ls -R ./bin
@@ -226,3 +218,10 @@ jobs:
           echo "Uploading $FILE to GitHub Release…"
           gh release upload "$VERSION" "bin/$FILE" --clobber
 
+      - name: Cleanup Keychain
+        if: always()
+        run: |
+          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
+          if [ -f "$KEYCHAIN_PATH" ]; then
+            security delete-keychain "$KEYCHAIN_PATH"
+          fi

package/dist/index.cjs

@@ -962,6 +962,18 @@ _CLIPrinter.errorDefinitions = [
 var CLIPrinter = _CLIPrinter;
 var printer_default = CLIPrinter;
 
+// src/utils/util.ts
+init_cjs_shims();
+var import_module = require("module");
+function isValidPort(p) {
+  return Number.isInteger(p) && p > 0 && p < 65536;
+}
+var require2 = (0, import_module.createRequire)(importMetaUrl);
+var pkg = require2("../package.json");
+function getVersion() {
+  return pkg.version ?? "";
+}
+
 // src/tunnel_manager/TunnelManager.ts
 var __filename2 = (0, import_node_url.fileURLToPath)(importMetaUrl);
 var __dirname = import_node_path.default.dirname(__filename2);
@@ -984,6 +996,7 @@ var TunnelManager = class _TunnelManager {
   }
   /**
    * Creates a new managed tunnel instance with the given configuration.
+   * Builds the config with forwarding rules and creates the tunnel instance.
    * 
    * @param config - The tunnel configuration options
    * @param config.configid - Unique identifier for the tunnel configuration
@@ -1005,42 +1018,97 @@ var TunnelManager = class _TunnelManager {
       throw new Error(`Tunnel with configId "${configid}" already exists`);
     }
     const tunnelid = config.tunnelid || await getUuid();
+    const configWithForwarding = this.buildPinggyConfig(config, additionalForwarding);
+    return this._createTunnelWithProcessedConfig({
+      configid,
+      tunnelid,
+      tunnelName,
+      originalConfig: config,
+      configWithForwarding,
+      additionalForwarding,
+      serve: config.serve,
+      autoReconnect: config.autoReconnect !== void 0 ? config.autoReconnect : false
+    });
+  }
+  /**
+   * Internal method to create a tunnel with an already-processed configuration.
+   * This is used by createTunnel, restartTunnel, and updateConfig to avoid config processing.
+   * 
+   * @param params - Configuration parameters with already-processed forwarding rules
+   * @returns The created ManagedTunnel instance
+   * @private
+   */
+  async _createTunnelWithProcessedConfig(params) {
     let instance;
     try {
-      instance = await import_pinggy2.pinggy.createTunnel(config);
+      instance = await import_pinggy2.pinggy.createTunnel(params.configWithForwarding);
     } catch (e) {
       logger.error("Error creating tunnel instance:", e);
       throw e;
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    let autoReconnect = config.autoReconnect !== void 0 ? config.autoReconnect : false;
     const managed = {
-      tunnelid,
-      configid,
-      tunnelName,
+      tunnelid: params.tunnelid,
+      configid: params.configid,
+      tunnelName: params.tunnelName,
       instance,
-      tunnelConfig: config,
-      additionalForwarding,
-      serve: config.serve,
+      tunnelConfig: params.originalConfig,
+      configWithForwarding: params.configWithForwarding,
+      additionalForwarding: params.additionalForwarding,
+      serve: params.serve,
       warnings: [],
       isStopped: false,
       createdAt: now,
       startedAt: null,
       stoppedAt: null,
-      autoReconnect
+      autoReconnect: params.autoReconnect
     };
-    instance.setPrimaryForwardingCallback(({}) => {
+    instance.setTunnelEstablishedCallback(({}) => {
       managed.startedAt = (/* @__PURE__ */ new Date()).toISOString();
     });
-    this.setupStatsCallback(tunnelid, managed);
-    this.setupErrorCallback(tunnelid, managed);
-    this.setupDisconnectCallback(tunnelid, managed);
-    this.setUpTunnelWorkerErrorCallback(tunnelid, managed);
-    this.tunnelsByTunnelId.set(tunnelid, managed);
-    this.tunnelsByConfigId.set(configid, managed);
-    logger.info("Tunnel created", { configid, tunnelid });
+    this.setupStatsCallback(params.tunnelid, managed);
+    this.setupErrorCallback(params.tunnelid, managed);
+    this.setupDisconnectCallback(params.tunnelid, managed);
+    this.setUpTunnelWorkerErrorCallback(params.tunnelid, managed);
+    this.tunnelsByTunnelId.set(params.tunnelid, managed);
+    this.tunnelsByConfigId.set(params.configid, managed);
+    logger.info("Tunnel created", { configid: params.configid, tunnelid: params.tunnelid });
     return managed;
   }
+  /**
+   * 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 
+   */
+  buildPinggyConfig(config, additionalForwarding) {
+    const forwardingRules = [];
+    if (config.forwarding) {
+      forwardingRules.push({
+        type: config.tunnelType && config.tunnelType[0] || "http",
+        address: config.forwarding
+      });
+    }
+    if (Array.isArray(additionalForwarding) && additionalForwarding.length > 0) {
+      for (const rule of additionalForwarding) {
+        if (rule && rule.localDomain && rule.localPort && rule.remoteDomain && isValidPort(rule.localPort)) {
+          const forwardingRule = {
+            type: import_pinggy2.TunnelType.Http,
+            // In Future we can make this dynamic based on user input
+            address: `${rule.localDomain}:${rule.localPort}`,
+            listenAddress: rule.remotePort && isValidPort(rule.remotePort) ? `${rule.remoteDomain}:${rule.remotePort}` : rule.remoteDomain
+          };
+          forwardingRules.push(forwardingRule);
+        }
+      }
+    }
+    return {
+      ...config,
+      forwarding: forwardingRules.length > 0 ? forwardingRules : config.forwarding
+    };
+  }
   /**
    * Start a tunnel that was created but not yet started
    */
@@ -1056,22 +1124,6 @@ var TunnelManager = class _TunnelManager {
       throw error;
     }
     logger.info("Tunnel started", { tunnelId, urls });
-    if (Array.isArray(managed.additionalForwarding) && managed.additionalForwarding.length > 0) {
-      for (const f of managed.additionalForwarding) {
-        try {
-          if (!f || typeof f.remoteDomain !== "string" || !f.localDomain || typeof f.localPort !== "number") {
-            logger.warn(`Skipping invalid additional forwarding rule: ${JSON.stringify(f)}`);
-            continue;
-          }
-          const hostname = f.remoteDomain;
-          const target = `${f.localDomain}:${f.localPort}`;
-          await managed.instance.tunnelRequestAdditionalForwarding(hostname, target);
-          logger.info("Applied additional forwarding", { tunnelId, hostname, target });
-        } catch (e) {
-          logger.warn(`Failed to apply additional forwarding (${JSON.stringify(f)}):`, e);
-        }
-      }
-    }
     if (managed.serve) {
       this.startStaticFileServer(managed);
     }
@@ -1320,22 +1372,32 @@ var TunnelManager = class _TunnelManager {
       const tunnelName = existingTunnel.tunnelName;
       const currentConfigId = existingTunnel.configid;
       const currentConfig = existingTunnel.tunnelConfig;
+      const configWithForwarding = existingTunnel.configWithForwarding;
       const additionalForwarding = existingTunnel.additionalForwarding;
+      const currentServe = existingTunnel.serve;
+      const autoReconnect = existingTunnel.autoReconnect || false;
       this.tunnelsByTunnelId.delete(tunnelid);
       this.tunnelsByConfigId.delete(existingTunnel.configid);
       this.tunnelStats.delete(tunnelid);
       this.tunnelStatsListeners.delete(tunnelid);
-      const newTunnel = await this.createTunnel({
-        ...currentConfig,
+      this.tunnelErrorListeners.delete(tunnelid);
+      this.tunnelDisconnectListeners.delete(tunnelid);
+      this.tunnelWorkerErrorListeners.delete(tunnelid);
+      this.tunnelStartListeners.delete(tunnelid);
+      const newTunnel = await this._createTunnelWithProcessedConfig({
         configid: currentConfigId,
         tunnelid,
+        tunnelName,
+        originalConfig: currentConfig,
+        configWithForwarding,
         additionalForwarding,
-        tunnelName
+        serve: currentServe,
+        autoReconnect
       });
       if (existingTunnel.createdAt) {
         newTunnel.createdAt = existingTunnel.createdAt;
       }
-      this.startTunnel(newTunnel.tunnelid);
+      await this.startTunnel(newTunnel.tunnelid);
     } catch (error) {
       logger.error("Failed to restart tunnel", {
         tunnelid,
@@ -1351,18 +1413,10 @@ var TunnelManager = class _TunnelManager {
    * its state. If the tunnel is running, it will be stopped, updated, and restarted.
    * In case of failure, it attempts to restore the original configuration.
    * 
-   * @param tunnelId - The unique identifier of the tunnel to update
    * @param newConfig - The new configuration to apply, including configid and optional additional forwarding
-   * @param preserveAdditionalForwarding - Whether to preserve existing additional forwarding rules (default: true)
    * 
-   * @returns Promise resolving to an object containing the tunnel ID and array of URLs (if tunnel was running)
+   * @returns Promise resolving to the updated ManagedTunnel
    * @throws Error if the tunnel is not found or if the update process fails
-   * 
-   * @example
-   * const result = await tunnelManager.updateConfig('tunnel123', {
-   *   configid: 'config456',
-   *   port: 8080
-   * });
    */
   async updateConfig(newConfig) {
     const { configid, tunnelName: newTunnelName, additionalForwarding } = newConfig;
@@ -1375,27 +1429,41 @@ var TunnelManager = class _TunnelManager {
     }
     const isStopped = existingTunnel.isStopped;
     const currentTunnelConfig = existingTunnel.tunnelConfig;
+    const currentConfigWithForwarding = existingTunnel.configWithForwarding;
     const currentTunnelId = existingTunnel.tunnelid;
     const currentTunnelConfigId = existingTunnel.configid;
     const currentAdditionalForwarding = existingTunnel.additionalForwarding;
     const currentTunnelName = existingTunnel.tunnelName;
     const currentServe = existingTunnel.serve;
+    const currentAutoReconnect = existingTunnel.autoReconnect || false;
     try {
       if (!isStopped) {
         existingTunnel.instance.stop();
       }
       this.tunnelsByTunnelId.delete(currentTunnelId);
       this.tunnelsByConfigId.delete(currentTunnelConfigId);
-      const mergedConfig = {
+      const mergedBaseConfig = {
         ...newConfig,
         configid,
         tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
-        additionalForwarding: additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding,
         serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe
       };
-      const newTunnel = await this.createTunnel(mergedConfig);
+      const newConfigWithForwarding = this.buildPinggyConfig(
+        mergedBaseConfig,
+        additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding
+      );
+      const newTunnel = await this._createTunnelWithProcessedConfig({
+        configid,
+        tunnelid: currentTunnelId,
+        tunnelName: newTunnelName !== void 0 ? newTunnelName : currentTunnelName,
+        originalConfig: mergedBaseConfig,
+        configWithForwarding: newConfigWithForwarding,
+        additionalForwarding: additionalForwarding !== void 0 ? additionalForwarding : currentAdditionalForwarding,
+        serve: newConfig.serve !== void 0 ? newConfig.serve : currentServe,
+        autoReconnect: currentAutoReconnect
+      });
       if (!isStopped) {
-        this.startTunnel(newTunnel.tunnelid);
+        await this.startTunnel(newTunnel.tunnelid);
       }
       logger.info("Tunnel configuration updated", {
         tunnelId: newTunnel.tunnelid,
@@ -1409,12 +1477,15 @@ var TunnelManager = class _TunnelManager {
         error: error instanceof Error ? error.message : String(error)
       });
       try {
-        const originalTunnel = await this.createTunnel({
-          ...currentTunnelConfig,
-          configid: existingTunnel.configid,
+        const originalTunnel = await this._createTunnelWithProcessedConfig({
+          configid: currentTunnelConfigId,
           tunnelid: currentTunnelId,
           tunnelName: currentTunnelName,
-          additionalForwarding: currentAdditionalForwarding
+          originalConfig: currentTunnelConfig,
+          configWithForwarding: currentConfigWithForwarding,
+          additionalForwarding: currentAdditionalForwarding,
+          serve: currentServe,
+          autoReconnect: currentAutoReconnect
         });
         if (!isStopped) {
           await this.startTunnel(originalTunnel.tunnelid);
@@ -1931,14 +2002,12 @@ init_cjs_shims();
 
 // src/cli/defaults.ts
 init_cjs_shims();
-var import_pinggy3 = require("@pinggy/pinggy");
 var defaultOptions = {
   token: void 0,
   // No default token
   serverAddress: "a.pinggy.io",
   forwarding: "localhost:8000",
   webDebugger: "",
-  tunnelType: [import_pinggy3.TunnelType.Http],
   ipWhitelist: [],
   basicAuth: [],
   bearerTokenAuth: [],
@@ -2082,21 +2151,7 @@ function isValidIpV6Cidr(input) {
 
 // src/cli/buildConfig.ts
 init_logger();
-
-// src/utils/util.ts
-init_cjs_shims();
-var import_module = require("module");
-function isValidPort(p) {
-  return Number.isInteger(p) && p > 0 && p < 65536;
-}
-var require2 = (0, import_module.createRequire)(importMetaUrl);
-var pkg = require2("../package.json");
-function getVersion() {
-  return pkg.version ?? "";
-}
-
-// src/cli/buildConfig.ts
-var import_pinggy4 = require("@pinggy/pinggy");
+var import_pinggy3 = require("@pinggy/pinggy");
 var import_fs2 = __toESM(require("fs"), 1);
 var import_path2 = __toESM(require("path"), 1);
 var domainRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
@@ -2112,7 +2167,7 @@ function parseUserAndDomain(str) {
       server = domain;
       const parts = user.split("+");
       for (const part of parts) {
-        if ([import_pinggy4.TunnelType.Http, import_pinggy4.TunnelType.Tcp, import_pinggy4.TunnelType.Tls, import_pinggy4.TunnelType.Udp, import_pinggy4.TunnelType.TlsTcp].includes(part.toLowerCase())) {
+        if ([import_pinggy3.TunnelType.Http, import_pinggy3.TunnelType.Tcp, import_pinggy3.TunnelType.Tls, import_pinggy3.TunnelType.Udp, import_pinggy3.TunnelType.TlsTcp].includes(part.toLowerCase())) {
           type = part;
         } else if (part === "force") {
           token = (token ? token + "+" : "") + part;
@@ -2167,7 +2222,7 @@ function parseUsers(positionalArgs, explicitToken) {
 }
 function parseType(finalConfig, values, inferredType) {
   const t = inferredType || values.type || finalConfig.tunnelType;
-  if (t === import_pinggy4.TunnelType.Http || t === import_pinggy4.TunnelType.Tcp || t === import_pinggy4.TunnelType.Tls || t === import_pinggy4.TunnelType.Udp || t === import_pinggy4.TunnelType.TlsTcp) {
+  if (t === import_pinggy3.TunnelType.Http || t === import_pinggy3.TunnelType.Tcp || t === import_pinggy3.TunnelType.Tls || t === import_pinggy3.TunnelType.Udp || t === import_pinggy3.TunnelType.TlsTcp) {
     finalConfig.tunnelType = [t];
   }
 }
@@ -2370,7 +2425,7 @@ async function buildFinalConfig(values, positionals) {
     configid: await getUuid(),
     token: token || (typeof values.token === "string" ? values.token : ""),
     serverAddress: server || defaultOptions.serverAddress,
-    tunnelType: initialTunnel ? [initialTunnel] : defaultOptions.tunnelType,
+    tunnelType: initialTunnel ? [initialTunnel] : [import_pinggy3.TunnelType.Http],
     NoTUI: values.notui || false,
     qrCode: qrCode || false,
     autoReconnect: values.autoreconnect || false
@@ -2496,7 +2551,7 @@ init_cjs_shims();
 
 // src/remote_management/remote_schema.ts
 init_cjs_shims();
-var import_pinggy5 = require("@pinggy/pinggy");
+var import_pinggy4 = require("@pinggy/pinggy");
 var import_zod = require("zod");
 var HeaderModificationSchema = import_zod.z.object({
   key: import_zod.z.string(),
@@ -2505,6 +2560,7 @@ var HeaderModificationSchema = import_zod.z.object({
 });
 var AdditionalForwardingSchema = import_zod.z.object({
   remoteDomain: import_zod.z.string().optional(),
+  remotePort: import_zod.z.number().optional(),
   localDomain: import_zod.z.string(),
   localPort: import_zod.z.number()
 });
@@ -2537,11 +2593,11 @@ var TunnelConfigSchema = import_zod.z.object({
   token: import_zod.z.string(),
   tunnelTimeout: import_zod.z.number(),
   type: import_zod.z.enum([
-    import_pinggy5.TunnelType.Http,
-    import_pinggy5.TunnelType.Tcp,
-    import_pinggy5.TunnelType.Udp,
-    import_pinggy5.TunnelType.Tls,
-    import_pinggy5.TunnelType.TlsTcp
+    import_pinggy4.TunnelType.Http,
+    import_pinggy4.TunnelType.Tcp,
+    import_pinggy4.TunnelType.Udp,
+    import_pinggy4.TunnelType.Tls,
+    import_pinggy4.TunnelType.TlsTcp
   ]),
   webdebuggerport: import_zod.z.number(),
   xff: import_zod.z.string(),
@@ -2578,7 +2634,6 @@ function tunnelConfigToPinggyOptions(config) {
     serverAddress: config.serveraddress || "free.pinggy.io",
     forwarding: `${config.forwardedhost || "localhost"}:${config.localport}`,
     webDebugger: config.webdebuggerport ? `localhost:${config.webdebuggerport}` : "",
-    tunnelType: Array.isArray(config.type) ? config.type : [config.type || import_pinggy5.TunnelType.Http],
     ipWhitelist: config.ipwhitelist || [],
     basicAuth: config.basicauth ? config.basicauth : [],
     bearerTokenAuth: config.bearerauth ? [config.bearerauth] : [],
@@ -2599,7 +2654,7 @@ function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls,
   const forwarding = 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.tunnelType) ? opts.tunnelType[0] : opts.tunnelType ?? "http";
+  const tunnelType = (Array.isArray(opts.forwarding) ? opts.forwarding[0]?.type : void 0) ?? import_pinggy4.TunnelType.Http;
   const parsedTokens = opts.bearerTokenAuth ? Array.isArray(opts.bearerTokenAuth) ? opts.bearerTokenAuth : JSON.parse(opts.bearerTokenAuth) : [];
   return {
     allowPreflight: opts.allowPreflight ?? false,
@@ -2637,6 +2692,7 @@ function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls,
 }
 
 // src/remote_management/handler.ts
+var import_pinggy5 = require("@pinggy/pinggy");
 var TunnelOperations = class {
   constructor() {
     this.tunnelManager = TunnelManager.getInstance();
@@ -2684,6 +2740,8 @@ var TunnelOperations = class {
       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] : [import_pinggy5.TunnelType.Http],
+        // Temporary fix in future we will not use this field.
         configid: config.configid,
         tunnelName: config.configname,
         additionalForwarding: additionalForwardingParsed,
@@ -2702,6 +2760,8 @@ var TunnelOperations = class {
       const opts = tunnelConfigToPinggyOptions(config);
       const tunnel = await this.tunnelManager.updateConfig({
         ...opts,
+        tunnelType: Array.isArray(config.type) ? config.type : config.type ? [config.type] : [import_pinggy5.TunnelType.Http],
+        // // Temporary fix in future we will not use this field.
         configid: config.configid,
         tunnelName: config.configname,
         additionalForwarding: config.additionalForwarding || [],
@@ -3127,7 +3187,7 @@ function setRemoteManagementState(state, errorMessage) {
 
 // src/utils/parseArgs.ts
 init_cjs_shims();
-var import_util2 = require("util");
+var import_util3 = require("util");
 var os = __toESM(require("os"), 1);
 function isInlineColonFlag(arg) {
   return /^-([RL])[A-Za-z0-9._-]*:?$/.test(arg);
@@ -3157,7 +3217,7 @@ function preprocessWindowsArgs(args) {
 function parseCliArgs(options) {
   const rawArgs = process.argv.slice(2);
   const processedArgs = preprocessWindowsArgs(rawArgs);
-  const parsed = (0, import_util2.parseArgs)({
+  const parsed = (0, import_util3.parseArgs)({
     args: processedArgs,
     options,
     allowPositionals: true