pinggy 0.1.6 → 0.1.7

package/dist/{chunk-WEG3ISRS.js → chunk-HUN2MRZO.js}

@@ -11,21 +11,24 @@ function getLogger() {
   return _logger;
 }
 var logger = getLogger();
-function configureLogger(values, silent = false) {
-  const levelStr = values.loglevel || void 0;
-  const filePath = values.logfile || process.env.PINGGY_LOG_FILE || void 0;
-  const printlog = values.v || values.vvv || void 0;
-  const source = values.vvv ?? false;
-  if (values.vv || values.vvv || levelStr) {
-    enableLoggingByLogLevel(levelStr);
+function applyLoggingConfig(cfg) {
+  const {
+    level,
+    filePath,
+    stdout = false,
+    source = false,
+    silent = false,
+    enableSdkLog = false
+  } = cfg;
+  if (enableSdkLog) {
+    enableLoggingByLogLevelInSdk(level ?? "info", filePath);
   }
   if (filePath) {
     const dir = path.dirname(filePath);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   }
   const transports = [];
-  const stdoutEnabled = printlog === true || (process.env.PINGGY_LOG_STDOUT || "").toLowerCase() === "true";
-  if (stdoutEnabled) {
+  if (stdout) {
     transports.push(
       new winston.transports.Console({
         format: winston.format.combine(
@@ -33,7 +36,7 @@ function configureLogger(values, silent = false) {
           winston.format.timestamp(),
           winston.format.printf(({ level: level2, message, timestamp, ...meta }) => {
             const srcLabel = source ? "[CLI] " : "";
-            return `${timestamp} ${srcLabel}[${level2}]  ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
+            return `${timestamp} ${srcLabel}[${level2}] ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
           })
         )
       })
@@ -44,7 +47,6 @@ function configureLogger(values, silent = false) {
       new winston.transports.File({
         filename: filePath,
         format: winston.format.combine(
-          winston.format.colorize(),
           winston.format.timestamp(),
           winston.format.printf(({ level: level2, message, timestamp, ...meta }) => {
             return `${timestamp} [${level2}] ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
@@ -53,27 +55,47 @@ function configureLogger(values, silent = false) {
       })
     );
   }
-  const level = (levelStr || process.env.PINGGY_LOG_LEVEL || "info").toLowerCase();
   const log = getLogger();
   log.clear();
   for (const t of transports) {
     log.add(t);
   }
-  log.level = level;
-  log.silent = transports.length === 0 || silent === true;
+  log.level = (level || process.env.PINGGY_LOG_LEVEL || "info").toLowerCase();
+  log.silent = silent || transports.length === 0;
   return log;
 }
-function enableLoggingByLogLevel(loglevel) {
-  if (loglevel === "DEBUG" || loglevel === "debug") {
-    pinggy.setDebugLogging(true, LogLevel.DEBUG);
-  } else if (loglevel === "ERROR" || loglevel === "error") {
-    pinggy.setDebugLogging(true, LogLevel.ERROR);
+function configureLogger(values, silent = false) {
+  const level = values.loglevel || void 0;
+  const filePath = values.logfile || process.env.PINGGY_LOG_FILE || void 0;
+  const stdout = values.v || values.vvv || void 0;
+  const source = values.vvv ?? false;
+  const enableSdkLog = values.vv || values.vvv;
+  return applyLoggingConfig({
+    level,
+    filePath,
+    stdout,
+    source,
+    silent,
+    enableSdkLog
+  });
+}
+function enablePackageLogging(opts) {
+  return applyLoggingConfig(opts ?? {});
+}
+function enableLoggingByLogLevelInSdk(loglevel, logFilePath) {
+  if (!loglevel) return;
+  const l = loglevel.toUpperCase();
+  if (loglevel === "DEBUG") {
+    pinggy.setDebugLogging(true, LogLevel.DEBUG, logFilePath);
+  } else if (loglevel === "ERROR") {
+    pinggy.setDebugLogging(true, LogLevel.ERROR, logFilePath);
   } else {
-    pinggy.setDebugLogging(true, LogLevel.INFO);
+    pinggy.setDebugLogging(true, LogLevel.INFO, logFilePath);
   }
 }
 
 export {
   logger,
-  configureLogger
+  configureLogger,
+  enablePackageLogging
 };

package/dist/index.cjs

@@ -48,21 +48,24 @@ function getLogger() {
   }
   return _logger;
 }
-function configureLogger(values, silent = false) {
-  const levelStr = values.loglevel || void 0;
-  const filePath = values.logfile || process.env.PINGGY_LOG_FILE || void 0;
-  const printlog = values.v || values.vvv || void 0;
-  const source = values.vvv ?? false;
-  if (values.vv || values.vvv || levelStr) {
-    enableLoggingByLogLevel(levelStr);
+function applyLoggingConfig(cfg) {
+  const {
+    level,
+    filePath,
+    stdout = false,
+    source = false,
+    silent = false,
+    enableSdkLog = false
+  } = cfg;
+  if (enableSdkLog) {
+    enableLoggingByLogLevelInSdk(level ?? "info", filePath);
   }
   if (filePath) {
     const dir = import_path.default.dirname(filePath);
     if (!import_fs.default.existsSync(dir)) import_fs.default.mkdirSync(dir, { recursive: true });
   }
   const transports = [];
-  const stdoutEnabled = printlog === true || (process.env.PINGGY_LOG_STDOUT || "").toLowerCase() === "true";
-  if (stdoutEnabled) {
+  if (stdout) {
     transports.push(
       new import_winston.default.transports.Console({
         format: import_winston.default.format.combine(
@@ -70,7 +73,7 @@ function configureLogger(values, silent = false) {
           import_winston.default.format.timestamp(),
           import_winston.default.format.printf(({ level: level2, message, timestamp, ...meta }) => {
             const srcLabel = source ? "[CLI] " : "";
-            return `${timestamp} ${srcLabel}[${level2}]  ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
+            return `${timestamp} ${srcLabel}[${level2}] ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
           })
         )
       })
@@ -81,7 +84,6 @@ function configureLogger(values, silent = false) {
       new import_winston.default.transports.File({
         filename: filePath,
         format: import_winston.default.format.combine(
-          import_winston.default.format.colorize(),
           import_winston.default.format.timestamp(),
           import_winston.default.format.printf(({ level: level2, message, timestamp, ...meta }) => {
             return `${timestamp} [${level2}] ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
@@ -90,23 +92,42 @@ function configureLogger(values, silent = false) {
       })
     );
   }
-  const level = (levelStr || process.env.PINGGY_LOG_LEVEL || "info").toLowerCase();
   const log = getLogger();
   log.clear();
   for (const t of transports) {
     log.add(t);
   }
-  log.level = level;
-  log.silent = transports.length === 0 || silent === true;
+  log.level = (level || process.env.PINGGY_LOG_LEVEL || "info").toLowerCase();
+  log.silent = silent || transports.length === 0;
   return log;
 }
-function enableLoggingByLogLevel(loglevel) {
-  if (loglevel === "DEBUG" || loglevel === "debug") {
-    import_pinggy.pinggy.setDebugLogging(true, import_pinggy.LogLevel.DEBUG);
-  } else if (loglevel === "ERROR" || loglevel === "error") {
-    import_pinggy.pinggy.setDebugLogging(true, import_pinggy.LogLevel.ERROR);
+function configureLogger(values, silent = false) {
+  const level = values.loglevel || void 0;
+  const filePath = values.logfile || process.env.PINGGY_LOG_FILE || void 0;
+  const stdout = values.v || values.vvv || void 0;
+  const source = values.vvv ?? false;
+  const enableSdkLog = values.vv || values.vvv;
+  return applyLoggingConfig({
+    level,
+    filePath,
+    stdout,
+    source,
+    silent,
+    enableSdkLog
+  });
+}
+function enablePackageLogging(opts) {
+  return applyLoggingConfig(opts ?? {});
+}
+function enableLoggingByLogLevelInSdk(loglevel, logFilePath) {
+  if (!loglevel) return;
+  const l = loglevel.toUpperCase();
+  if (loglevel === "DEBUG") {
+    import_pinggy.pinggy.setDebugLogging(true, import_pinggy.LogLevel.DEBUG, logFilePath);
+  } else if (loglevel === "ERROR") {
+    import_pinggy.pinggy.setDebugLogging(true, import_pinggy.LogLevel.ERROR, logFilePath);
   } else {
-    import_pinggy.pinggy.setDebugLogging(true, import_pinggy.LogLevel.INFO);
+    import_pinggy.pinggy.setDebugLogging(true, import_pinggy.LogLevel.INFO, logFilePath);
   }
 }
 var import_winston, import_fs, import_path, import_pinggy, _logger, logger;
@@ -305,7 +326,7 @@ var init_URLsSection = __esm({
                 isCopied && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { color: "greenBright", children: "  [Copied!]" })
               ]
             },
-            url
+            `url-${url}-${index}`
           );
         })
       ] });
@@ -825,7 +846,8 @@ var init_tui = __esm({
 var index_exports = {};
 __export(index_exports, {
   TunnelManager: () => TunnelManager,
-  TunnelOperations: () => TunnelOperations
+  TunnelOperations: () => TunnelOperations,
+  enablePackageLogging: () => enablePackageLogging
 });
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
@@ -877,28 +899,23 @@ var _CLIPrinter = class _CLIPrinter {
   static print(message, ...args) {
     console.log(message, ...args);
   }
-  static async error(err) {
-    const chalk = this.chalk;
+  static error(err) {
     const def = this.errorDefinitions.find((d) => d.match(err));
     const msg = def.message(err);
-    console.error(chalk.redBright("\u2716 Error:"), chalk.red(msg));
+    console.error(this.chalk.redBright("\u2716 Error:"), this.chalk.red(msg));
     process.exit(1);
   }
-  static async warn(message) {
-    const chalk = this.chalk;
-    console.warn(chalk.yellowBright("\u26A0 Warning:"), chalk.yellow(message));
+  static warn(message) {
+    console.warn(this.chalk.yellowBright("\u26A0 Warning:"), this.chalk.yellow(message));
   }
-  static async success(message) {
-    const chalk = this.chalk;
-    console.log(chalk.greenBright("\u2714 Success:"), chalk.green(message));
+  static success(message) {
+    console.log(this.chalk.greenBright(" \u2714 Success:"), this.chalk.green(message));
   }
   static async info(message) {
-    const chalk = this.chalk;
-    console.log(chalk.blue(message));
+    console.log(this.chalk.blue(message));
   }
   static async startSpinner(message) {
-    const ora = this.ora;
-    this.spinner = ora({ text: message, color: "cyan" }).start();
+    this.spinner = this.ora({ text: message, color: "cyan" }).start();
   }
   static stopSpinnerSuccess(message) {
     this.spinner?.succeed(message);
@@ -993,7 +1010,8 @@ var TunnelManager = class _TunnelManager {
       tunnelConfig: config,
       additionalForwarding,
       serve: config.serve,
-      warnings: []
+      warnings: [],
+      isStopped: false
     };
     this.setupStatsCallback(tunnelid, managed);
     this.setupErrorCallback(tunnelid, managed);
@@ -1062,7 +1080,15 @@ var TunnelManager = class _TunnelManager {
       }
       this.tunnelStats.delete(tunnelId);
       this.tunnelStatsListeners.delete(tunnelId);
-      logger.info("Tunnel stopped", { tunnelId });
+      this.tunnelStats.delete(tunnelId);
+      this.tunnelStatsListeners.delete(tunnelId);
+      this.tunnelErrorListeners.delete(tunnelId);
+      this.tunnelDisconnectListeners.delete(tunnelId);
+      this.tunnelWorkerErrorListeners.delete(tunnelId);
+      managed.serveWorker = null;
+      managed.warnings = managed.warnings ?? [];
+      managed.isStopped = true;
+      logger.info("Tunnel stopped", { tunnelId, configId: managed.configid });
       return { configid: managed.configid, tunnelid: managed.tunnelid };
     } catch (error) {
       logger.error("Failed to stop tunnel", { tunnelId, error });
@@ -1073,28 +1099,40 @@ var TunnelManager = class _TunnelManager {
    * Get all public URLs for a tunnel
    */
   async getTunnelUrls(tunnelId) {
-    const managed = this.tunnelsByTunnelId.get(tunnelId);
-    if (!managed) {
-      logger.error(`Tunnel "${tunnelId}" not found when fetching URLs`);
-      throw new Error(`Tunnel "${tunnelId}" not found`);
+    try {
+      const managed = this.tunnelsByTunnelId.get(tunnelId);
+      if (!managed || managed.isStopped) {
+        logger.error(`Tunnel "${tunnelId}" not found when fetching URLs`);
+        return [];
+      }
+      const urls = await managed.instance.urls();
+      logger.debug("Queried tunnel URLs", { tunnelId, urls });
+      return urls;
+    } catch (error) {
+      logger.error("Error fetching tunnel URLs", { tunnelId, error });
+      throw error;
     }
-    const urls = await managed.instance.urls();
-    logger.debug("Queried tunnel URLs", { tunnelId, urls });
-    return urls;
   }
   /**
    * Get all TunnelStatus currently managed by this TunnelManager
    * @returns An array of all TunnelStatus objects
    */
   async getAllTunnels() {
-    const tunnelList = await Promise.all(Array.from(this.tunnelsByTunnelId.values()).map(async (tunnel) => ({
-      tunnelid: tunnel.tunnelid,
-      configid: tunnel.configid,
-      tunnelName: tunnel.tunnelName,
-      tunnelConfig: tunnel.tunnelConfig,
-      remoteurls: await this.getTunnelUrls(tunnel.tunnelid)
-    })));
-    return tunnelList;
+    try {
+      const tunnelList = await Promise.all(Array.from(this.tunnelsByTunnelId.values()).map(async (tunnel) => {
+        return {
+          tunnelid: tunnel.tunnelid,
+          configid: tunnel.configid,
+          tunnelName: tunnel.tunnelName,
+          tunnelConfig: tunnel.tunnelConfig,
+          remoteurls: !tunnel.isStopped ? await this.getTunnelUrls(tunnel.tunnelid) : []
+        };
+      }));
+      return tunnelList;
+    } catch (err) {
+      logger.error("Error fetching tunnels", { error: err });
+      return [];
+    }
   }
   /**
    * Get status of a tunnel
@@ -1105,6 +1143,9 @@ var TunnelManager = class _TunnelManager {
       logger.error(`Tunnel "${tunnelId}" not found when fetching status`);
       throw new Error(`Tunnel "${tunnelId}" not found`);
     }
+    if (managed.isStopped) {
+      return "exited";
+    }
     const status = await managed.instance.getStatus();
     logger.debug("Queried tunnel status", { tunnelId, status });
     return status;
@@ -1316,6 +1357,10 @@ var TunnelManager = class _TunnelManager {
       return null;
     }
     try {
+      if (managed.isStopped) {
+        logger.debug(`Tunnel "${tunnelId}" is stopped. No greet message available.`);
+        return null;
+      }
       const messages = await managed.instance.getGreetMessage();
       if (Array.isArray(messages)) {
         return messages.join(" ");
@@ -1460,6 +1505,10 @@ var TunnelManager = class _TunnelManager {
       return false;
     }
     try {
+      if (managed.isStopped) {
+        logger.debug(`Tunnel "${tunnelId}" is stopped. Cannot fetch local server TLS info`);
+        return false;
+      }
       const tlsInfo = await managed.instance.getLocalServerTls();
       if (tlsInfo) {
         return tlsInfo;
@@ -1572,12 +1621,14 @@ var TunnelManager = class _TunnelManager {
   updateStats(tunnelId, rawUsage) {
     try {
       const normalizedStats = this.normalizeStats(rawUsage);
-      this.tunnelStats.set(tunnelId, normalizedStats);
+      const existingStats = this.tunnelStats.get(tunnelId) || [];
+      const updatedStats = [...existingStats, normalizedStats];
+      this.tunnelStats.set(tunnelId, updatedStats);
       const tunnelListeners = this.tunnelStatsListeners.get(tunnelId);
       if (tunnelListeners) {
         for (const [listenerId, listener] of tunnelListeners) {
           try {
-            listener(tunnelId, normalizedStats);
+            listener(tunnelId, updatedStats);
           } catch (error) {
             logger.warn("Error in stats listener callback", { listenerId, tunnelId, error });
           }
@@ -2299,7 +2350,7 @@ var HeaderModificationSchema = import_zod.z.object({
   type: import_zod.z.enum(["add", "remove", "update"])
 });
 var TunnelConfigSchema = import_zod.z.object({
-  allowpreflight: import_zod.z.boolean(),
+  allowPreflight: import_zod.z.boolean(),
   autoreconnect: import_zod.z.boolean(),
   basicauth: import_zod.z.array(import_zod.z.object({ username: import_zod.z.string(), password: import_zod.z.string() })).nullable(),
   bearerauth: import_zod.z.string().nullable(),
@@ -2353,7 +2404,7 @@ function tunnelConfigToPinggyOptions(config) {
     xForwardedFor: !!config.xff,
     httpsOnly: config.httpsOnly,
     originalRequestUrl: config.fullRequestUrl,
-    allowPreflight: config.allowpreflight,
+    allowPreflight: config.allowPreflight,
     reverseProxy: config.noReverseProxy,
     force: config.force,
     optional: {
@@ -2366,7 +2417,7 @@ function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls,
   const tunnelType = Array.isArray(opts.tunnelType) ? opts.tunnelType[0] : opts.tunnelType ?? "http";
   const parsedTokens = opts.bearerTokenAuth ? Array.isArray(opts.bearerTokenAuth) ? opts.bearerTokenAuth : JSON.parse(opts.bearerTokenAuth) : [];
   return {
-    allowpreflight: opts.allowPreflight ?? false,
+    allowPreflight: opts.allowPreflight ?? false,
     autoreconnect: true,
     basicauth: opts.basicAuth && Object.keys(opts.basicAuth).length ? opts.basicAuth : null,
     bearerauth: parsedTokens.length ? parsedTokens.join(",") : null,
@@ -2460,21 +2511,25 @@ var TunnelOperations = class {
   async handleList() {
     try {
       const tunnels = await this.tunnelManager.getAllTunnels();
+      if (tunnels.length === 0) {
+        return [];
+      }
       return Promise.all(
         tunnels.map(async (t) => {
-          const stats = this.tunnelManager.getTunnelStats(t.tunnelid) ?? newStats();
-          const [status, config, tlsInfo, greetMsg] = await Promise.all([
+          const rawStats = this.tunnelManager.getTunnelStats(t.tunnelid);
+          const stats = rawStats ?? newStats();
+          const [status, tlsInfo, greetMsg] = await Promise.all([
             this.tunnelManager.getTunnelStatus(t.tunnelid),
-            this.tunnelManager.getTunnelConfig("", t.tunnelid),
             this.tunnelManager.getLocalserverTlsInfo(t.tunnelid),
             this.tunnelManager.getTunnelGreetMessage(t.tunnelid)
           ]);
+          const tunnelConfig = pinggyOptionsToTunnelConfig(t.tunnelConfig, t.configid, t.tunnelName, tlsInfo, greetMsg);
           return {
             tunnelid: t.tunnelid,
             remoteurls: t.remoteurls,
             status: newStatus(status, "" /* NoError */, ""),
             stats,
-            tunnelconfig: pinggyOptionsToTunnelConfig(config, t.configid, t.tunnelName, tlsInfo, greetMsg)
+            tunnelconfig: tunnelConfig
           };
         })
       );
@@ -2511,6 +2566,12 @@ var TunnelOperations = class {
       return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
     }
   }
+  handleRegisterStatsListener(tunnelid, listener) {
+    this.tunnelManager.registerStatsListener(tunnelid, listener);
+  }
+  handleUnregisterStatsListener(tunnelid, listnerId) {
+    this.tunnelManager.deregisterStatsListener(tunnelid, listnerId);
+  }
 };
 
 // src/remote_management/websocket_handlers.ts
@@ -2777,8 +2838,37 @@ async function initiateRemoteManagement(token, manage) {
 // src/utils/parseArgs.ts
 init_cjs_shims();
 var import_util2 = require("util");
+var os = __toESM(require("os"), 1);
+function isInlineColonFlag(arg) {
+  return /^-([RL])[A-Za-z0-9._-]*:?$/.test(arg);
+}
+function preprocessWindowsArgs(args) {
+  if (os.platform() !== "win32") return args;
+  const out = [];
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (isInlineColonFlag(arg)) {
+      if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        let merged = arg + args[i + 1];
+        i += 2;
+        out.push(merged);
+        continue;
+      }
+      out.push(arg);
+      i++;
+      continue;
+    }
+    out.push(arg);
+    i++;
+  }
+  return out;
+}
 function parseCliArgs(options) {
+  const rawArgs = process.argv.slice(2);
+  const processedArgs = preprocessWindowsArgs(rawArgs);
   const parsed = (0, import_util2.parseArgs)({
+    args: processedArgs,
     options,
     allowPositionals: true
   });
@@ -2907,6 +2997,7 @@ async function startCli(finalConfig, manager) {
       const { withFullScreen } = await import("fullscreen-ink");
       const { default: TunnelTui2 } = await Promise.resolve().then(() => (init_tui(), tui_exports));
       const React3 = await import("react");
+      const isTTYEnabled = process.stdin.isTTY;
       const TunnelTuiWrapper = ({ finalConfig: finalConfig2, urls, greet }) => {
         const [disconnectInfo, setDisconnectInfo] = React3.useState(null);
         React3.useEffect(() => {
@@ -2936,13 +3027,17 @@ async function startCli(finalConfig, manager) {
         )
       );
       activeTui = tui;
-      try {
-        await tui.start();
-        await tui.waitUntilExit();
-      } catch (e) {
-        logger.warn("TUI error", e);
-      } finally {
-        activeTui = null;
+      if (isTTYEnabled) {
+        try {
+          await tui.start();
+          await tui.waitUntilExit();
+        } catch (e) {
+          logger.warn("TUI error", e);
+        } finally {
+          activeTui = null;
+        }
+      } else {
+        printer_default.warn("Unable to initiate the TUI: your terminal does not support the required input mode.");
       }
     }
   } catch (err) {
@@ -2956,6 +3051,7 @@ async function startCli(finalConfig, manager) {
 var import_url = require("url");
 var import_process = require("process");
 var import_fs3 = require("fs");
+init_logger();
 async function main() {
   try {
     const { values, positionals, hasAnyArgs } = parseCliArgs(cliOptions);
@@ -3004,5 +3100,6 @@ if (entryFile && entryFile === currentFile) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TunnelManager,
-  TunnelOperations
+  TunnelOperations,
+  enablePackageLogging
 });

package/dist/index.d.cts

@@ -2,6 +2,7 @@
 import { PinggyOptions, TunnelInstance, TunnelUsageType, TunnelType } from '@pinggy/pinggy';
 import { Worker } from 'node:worker_threads';
 import { z } from 'zod';
+import winston from 'winston';
 
 interface AdditionalForwarding {
     remoteDomain?: string;
@@ -73,6 +74,7 @@ interface ManagedTunnel {
     serveWorker?: Worker | null;
     warnings?: Warning[];
     serve?: string;
+    isStopped?: boolean;
 }
 interface TunnelList {
     tunnelid: string;
@@ -81,7 +83,7 @@ interface TunnelList {
     tunnelConfig: PinggyOptions;
     remoteurls: string[];
 }
-type StatsListener = (tunnelId: string, stats: TunnelUsageType) => void;
+type StatsListener = (tunnelId: string, stats: TunnelUsageType[]) => void;
 type ErrorListener = (tunnelId: string, errorMsg: string, isFatal: boolean) => void;
 type DisconnectListener = (tunnelId: string, error: string, messages: string[]) => void;
 type TunnelWorkerErrorListner = (tunnelid: string, error: Error) => void;
@@ -112,7 +114,7 @@ interface ITunnelManager {
     }): Promise<ManagedTunnel>;
     getManagedTunnel(configId?: string, tunnelId?: string): ManagedTunnel;
     getTunnelGreetMessage(tunnelId: string): Promise<string | null>;
-    getTunnelStats(tunnelId: string): TunnelUsageType | null;
+    getTunnelStats(tunnelId: string): TunnelUsageType[] | null;
     registerStatsListener(tunnelId: string, listener: StatsListener): Promise<string>;
     registerErrorListener(tunnelId: string, listener: ErrorListener): Promise<string>;
     registerWorkerErrorListner(tunnelId: string, listener: TunnelWorkerErrorListner): void;
@@ -244,7 +246,7 @@ declare class TunnelManager implements ITunnelManager {
      */
     getManagedTunnel(configId?: string, tunnelId?: string): ManagedTunnel;
     getTunnelGreetMessage(tunnelId: string): Promise<string | null>;
-    getTunnelStats(tunnelId: string): TunnelUsageType | null;
+    getTunnelStats(tunnelId: string): TunnelUsageType[] | null;
     /**
      * Registers a listener function to receive tunnel statistics updates.
      * The listener will be called whenever any tunnel's stats are updated.
@@ -289,7 +291,7 @@ declare class TunnelManager implements ITunnelManager {
 }
 
 declare const TunnelConfigSchema: z.ZodObject<{
-    allowpreflight: z.ZodBoolean;
+    allowPreflight: z.ZodBoolean;
     autoreconnect: z.ZodBoolean;
     basicauth: z.ZodNullable<z.ZodArray<z.ZodObject<{
         username: z.ZodString;
@@ -341,7 +343,7 @@ interface TunnelResponse {
     remoteurls: string[];
     tunnelconfig: TunnelConfig;
     status: Status;
-    stats: TunnelUsageType;
+    stats: TunnelUsageType[];
 }
 interface TunnelHandler {
     handleStart(config: TunnelConfig): Promise<TunnelResponse | ErrorResponse>;
@@ -350,6 +352,8 @@ interface TunnelHandler {
     handleStop(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
     handleGet(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
     handleRestart(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
+    handleRegisterStatsListener(tunnelid: string, listener: (tunnelId: string, stats: TunnelUsageType[]) => void): void;
+    handleUnregisterStatsListener(tunnelid: string, listnerId: string): void;
 }
 declare class TunnelOperations implements TunnelHandler {
     private tunnelManager;
@@ -362,6 +366,19 @@ declare class TunnelOperations implements TunnelHandler {
     handleStop(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
     handleGet(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
     handleRestart(tunnelid: string): Promise<TunnelResponse | ErrorResponse>;
+    handleRegisterStatsListener(tunnelid: string, listener: (tunnelId: string, stats: TunnelUsageType[]) => void): void;
+    handleUnregisterStatsListener(tunnelid: string, listnerId: string): void;
 }
 
-export { TunnelManager, TunnelOperations, type TunnelResponse };
+interface BaseLogConfig {
+    level?: string;
+    filePath?: string;
+    stdout?: boolean;
+    source?: boolean;
+    silent?: boolean;
+    enableSdkLog?: boolean;
+}
+type BaseLogConfigType = BaseLogConfig;
+declare function enablePackageLogging(opts?: BaseLogConfigType): winston.Logger;
+
+export { TunnelManager, TunnelOperations, type TunnelResponse, enablePackageLogging };