pinggy 0.4.4 → 0.4.6

package/dist/index.cjs

@@ -116,6 +116,11 @@ var init_printer = __esm({
         const def = this.errorDefinitions.find((d) => d.match(err));
         const msg = def.message(err);
         console.error(import_picocolors2.default.red(import_picocolors2.default.bold("\u2716 Error:")), import_picocolors2.default.red(msg));
+      }
+      static fatal(err) {
+        const def = this.errorDefinitions.find((d) => d.match(err));
+        const msg = def.message(err);
+        console.error(import_picocolors2.default.red(import_picocolors2.default.bold("\u2716 Fatal Error:")), import_picocolors2.default.red(msg));
         process.exit(1);
       }
       static red(message) {
@@ -254,7 +259,9 @@ function enablePackageLogging(opts) {
   return applyLoggingConfig(opts ?? {});
 }
 function enableLoggingByLogLevelInSdk(loglevel, logFilePath) {
-  if (!loglevel) return;
+  if (!loglevel) {
+    return;
+  }
   const l = loglevel.toUpperCase();
   if (loglevel === "DEBUG") {
     import_pinggy.pinggy.setDebugLogging(true, import_pinggy.LogLevel.DEBUG, logFilePath);
@@ -430,7 +437,9 @@ var init_TunnelManager = __esm({
        */
       async startTunnel(tunnelId) {
         const managed = this.tunnelsByTunnelId.get(tunnelId);
-        if (!managed) throw new Error(`Tunnel with id "${tunnelId}" not found`);
+        if (!managed) {
+          throw new Error(`Tunnel with id "${tunnelId}" not found`);
+        }
         logger.info("Starting tunnel", { tunnelId });
         let urls;
         try {
@@ -478,7 +487,9 @@ var init_TunnelManager = __esm({
        */
       stopTunnel(tunnelId) {
         const managed = this.tunnelsByTunnelId.get(tunnelId);
-        if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
+        if (!managed) {
+          throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
         logger.info("Stopping tunnel", { tunnelId, configId: managed.configId });
         try {
           managed.instance.stop();
@@ -659,12 +670,16 @@ var init_TunnelManager = __esm({
       getTunnelInstance(configId, tunnelId) {
         if (configId) {
           const managed = this.tunnelsByConfigId.get(configId);
-          if (!managed) throw new Error(`Tunnel "${configId}" not found`);
+          if (!managed) {
+            throw new Error(`Tunnel "${configId}" not found`);
+          }
           return managed.instance;
         }
         if (tunnelId) {
           const managed = this.tunnelsByTunnelId.get(tunnelId);
-          if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
+          if (!managed) {
+            throw new Error(`Tunnel "${tunnelId}" not found`);
+          }
           return managed.instance;
         }
         throw new Error(`Either configId or tunnelId must be provided`);
@@ -843,12 +858,16 @@ var init_TunnelManager = __esm({
       getManagedTunnel(configId, tunnelId) {
         if (configId) {
           const managed = this.tunnelsByConfigId.get(configId);
-          if (!managed) throw new Error(`Tunnel "${configId}" not found`);
+          if (!managed) {
+            throw new Error(`Tunnel "${configId}" not found`);
+          }
           return managed;
         }
         if (tunnelId) {
           const managed = this.tunnelsByTunnelId.get(tunnelId);
-          if (!managed) throw new Error(`Tunnel "${tunnelId}" not found`);
+          if (!managed) {
+            throw new Error(`Tunnel "${tunnelId}" not found`);
+          }
           return managed;
         }
         throw new Error(`Either configId or tunnelId must be provided`);
@@ -1237,7 +1256,9 @@ var init_TunnelManager = __esm({
       notifyPollingErrorListeners(tunnelId, errorMsg) {
         try {
           const listeners = this.tunnelPollingErrorListeners.get(tunnelId);
-          if (!listeners) return;
+          if (!listeners) {
+            return;
+          }
           for (const [id, listener] of listeners) {
             try {
               listener(tunnelId, errorMsg);
@@ -1252,7 +1273,9 @@ var init_TunnelManager = __esm({
       notifyErrorListeners(tunnelId, errorMsg, isFatal) {
         try {
           const listeners = this.tunnelErrorListeners.get(tunnelId);
-          if (!listeners) return;
+          if (!listeners) {
+            return;
+          }
           for (const [id, listener] of listeners) {
             try {
               listener(tunnelId, errorMsg, isFatal);
@@ -1301,7 +1324,9 @@ var init_TunnelManager = __esm({
                 managedTunnel.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
               }
               const listeners = this.tunnelDisconnectListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, error, messages);
@@ -1329,7 +1354,9 @@ var init_TunnelManager = __esm({
             try {
               logger.info("Tunnel will reconnect", { tunnelId, error, messages });
               const listeners = this.tunnelWillReconnectListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, error, messages);
@@ -1357,7 +1384,9 @@ var init_TunnelManager = __esm({
             try {
               logger.info("Tunnel reconnecting", { tunnelId, retryCnt });
               const listeners = this.tunnelReconnectingListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, retryCnt);
@@ -1435,7 +1464,9 @@ var init_TunnelManager = __esm({
                 managedTunnel.stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
               }
               const listeners = this.tunnelReconnectionFailedListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, retryCnt);
@@ -1459,7 +1490,9 @@ var init_TunnelManager = __esm({
             try {
               logger.debug("Error in Tunnel Worker", { tunnelId, errorMessage: error.message });
               const listeners = this.tunnelWorkerErrorListeners.get(tunnelId);
-              if (!listeners) return;
+              if (!listeners) {
+                return;
+              }
               for (const [id, listener] of listeners) {
                 try {
                   listener(tunnelId, error);
@@ -1945,6 +1978,7 @@ var init_handler = __esm({
     "use strict";
     init_cjs_shims();
     init_types();
+    init_logger();
     init_TunnelManager();
     init_remote_schema();
     TunnelOperations = class {
@@ -1967,6 +2001,26 @@ var init_handler = __esm({
         }
         return status;
       }
+      // --- Placeholder response ---
+      buildPendingTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, serve) {
+        return {
+          tunnelid,
+          remoteurls: [],
+          tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, false, void 0, serve),
+          status: this.buildStatus(tunnelid, "starting" /* Starting */, "" /* NoError */),
+          stats: newStats()
+        };
+      }
+      buildPendingTunnelResponseV2(tunnelid, tunnelConfig, configFromCli, configid, tunnelName, serve) {
+        return {
+          tunnelid,
+          remoteurls: [],
+          tunnelconfig: pinggyOptionsToTunnelConfigV1(tunnelConfig, configFromCli),
+          status: this.buildStatus(tunnelid, "starting" /* Starting */, "" /* NoError */),
+          stats: newStats(),
+          greetmsg: ""
+        };
+      }
       // --- Helper to construct TunnelResponse ---
       async buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName, serve) {
         const [status, stats, tlsInfo, greetMsg, remoteurls] = await Promise.all([
@@ -2007,10 +2061,10 @@ var init_handler = __esm({
         });
       }
       // --- Operations ---
-      async handleStart(config) {
+      async handleStart(config, noWait = false) {
         try {
           const opts = tunnelConfigToPinggyOptions(config);
-          const { tunnelid, instance, tunnelName, serve, tunnelConfig } = await this.tunnelManager.createTunnel({
+          const managed = await this.tunnelManager.createTunnel({
             ...opts,
             configId: config.configid,
             name: config.configname,
@@ -2018,36 +2072,52 @@ var init_handler = __esm({
               serve: config.serve
             }
           });
-          await this.tunnelManager.startTunnel(tunnelid);
+          const { tunnelid, tunnelName, serve, tunnelConfig } = managed;
+          const startPromise = this.tunnelManager.startTunnel(tunnelid);
+          if (noWait) {
+            startPromise.catch((err) => {
+              logger.error("No-wait startTunnel failed", { tunnelid, err: String(err) });
+            });
+            return this.buildPendingTunnelResponse(tunnelid, tunnelConfig, config.configid, tunnelName, serve);
+          }
+          await startPromise;
           const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-          const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, serve);
-          return resp;
+          return this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName, serve);
         } catch (err) {
           return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
         }
       }
-      async handleStartV2(config) {
+      async handleStartV2(config, noWait = false) {
         try {
-          const { tunnelid, instance, serve } = await this.tunnelManager.createTunnel(config);
+          const managed = await this.tunnelManager.createTunnel(config);
+          const { tunnelid, serve, tunnelConfig } = managed;
           await this.tunnelManager.startTunnel(tunnelid);
           const tunnelPconfig = await this.tunnelManager.getTunnelConfig("", tunnelid);
-          const resp = this.buildTunnelResponseV2(tunnelid, tunnelPconfig, config, config.configId, config.name, config.serve);
-          return resp;
+          return this.buildTunnelResponseV2(tunnelid, tunnelPconfig, config, config.configId, config.name, config.serve);
         } catch (err) {
           return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
         }
       }
-      async handleUpdateConfig(config) {
+      async handleUpdateConfig(config, noWait = false) {
         try {
           const opts = tunnelConfigToPinggyOptions(config);
-          const tunnel = await this.tunnelManager.updateConfig({
+          const updateOpts = {
             ...opts,
             configId: config.configid,
             name: config.configname,
             optional: {
               serve: config.serve
             }
-          });
+          };
+          if (noWait) {
+            const existing = this.tunnelManager.getManagedTunnel(config.configid);
+            if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
+            this.tunnelManager.updateConfig(updateOpts).catch((err) => {
+              logger.error("No-wait updateConfig failed", { configid: config.configid, err: String(err) });
+            });
+            return this.buildPendingTunnelResponse(existing.tunnelid, existing.tunnelConfig, config.configid, existing.tunnelName, existing.serve);
+          }
+          const tunnel = await this.tunnelManager.updateConfig(updateOpts);
           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, tunnel.serve);
@@ -2055,8 +2125,17 @@ var init_handler = __esm({
           return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
         }
       }
-      async handleUpdateConfigV2(config) {
+      async handleUpdateConfigV2(config, noWait = false) {
         try {
+          if (noWait) {
+            const existing = this.tunnelManager.getManagedTunnel(config.configId);
+            console.log(existing);
+            if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
+            this.tunnelManager.updateConfig(config).catch((err) => {
+              logger.error("No-wait updateConfigV2 failed", { configId: config.configId, err: String(err) });
+            });
+            return this.buildPendingTunnelResponseV2(existing.tunnelid, existing.tunnelConfig, config, config.configId, existing.tunnelName, existing.serve);
+          }
           const tunnel = await this.tunnelManager.updateConfig(config);
           if (!tunnel.instance || !tunnel.tunnelConfig)
             throw new Error("Invalid tunnel state after configuration update");
@@ -2143,8 +2222,16 @@ var init_handler = __esm({
           return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
         }
       }
-      async handleRestart(tunnelid) {
+      async handleRestart(tunnelid, noWait = false) {
         try {
+          if (noWait) {
+            const managed2 = this.tunnelManager.getManagedTunnel("", tunnelid);
+            if (!managed2?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+            this.tunnelManager.restartTunnel(tunnelid).catch((err) => {
+              logger.error("No-wait restartTunnel failed", { tunnelid, err: String(err) });
+            });
+            return this.buildPendingTunnelResponse(tunnelid, managed2.tunnelConfig, managed2.configId, managed2.tunnelName, managed2.serve);
+          }
           await this.tunnelManager.restartTunnel(tunnelid);
           const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
           if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
@@ -2463,7 +2550,7 @@ var init_websocket_handlers = __esm({
           const dc = StartSchema.parse(raw);
           queuedConfig = dc.tunnelConfig;
           remoteManagementWebSocketPrinter.queueStart(dc.tunnelConfig);
-          const result = await this.tunnelHandler.handleStart(dc.tunnelConfig);
+          const result = await this.tunnelHandler.handleStart(dc.tunnelConfig, true);
           remoteManagementWebSocketPrinter.handleStartResult(dc.tunnelConfig, result);
           return this.wrapResponse(result, req);
         } catch (e) {
@@ -2484,7 +2571,7 @@ var init_websocket_handlers = __esm({
           const dc = StartV2Schema.parse(raw);
           queuedConfig = dc.tunnelConfig;
           remoteManagementWebSocketPrinter.queueStart(dc.tunnelConfig);
-          const result = await this.tunnelHandler.handleStartV2(dc.tunnelConfig);
+          const result = await this.tunnelHandler.handleStartV2(dc.tunnelConfig, true);
           remoteManagementWebSocketPrinter.handleStartResult(dc.tunnelConfig, result);
           return this.wrapResponse(result, req);
         } catch (e) {
@@ -2533,7 +2620,7 @@ var init_websocket_handlers = __esm({
         try {
           const dc = RestartSchema.parse(raw);
           remoteManagementWebSocketPrinter.printRestartRequested(dc.tunnelID);
-          const result = await this.tunnelHandler.handleRestart(dc.tunnelID);
+          const result = await this.tunnelHandler.handleRestart(dc.tunnelID, true);
           remoteManagementWebSocketPrinter.handleRestartResult(dc.tunnelID, result);
           return this.wrapResponse(result, req);
         } catch (e) {
@@ -2548,7 +2635,7 @@ var init_websocket_handlers = __esm({
       async handleUpdateConfigReq(req, raw) {
         try {
           const dc = UpdateConfigSchema.parse(raw);
-          const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
+          const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig, true);
           return this.wrapResponse(result, req);
         } catch (e) {
           if (e instanceof import_zod2.default.ZodError) {
@@ -2562,7 +2649,7 @@ var init_websocket_handlers = __esm({
       async handleUpdateConfigV2Req(req, raw) {
         try {
           const dc = UpdateConfigV2Schema.parse(raw);
-          const result = await this.tunnelHandler.handleUpdateConfigV2(dc.tunnelConfig);
+          const result = await this.tunnelHandler.handleUpdateConfigV2(dc.tunnelConfig, true);
           return this.wrapResponse(result, req);
         } catch (e) {
           if (e instanceof import_zod2.default.ZodError) {
@@ -2758,9 +2845,14 @@ async function initiateRemoteManagement(remoteManagementConfig) {
     try {
       await handleWebSocketConnection(wsUrl, wsHost, remoteManagementConfig.apiKey);
     } catch (error) {
+      if (error instanceof RemoteManagementUnauthorizedError) {
+        throw error;
+      }
       logger.warn("Remote management connection error", { error: String(error) });
     }
-    if (_stopRequested) break;
+    if (_stopRequested) {
+      break;
+    }
     printer_default.warn(`Remote management disconnected. Reconnecting in ${RECONNECT_SLEEP_MS / 1e3} seconds...`);
     logger.info("Reconnecting to remote management after disconnect");
     await sleep(RECONNECT_SLEEP_MS);
@@ -2769,22 +2861,34 @@ async function initiateRemoteManagement(remoteManagementConfig) {
   logger.info("Remote management stopped.");
   return getRemoteManagementState();
 }
-async function handleWebSocketConnection(wsUrl, wsHost, token) {
-  return new Promise((resolve) => {
+async function handleWebSocketConnection(wsUrl, wsHost, token, onOpenCallback) {
+  return new Promise((resolve, reject) => {
     const ws = new import_ws.default(wsUrl, {
       headers: { Authorization: `Bearer ${token}` }
     });
     currentWs = ws;
     let heartbeat = null;
     let firstMessage = true;
-    const cleanup = () => {
-      if (heartbeat) clearInterval(heartbeat);
+    let settled = false;
+    const cleanup = (err) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (heartbeat) {
+        clearInterval(heartbeat);
+      }
       currentWs = null;
-      resolve();
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
     };
     ws.once("open", () => {
       printer_default.success(`Connected to ${wsHost}`);
       setRemoteManagementState({ status: RemoteManagementStatus.Running, errorMessage: "" });
+      onOpenCallback?.();
       heartbeat = setInterval(() => {
         if (ws.readyState === import_ws.default.OPEN) ws.ping();
       }, PING_INTERVAL_MS);
@@ -2812,13 +2916,14 @@ async function handleWebSocketConnection(wsUrl, wsHost, token) {
     ws.on("unexpected-response", (_, res) => {
       if (res.statusCode === 401) {
         setRemoteManagementState({ status: RemoteManagementStatus.NotRunning, errorMessage: `HTTP ${res.statusCode}` });
-        printer_default.error("Unauthorized. Please enter a valid token.");
         logger.error("Unauthorized (401) on remote management connect");
+        cleanup(new RemoteManagementUnauthorizedError());
         ws.close();
       } else {
         logger.warn("Unexpected HTTP response ", { statusCode: res.statusCode });
         printer_default.warn(`Unexpected HTTP ${res.statusCode}. Retrying...`);
         cleanup();
+        ws.close();
       }
     });
     ws.on("close", (code, reason) => {
@@ -2830,7 +2935,7 @@ async function handleWebSocketConnection(wsUrl, wsHost, token) {
     ws.on("error", (err) => {
       setRemoteManagementState({ status: RemoteManagementStatus.Error, errorMessage: err.message });
       logger.warn("WebSocket error", { error: err.message });
-      printer_default.error(err);
+      printer_default.warn(err.message);
       cleanup();
     });
   });
@@ -2860,6 +2965,58 @@ async function closeRemoteManagement(timeoutMs = 1e4) {
     return getRemoteManagementState();
   }
 }
+function startRemoteManagement(remoteManagementConfig) {
+  if (!remoteManagementConfig.apiKey || remoteManagementConfig.apiKey.trim().length === 0) {
+    return Promise.reject(new Error("Remote management token is required"));
+  }
+  const wsUrl = remoteManagementConfig.serverUrl;
+  const wsHost = extractHostname(wsUrl);
+  logger.info("Remote management mode enabled.");
+  _stopRequested = false;
+  return new Promise((resolve, reject) => {
+    let firstSettled = false;
+    const settleOnce = (err) => {
+      if (firstSettled) {
+        return;
+      }
+      firstSettled = true;
+      if (err) {
+        reject(err);
+      } else {
+        resolve(getRemoteManagementState());
+      }
+    };
+    const runLoop = async () => {
+      const sigintHandler = () => {
+        _stopRequested = true;
+      };
+      process.once("SIGINT", sigintHandler);
+      while (!_stopRequested) {
+        logger.info("Connecting to remote management", { wsUrl });
+        setRemoteManagementState({ status: RemoteManagementStatus.Connecting, errorMessage: "" });
+        try {
+          await handleWebSocketConnection(wsUrl, wsHost, remoteManagementConfig.apiKey, () => settleOnce());
+        } catch (error) {
+          if (error instanceof RemoteManagementUnauthorizedError) {
+            settleOnce(error);
+            process.removeListener("SIGINT", sigintHandler);
+            return;
+          }
+          settleOnce();
+          logger.warn("Remote management connection error", { error: String(error) });
+        }
+        if (_stopRequested) {
+          break;
+        }
+        logger.info("Reconnecting to remote management after disconnect");
+        await sleep(RECONNECT_SLEEP_MS);
+      }
+      process.removeListener("SIGINT", sigintHandler);
+      logger.info("Remote management stopped.");
+    };
+    runLoop().catch((err) => settleOnce(err instanceof Error ? err : new Error(String(err))));
+  });
+}
 function getRemoteManagementState() {
   return _remoteManagementState;
 }
@@ -2869,7 +3026,7 @@ function setRemoteManagementState(state, errorMessage) {
     errorMessage: errorMessage || ""
   };
 }
-var import_ws, RECONNECT_SLEEP_MS, PING_INTERVAL_MS, _remoteManagementState, _stopRequested, currentWs;
+var import_ws, RECONNECT_SLEEP_MS, PING_INTERVAL_MS, RemoteManagementUnauthorizedError, _remoteManagementState, _stopRequested, currentWs;
 var init_remoteManagement = __esm({
   "src/remote_management/remoteManagement.ts"() {
     "use strict";
@@ -2881,6 +3038,12 @@ var init_remoteManagement = __esm({
     init_types();
     RECONNECT_SLEEP_MS = 5e3;
     PING_INTERVAL_MS = 3e4;
+    RemoteManagementUnauthorizedError = class extends Error {
+      constructor() {
+        super("Unauthorized. Please enter a valid token.");
+        this.name = "RemoteManagementUnauthorizedError";
+      }
+    };
     _remoteManagementState = {
       status: "NOT_RUNNING",
       errorMessage: ""
@@ -3154,6 +3317,19 @@ var init_extendedOptions = __esm({
 });
 
 // src/cli/buildConfig.ts
+function removeIPv6Brackets(ip) {
+  if (ip.startsWith("[") && ip.endsWith("]")) {
+    return ip.slice(1, -1);
+  }
+  return ip;
+}
+function isValidServerAddress(host) {
+  const normalized = removeIPv6Brackets(host.trim());
+  if (!normalized) {
+    return false;
+  }
+  return domainRegex.test(normalized) || (0, import_net2.isIP)(normalized) !== 0;
+}
 function isKeyword(str) {
   return KEYWORDS.has(str.toLowerCase());
 }
@@ -3163,10 +3339,12 @@ function parseUserAndDomain(str) {
   let server;
   let qrCode;
   let forceFlag;
-  if (!str) return { token, type, server, qrCode, forceFlag };
+  if (!str) {
+    return { token, type, server, qrCode, forceFlag };
+  }
   if (str.includes("@")) {
     const [user, domain] = str.split("@", 2);
-    if (domainRegex.test(domain)) {
+    if (isValidServerAddress(domain)) {
       let processKeyword2 = function(keyword) {
         if ([import_pinggy4.TunnelType.Http, import_pinggy4.TunnelType.Tcp, import_pinggy4.TunnelType.Tls, import_pinggy4.TunnelType.Udp, import_pinggy4.TunnelType.TlsTcp].includes(keyword)) {
           type = keyword;
@@ -3202,7 +3380,7 @@ function parseUserAndDomain(str) {
         }
       }
     }
-  } else if (domainRegex.test(str)) {
+  } else if (isValidServerAddress(str)) {
     server = str;
   }
   return { token, type, server, qrCode, forceFlag };
@@ -3216,21 +3394,39 @@ function parseUsers(positionalArgs, explicitToken) {
   let remaining = [...positionalArgs];
   if (typeof explicitToken === "string") {
     const parsed = parseUserAndDomain(explicitToken);
-    if (parsed.server) server = parsed.server;
-    if (parsed.type) type = parsed.type;
-    if (parsed.token) token = parsed.token;
-    if (parsed.forceFlag) forceFlag = true;
-    if (parsed.qrCode) qrCode = true;
+    if (parsed.server) {
+      server = parsed.server;
+    }
+    if (parsed.type) {
+      type = parsed.type;
+    }
+    if (parsed.token) {
+      token = parsed.token;
+    }
+    if (parsed.forceFlag) {
+      forceFlag = true;
+    }
+    if (parsed.qrCode) {
+      qrCode = true;
+    }
   }
   if (remaining.length > 0) {
     const first = remaining[0];
     const parsed = parseUserAndDomain(first);
     if (parsed.server) {
       server = parsed.server;
-      if (parsed.type) type = parsed.type;
-      if (parsed.token) token = parsed.token;
-      if (parsed.forceFlag) forceFlag = true;
-      if (parsed.qrCode) qrCode = true;
+      if (parsed.type) {
+        type = parsed.type;
+      }
+      if (parsed.token) {
+        token = parsed.token;
+      }
+      if (parsed.forceFlag) {
+        forceFlag = true;
+      }
+      if (parsed.qrCode) {
+        qrCode = true;
+      }
       remaining = remaining.slice(1);
     }
   }
@@ -3243,7 +3439,9 @@ function parseType(finalConfig, values, inferredType) {
   }
 }
 function parseLocalPort(finalConfig, values) {
-  if (typeof values.localport !== "string") return null;
+  if (typeof values.localport !== "string") {
+    return null;
+  }
   let lp = values.localport.trim();
   let isHttps = false;
   if (lp.startsWith("https://")) {
@@ -3273,15 +3471,11 @@ function parseLocalPort(finalConfig, values) {
   }
   return null;
 }
-function removeIPv6Brackets(ip) {
-  if (ip.startsWith("[") && ip.endsWith("]")) {
-    return ip.slice(1, -1);
-  }
-  return ip;
-}
 function isValidHostAddress(host) {
   const normalized = removeIPv6Brackets(host.trim());
-  if (normalized.length === 0) return false;
+  if (normalized.length === 0) {
+    return false;
+  }
   return normalized === "localhost" || (0, import_net2.isIP)(normalized) !== 0;
 }
 function ipv6SafeSplitColon(s) {
@@ -3324,7 +3518,9 @@ function parseDefaultForwarding(forwarding) {
 }
 function parseAdditionalForwarding(forwarding) {
   const toPort = (v) => {
-    if (!v) return null;
+    if (!v) {
+      return null;
+    }
     const n = parseInt(v, 10);
     return Number.isNaN(n) ? null : n;
   };
@@ -3336,7 +3532,7 @@ function parseAdditionalForwarding(forwarding) {
   }
   const firstPart = parsed[0];
   const [hostPart] = firstPart.split("@");
-  let protocol = "http";
+  let protocol = import_pinggy4.TunnelType.Http;
   let remoteDomainRaw;
   let remotePort = 0;
   if (hostPart.includes("//")) {
@@ -3350,7 +3546,7 @@ function parseAdditionalForwarding(forwarding) {
       return new Error("invalid forwarding address format");
     }
     remoteDomainRaw = domainAndPort[0];
-    if (!remoteDomainRaw || !domainRegex.test(remoteDomainRaw)) {
+    if (!remoteDomainRaw || !isValidServerAddress(remoteDomainRaw)) {
       return new Error("invalid remote domain");
     }
     const parsedRemotePort = toPort(domainAndPort[1]);
@@ -3366,10 +3562,10 @@ function parseAdditionalForwarding(forwarding) {
     }
   } else {
     remoteDomainRaw = hostPart;
-    if (!domainRegex.test(remoteDomainRaw)) {
+    if (!isValidServerAddress(remoteDomainRaw)) {
       return new Error("invalid remote domain");
     }
-    protocol = "http";
+    protocol = import_pinggy4.TunnelType.Http;
     remotePort = 0;
   }
   const localDomain = removeIPv6Brackets(parsed[2] || "localhost");
@@ -3403,7 +3599,9 @@ function parseReverseTunnelAddr(finalConfig, values, primaryType) {
       });
     } else if (slicedForwarding.length === 4) {
       const parsed = parseAdditionalForwarding(forwarding);
-      if (parsed instanceof Error) return parsed;
+      if (parsed instanceof Error) {
+        return parsed;
+      }
       forwardingData.push(parsed);
     } else {
       return new Error(
@@ -3415,7 +3613,9 @@ function parseReverseTunnelAddr(finalConfig, values, primaryType) {
   return null;
 }
 function parseLocalTunnelAddr(finalConfig, values) {
-  if (!Array.isArray(values.L) || values.L.length === 0) return null;
+  if (!Array.isArray(values.L) || values.L.length === 0) {
+    return null;
+  }
   const firstL = values.L[0];
   const parts = ipv6SafeSplitColon(firstL);
   let debuggerHost = "localhost";
@@ -3439,7 +3639,9 @@ function parseLocalTunnelAddr(finalConfig, values) {
 }
 function parseDebugger(finalConfig, values) {
   let dbg = values.debugger;
-  if (typeof dbg !== "string") return;
+  if (typeof dbg !== "string") {
+    return;
+  }
   dbg = dbg.startsWith(":") ? dbg.slice(1) : dbg;
   const d = parseInt(dbg, 10);
   if (!Number.isNaN(d) && isValidPort(d)) {
@@ -3498,7 +3700,9 @@ function isSaveConfOption(values) {
 }
 function parseServe(finalConfig, values) {
   const sv = values.serve;
-  if (typeof sv !== "string" || sv.trim().length === 0) return null;
+  if (typeof sv !== "string" || sv.trim().length === 0) {
+    return null;
+  }
   finalConfig.optional.serve = sv;
   return null;
 }
@@ -3539,7 +3743,7 @@ async function buildFinalConfig(values, positionals) {
     // Apply loaded config on top of defaults
     configId: getRandomId(),
     token: token || (configFromFile?.token || (typeof values.token === "string" ? values.token : "")),
-    serverAddress: server || (configFromFile?.serverAddress || defaultOptions.serverAddress),
+    serverAddress: server ? removeIPv6Brackets(server) : configFromFile?.serverAddress || defaultOptions.serverAddress,
     isQRCode: qrCode || (configFromFile?.isQRCode || false),
     autoReconnect: configFromFile?.autoReconnect ? configFromFile.autoReconnect : defaultOptions.autoReconnect,
     optional: {
@@ -3550,18 +3754,32 @@ async function buildFinalConfig(values, positionals) {
   type = parseType(finalConfig, values, type);
   parseToken(finalConfig, token || values.token);
   const dbgErr = parseDebugger(finalConfig, values);
-  if (dbgErr instanceof Error) throw dbgErr;
+  if (dbgErr instanceof Error) {
+    throw dbgErr;
+  }
   const lpErr = parseLocalPort(finalConfig, values);
-  if (lpErr instanceof Error) throw lpErr;
+  if (lpErr instanceof Error) {
+    throw lpErr;
+  }
   const rErr = parseReverseTunnelAddr(finalConfig, values, type);
-  if (rErr instanceof Error) throw rErr;
+  if (rErr instanceof Error) {
+    throw rErr;
+  }
   const lErr = parseLocalTunnelAddr(finalConfig, values);
-  if (lErr instanceof Error) throw lErr;
+  if (lErr instanceof Error) {
+    throw lErr;
+  }
   const serveErr = parseServe(finalConfig, values);
-  if (serveErr instanceof Error) throw serveErr;
+  if (serveErr instanceof Error) {
+    throw serveErr;
+  }
   const autoReconnectErr = parseAutoReconnect(finalConfig, values);
-  if (autoReconnectErr instanceof Error) throw autoReconnectErr;
-  if (forceFlag || values.force) finalConfig.force = true;
+  if (autoReconnectErr instanceof Error) {
+    throw autoReconnectErr;
+  }
+  if (forceFlag || values.force) {
+    finalConfig.force = true;
+  }
   parseArgs(finalConfig, remainingPositionals);
   storeJson(finalConfig, saveconf);
   return finalConfig;
@@ -3589,7 +3807,7 @@ var init_buildConfig = __esm({
       "force",
       "qr"
     ]);
-    VALID_PROTOCOLS = ["http", "tcp", "udp", "tls"];
+    VALID_PROTOCOLS = [import_pinggy4.TunnelType.Http, import_pinggy4.TunnelType.Tcp, import_pinggy4.TunnelType.Udp, import_pinggy4.TunnelType.Tls, import_pinggy4.TunnelType.TlsTcp];
   }
 });
 
@@ -3598,15 +3816,26 @@ function isAttachedReverseOrLocalFlag(arg) {
   return /^-[RL].+/.test(arg);
 }
 function shouldMergeReverseOrLocalFragment(current, next) {
-  if (next.startsWith("-")) return false;
-  if (next.startsWith(".")) return true;
+  if (next.startsWith("-")) {
+    return false;
+  }
+  if (next.startsWith(".")) {
+    return true;
+  }
   const body = current.slice(2);
-  if (body.endsWith(":")) return true;
-  if (body.includes("//") && !body.includes(":")) return true;
+  if (body.endsWith(":")) {
+    return true;
+  }
+  if (body.includes("//") && !body.includes(":")) {
+    return true;
+  }
   return false;
 }
 function preprocessWindowsArgs(args) {
-  if (os2.platform() !== "win32") return args;
+  if (os2.platform() !== "win32") {
+    return args;
+  }
+  ;
   const out = [];
   let i = 0;
   while (i < args.length) {
@@ -3693,13 +3922,12 @@ var init_getFreePort = __esm({
 async function createQrCodes(urls) {
   const codes = [];
   for (const url of urls) {
-    const qr = await import_qrcode.default.toString(url, {
-      type: "terminal",
-      small: true,
-      margin: 0,
+    const raw = await import_qrcode.default.toString(url, {
+      type: "utf8",
+      margin: 2,
       errorCorrectionLevel: "L"
     });
-    codes.push(qr);
+    codes.push(raw);
   }
   return codes;
 }
@@ -3717,6 +3945,7 @@ function getTuiConfig() {
   return {
     maxRequestPairs: defaultTuiConfig.maxRequestPairs,
     visibleRequestCount: defaultTuiConfig.visibleRequestCount,
+    visibleUrlCount: defaultTuiConfig.visibleUrlCount,
     viewportScrollMargin: defaultTuiConfig.viewportScrollMargin,
     inactivityHttpSelectorTimeoutMs: defaultTuiConfig.inactivityHttpSelectorTimeoutMs
   };
@@ -3729,6 +3958,7 @@ var init_config = __esm({
     defaultTuiConfig = {
       maxRequestPairs: 100,
       visibleRequestCount: 10,
+      visibleUrlCount: 7,
       viewportScrollMargin: 2,
       inactivityHttpSelectorTimeoutMs: 1e4
     };
@@ -3969,7 +4199,7 @@ function createFullUI(screen, urls, greet, tunnelConfig) {
     width: "100%-2",
     height: `100%-${lowerSectionTop + 6}`
   });
-  const isQrCodeRequested = tunnelConfig?.qrCode || false;
+  const isQrCodeRequested = tunnelConfig?.isQRCode || false;
   const requestsBox = import_blessed.default.box({
     parent: lowerSection,
     top: 0,
@@ -4129,8 +4359,24 @@ var init_utils = __esm({
 // src/tui/blessed/components/DisplayUpdaters.ts
 function updateUrlsDisplay(urlsBox, screen, urls, currentQrIndex) {
   if (!urlsBox) return;
-  let content = "{green-fg}{bold}Public URLs{/bold}{/green-fg}\n";
-  urls.forEach((url, index) => {
+  const config = getTuiConfig();
+  const { visibleUrlCount } = config;
+  let viewportStart = 0;
+  if (urls.length > visibleUrlCount) {
+    viewportStart = Math.max(0, Math.min(
+      currentQrIndex - Math.floor(visibleUrlCount / 2),
+      urls.length - visibleUrlCount
+    ));
+  }
+  const viewportEnd = Math.min(viewportStart + visibleUrlCount, urls.length);
+  const visibleUrls = urls.slice(viewportStart, viewportEnd);
+  let content = "{green-fg}{bold}Public URLs{/bold}{/green-fg}";
+  if (viewportStart > 0) {
+    content += ` {gray-fg}\u2191 ${viewportStart} more{/gray-fg}`;
+  }
+  content += "\n";
+  visibleUrls.forEach((url, i) => {
+    const index = viewportStart + i;
     const isSelected = index === currentQrIndex;
     const prefix = isSelected ? "\u2192 " : "\u2022 ";
     const color = isSelected ? "yellow" : "magenta";
@@ -4142,6 +4388,11 @@ function updateUrlsDisplay(urlsBox, screen, urls, currentQrIndex) {
 `;
     }
   });
+  const itemsBelow = urls.length - viewportEnd;
+  if (itemsBelow > 0) {
+    content += `{gray-fg}\u2193 ${itemsBelow} more{/gray-fg}
+`;
+  }
   urlsBox.setContent(content);
   screen.render();
 }
@@ -4854,7 +5105,7 @@ var init_TunnelTui = __esm({
         }
       }
       async generateQrCodes() {
-        if (this.tunnelConfig?.qrCode && this.urls.length > 0) {
+        if (this.tunnelConfig?.isQRCode && this.urls.length > 0) {
           this.qrCodes = await createQrCodes(this.urls);
           this.updateQrCodeDisplay();
         }
@@ -5091,7 +5342,7 @@ async function startCli(finalConfig, manager) {
       });
     }
     manager2.registerWorkerErrorListner(tunnel.tunnelid, (_tunnelid, error) => {
-      printer_default.error(`${error.message}`);
+      printer_default.fatal(`${error.message}`);
     });
     await manager2.startTunnel(tunnel.tunnelid);
     printer_default.stopSpinnerSuccess(" Connected to Pinggy");
@@ -5216,7 +5467,7 @@ async function startCli(finalConfig, manager) {
     }
   } catch (err) {
     printer_default.stopSpinnerFail("Failed to connect");
-    printer_default.error(err.message || "Unknown error");
+    printer_default.fatal(err.message || "Unknown error");
     throw err;
   }
 }
@@ -5244,6 +5495,7 @@ var init_starCli = __esm({
 // src/main.ts
 var main_exports = {};
 __export(main_exports, {
+  RemoteManagementUnauthorizedError: () => RemoteManagementUnauthorizedError,
   TunnelManager: () => TunnelManager,
   TunnelOperations: () => TunnelOperations,
   closeRemoteManagement: () => closeRemoteManagement,
@@ -5273,9 +5525,8 @@ async function main() {
     }
     const parseResult = await parseRemoteManagement(values);
     if (parseResult?.ok === false) {
-      printer_default.error(parseResult.error);
       logger.error("Failed to initiate remote management:", parseResult.error);
-      process.exit(1);
+      printer_default.fatal(parseResult.error);
     }
     logger.debug("Building final config from CLI values and positionals", { values, positionals });
     const finalConfig = await buildFinalConfig(values, positionals);
@@ -5283,7 +5534,7 @@ async function main() {
     await startCli(finalConfig, manager);
   } catch (error) {
     logger.error("Unhandled error in CLI:", error);
-    printer_default.error(error);
+    printer_default.fatal(error);
   }
 }
 var import_url2, import_process, import_fs5, currentFile, entryFile;
@@ -5323,6 +5574,7 @@ var init_main = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  RemoteManagementUnauthorizedError: () => RemoteManagementUnauthorizedError,
   TunnelErrorCodeType: () => TunnelErrorCodeType,
   TunnelManager: () => TunnelManager,
   TunnelOperations: () => TunnelOperations,
@@ -5331,7 +5583,8 @@ __export(index_exports, {
   closeRemoteManagement: () => closeRemoteManagement,
   enablePackageLogging: () => enablePackageLogging,
   getRemoteManagementState: () => getRemoteManagementState,
-  initiateRemoteManagement: () => initiateRemoteManagement
+  initiateRemoteManagement: () => initiateRemoteManagement,
+  startRemoteManagement: () => startRemoteManagement
 });
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
@@ -5437,11 +5690,11 @@ async function verifyAndLoad() {
   await Promise.resolve().then(() => (init_main(), main_exports));
 }
 verifyAndLoad().catch((err) => {
-  printer_default.error(`Failed to start CLI:, ${err}`);
-  process.exit(1);
+  printer_default.fatal(`Failed to start CLI:, ${err}`);
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  RemoteManagementUnauthorizedError,
   TunnelErrorCodeType,
   TunnelManager,
   TunnelOperations,
@@ -5450,5 +5703,6 @@ verifyAndLoad().catch((err) => {
   closeRemoteManagement,
   enablePackageLogging,
   getRemoteManagementState,
-  initiateRemoteManagement
+  initiateRemoteManagement,
+  startRemoteManagement
 });