pinggy 0.1.3 → 0.1.4

package/dist/cli/buildConfig.js

@@ -88,7 +88,7 @@ function parseUsers(positionalArgs, explicitToken) {
 }
 function parseType(finalConfig, values, inferredType) {
     const t = inferredType || values.type || finalConfig.tunnelType;
-    if (t === "http" /* TunnelType.Http */ || t === "tcp" /* TunnelType.Tcp */ || t === "tls" /* TunnelType.Tls */ || t === "udp" /* TunnelType.Udp */) {
+    if (t === "http" /* TunnelType.Http */ || t === "tcp" /* TunnelType.Tcp */ || t === "tls" /* TunnelType.Tls */ || t === "udp" /* TunnelType.Udp */ || t === "tlstcp" /* TunnelType.TlsTcp */) {
         finalConfig.tunnelType = [t];
     }
 }

package/dist/cli/extendedOptions.js

@@ -37,7 +37,7 @@ export function parseExtendedOptions(options, config) {
                 // Whitelist IPs
                 if (value) {
                     const ips = value.split(",").map(ip => ip.trim()).filter(Boolean);
-                    const invalidIps = ips.filter(ip => !isValidIpV4Cidr(ip));
+                    const invalidIps = ips.filter(ip => !(isValidIpV4Cidr(ip) || isValidIpV6Cidr(ip)));
                     if (invalidIps.length > 0) {
                         CLIPrinter.warn(`Invalid IP/CIDR(s) in whitelist: ${invalidIps.join(", ")}`);
                         logger.warn(`Warning: Invalid IP/CIDR(s) in whitelist: ${invalidIps.join(", ")}`);
@@ -132,3 +132,18 @@ function isValidIpV4Cidr(input) {
     }
     return false;
 }
+function isValidIpV6Cidr(input) {
+    // Check for CIDR notation
+    if (input.includes('/')) {
+        const [rawIp, mask] = input.split('/');
+        if (!rawIp || !mask)
+            return false;
+        // Strip zone index (e.g. %eth0) and surrounding brackets if present
+        const ip = rawIp.split('%')[0].replace(/^\[|\]$/g, '');
+        const isIp6 = isIP(ip) === 6;
+        const maskNum = parseInt(mask, 10);
+        const isMaskValid = !isNaN(maskNum) && maskNum >= 0 && maskNum <= 128;
+        return isIp6 && isMaskValid;
+    }
+    return false;
+}

package/dist/cli/options.js

@@ -19,7 +19,9 @@ export const cliOptions = {
     // Logging options (CLI overrides env)
     loglevel: { type: 'string', description: 'Logging level: ERROR, INFO, DEBUG. Overrides PINGGY_LOG_LEVEL environment variable' },
     logfile: { type: 'string', description: 'Path to log file. Overrides PINGGY_LOG_FILE environment variable' },
-    printlog: { type: 'boolean', short: 'g', description: 'Also print logs to stdout. Overrides PINGGY_LOG_STDOUT environment variable' },
+    v: { type: 'boolean', description: 'Print logs to stdout for Cli. Overrides PINGGY_LOG_STDOUT environment variable' },
+    vv: { type: 'boolean', description: 'Enable detailed logging for the Node.js SDK and Libpinggy, including both info and debug level logs.' },
+    vvv: { type: 'boolean', description: 'Enable all logs from Cli, SDK and internal components.' },
     // Save and load config
     saveconf: { type: 'string', description: 'Create the configuration file based on the options provided here' },
     conf: { type: 'string', description: 'Use the configuration file as base. Other options will be used to override this file' },

package/dist/cli/starCli.js

@@ -9,13 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { jsx as _jsx } from "react/jsx-runtime";
 import CLIPrinter from "../utils/printer.js";
+import { TunnelManager } from "../tunnel_manager/TunnelManager.js";
 import chalk from "chalk";
 import TunnelTui from "../tui/index.js";
 import { withFullScreen } from "fullscreen-ink";
-import path from "node:path";
-import { Worker } from "node:worker_threads";
 import { getFreePort } from "../utils/getFreePort.js";
-import { fileURLToPath } from "url";
 import { logger } from "../logger.js";
 import React, { useState } from "react";
 const TunnelData = {
@@ -26,8 +24,6 @@ const TunnelData = {
 let activeTui = null;
 let disconnectState = null;
 let updateDisconnectState = null;
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
 const TunnelTuiWrapper = ({ finalConfig, urls, greet }) => {
     const [disconnectInfo, setDisconnectInfo] = useState(null);
     React.useEffect(() => {
@@ -40,118 +36,95 @@ const TunnelTuiWrapper = ({ finalConfig, urls, greet }) => {
 };
 export function startCli(finalConfig, manager) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
         if (!finalConfig.NoTUI && finalConfig.webDebugger === "") {
             // Need a webdebugger port 
             const freePort = yield getFreePort(finalConfig.webDebugger || "");
             finalConfig.webDebugger = `localhost:${freePort}`;
         }
-        const workerPath = path.resolve(__dirname, "../workers/worker.js");
         try {
-            const worker = new Worker(workerPath, {
-                workerData: { finalConfig },
+            const manager = TunnelManager.getInstance();
+            const tunnel = manager.createTunnel(finalConfig);
+            CLIPrinter.startSpinner("Connecting to Pinggy...");
+            if (!finalConfig.NoTUI) {
+                manager.registerStatsListener(tunnel.tunnelid, (tunnelId, stats) => {
+                    var _a;
+                    (_a = globalThis.__PINGGY_TUNNEL_STATS__) === null || _a === void 0 ? void 0 : _a.call(globalThis, stats);
+                });
+            }
+            manager.registerWorkerErrorListner(tunnel.tunnelid, (_tunnelid, error) => {
+                // The CLI terminates in this callback because these errors occur only when the tunnel worker
+                // exits, crashes, or encounters critical problems (e.g., authentication failure or primary forwarding failure).
+                CLIPrinter.error(`${error.message}`);
             });
-            worker.on("message", (msg) => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d, _e;
-                switch (msg.type) {
-                    case "created":
-                        CLIPrinter.startSpinner(msg.message);
-                        break;
-                    case "started":
-                        CLIPrinter.stopSpinnerSuccess(msg.message);
-                        CLIPrinter.success(chalk.bold("Tunnel established!"));
-                        CLIPrinter.print(chalk.gray("───────────────────────────────"));
-                        break;
-                    case "urls":
-                        TunnelData.urls = msg.urls;
-                        CLIPrinter.info(chalk.cyanBright("Remote URLs:"));
-                        ((_a = TunnelData.urls) !== null && _a !== void 0 ? _a : []).forEach((url) => CLIPrinter.print("  " + chalk.magentaBright(url)));
-                        CLIPrinter.print(chalk.gray("───────────────────────────────"));
-                        CLIPrinter.print(chalk.gray("\nPress Ctrl+C to stop the tunnel.\n"));
-                        break;
-                    case "greetmsg":
-                        TunnelData.greet = msg.message;
-                        if ((_b = TunnelData.greet) === null || _b === void 0 ? void 0 : _b.includes("not authenticated")) {
-                            // show unauthenticated warning
-                            CLIPrinter.warn(chalk.yellowBright(TunnelData.greet));
-                        }
-                        else if ((_c = TunnelData.greet) === null || _c === void 0 ? void 0 : _c.includes("authenticated as")) {
-                            // extract email
-                            const emailMatch = /authenticated as (.+)/.exec(TunnelData.greet);
-                            if (emailMatch) {
-                                const email = emailMatch[1];
-                                CLIPrinter.info(chalk.cyanBright("Authenticated as: " + email));
-                            }
-                        }
-                        CLIPrinter.print(chalk.gray("───────────────────────────────"));
-                        break;
-                    case "status":
-                        CLIPrinter.info(msg.message || "Status update from worker");
-                        break;
-                    case "usage":
-                        TunnelData.usage = msg.usage;
-                        (_d = globalThis.__PINGGY_TUNNEL_STATS__) === null || _d === void 0 ? void 0 : _d.call(globalThis, msg.usage);
-                        break;
-                    case "TUI":
-                        if (!finalConfig.NoTUI) {
-                            const tui = withFullScreen(_jsx(TunnelTuiWrapper, { finalConfig: finalConfig, urls: TunnelData.urls, greet: TunnelData.greet }));
-                            activeTui = tui;
-                            try {
-                                yield tui.start();
-                                yield tui.waitUntilExit();
-                            }
-                            catch (e) {
-                                logger.warn("TUI error", e);
-                            }
-                            finally {
-                                activeTui = null;
-                            }
-                        }
-                        break;
-                    case "warnings":
-                        CLIPrinter.warn(msg.message);
-                        break;
-                    case "disconnected":
-                        if (activeTui && updateDisconnectState) {
-                            disconnectState = {
-                                disconnected: true,
-                                error: msg.error,
-                                messages: msg.messages
-                            };
-                            updateDisconnectState(disconnectState);
-                            try {
-                                // Wait for Ink to fully exit
-                                yield activeTui.waitUntilExit();
-                            }
-                            catch (e) {
-                                logger.warn("Failed to wait for TUI exit", e);
-                            }
-                            finally {
-                                activeTui = null;
-                            }
-                        }
-                        if ((_e = msg.messages) === null || _e === void 0 ? void 0 : _e.length) {
-                            msg.messages.forEach((m) => CLIPrinter.print(m));
-                        }
+            yield manager.startTunnel(tunnel.tunnelid);
+            CLIPrinter.stopSpinnerSuccess("Connected to Pinggy");
+            CLIPrinter.success(chalk.bold("Tunnel established!"));
+            CLIPrinter.print(chalk.gray("───────────────────────────────"));
+            TunnelData.urls = yield manager.getTunnelUrls(tunnel.tunnelid);
+            TunnelData.greet = yield manager.getTunnelGreetMessage(tunnel.tunnelid);
+            CLIPrinter.info(chalk.cyanBright("Remote URLs:"));
+            ((_a = TunnelData.urls) !== null && _a !== void 0 ? _a : []).forEach((url) => CLIPrinter.print("  " + chalk.magentaBright(url)));
+            CLIPrinter.print(chalk.gray("───────────────────────────────"));
+            if ((_b = TunnelData.greet) === null || _b === void 0 ? void 0 : _b.includes("not authenticated")) {
+                // show unauthenticated warning
+                CLIPrinter.warn(chalk.yellowBright(TunnelData.greet));
+            }
+            else if ((_c = TunnelData.greet) === null || _c === void 0 ? void 0 : _c.includes("authenticated as")) {
+                // extract email
+                const emailMatch = /authenticated as (.+)/.exec(TunnelData.greet);
+                if (emailMatch) {
+                    const email = emailMatch[1];
+                    CLIPrinter.info(chalk.cyanBright("Authenticated as: " + email));
+                }
+            }
+            CLIPrinter.print(chalk.gray("───────────────────────────────"));
+            CLIPrinter.print(chalk.gray("\nPress Ctrl+C to stop the tunnel.\n"));
+            manager.registerDisconnectListener(tunnel.tunnelid, (tunnelId, error, messages) => __awaiter(this, void 0, void 0, function* () {
+                if (activeTui && updateDisconnectState) {
+                    disconnectState = {
+                        disconnected: true,
+                        error: error,
+                        messages: messages
+                    };
+                    updateDisconnectState(disconnectState);
+                    try {
+                        // Wait for Ink to fully exit
+                        yield activeTui.waitUntilExit();
+                    }
+                    catch (e) {
+                        logger.warn("Failed to wait for TUI exit", e);
+                    }
+                    finally {
+                        activeTui = null;
+                        messages.forEach(function (m) {
+                            CLIPrinter.warn(m);
+                        });
                         // Exit ONLY after fullscreen ink has restored the terminal
                         process.exit(0);
-                        break;
-                    case "error":
-                        CLIPrinter.error(msg.message || "Unknown error from worker");
-                        break;
+                    }
+                }
+                else {
+                    messages.forEach(function (m) {
+                        CLIPrinter.warn(m);
+                    });
+                    process.exit(0);
                 }
             }));
-            worker.on("error", (err) => {
-                logger.error("Worker thread error:", err);
-                CLIPrinter.error(`${err}`);
-            });
-            worker.on("exit", (code) => {
-                if (code !== 0) {
-                    CLIPrinter.error(`Worker stopped with exit code ${code}`);
+            if (!finalConfig.NoTUI) {
+                const tui = withFullScreen(_jsx(TunnelTuiWrapper, { finalConfig: finalConfig, urls: TunnelData.urls, greet: TunnelData.greet }));
+                activeTui = tui;
+                try {
+                    yield tui.start();
+                    yield tui.waitUntilExit();
                 }
-                else {
-                    console.log("Worker exited cleanly.");
+                catch (e) {
+                    logger.warn("TUI error", e);
                 }
-            });
+                finally {
+                    activeTui = null;
+                }
+            }
         }
         catch (err) {
             CLIPrinter.stopSpinnerFail("Failed to connect");

package/dist/index.js

@@ -25,6 +25,16 @@ function main() {
             const { values, positionals, hasAnyArgs } = parseCliArgs(cliOptions);
             // Configure logger from CLI args
             configureLogger(values);
+            // Use the TunnelManager to start the tunnel
+            const manager = TunnelManager.getInstance();
+            // Keep the process alive and handle graceful shutdown
+            process.on('SIGINT', () => {
+                logger.info("SIGINT received: stopping tunnels and exiting");
+                console.log("\nStopping all tunnels...");
+                manager.stopAllTunnels();
+                console.log("Tunnels stopped. Exiting.");
+                process.exit(0);
+            });
             if (!hasAnyArgs || values.help) {
                 printHelpMessage();
                 return;
@@ -44,17 +54,7 @@ function main() {
             logger.debug("Building final config from CLI values and positionals", { values, positionals });
             const finalConfig = buildFinalConfig(values, positionals);
             logger.debug("Final configuration built", finalConfig);
-            // Use the TunnelManager to start the tunnel
-            const manager = TunnelManager.getInstance();
-            const tunnel = yield startCli(finalConfig, manager);
-            // Keep the process alive and handle graceful shutdown
-            process.on('SIGINT', () => {
-                logger.info("SIGINT received: stopping tunnels and exiting");
-                console.log("\nStopping all tunnels...");
-                manager.stopAllTunnels();
-                console.log("Tunnels stopped. Exiting.");
-                process.exit(0);
-            });
+            yield startCli(finalConfig, manager);
         }
         catch (error) {
             logger.error("Unhandled error in CLI:", error);

package/dist/logger.js

@@ -12,6 +12,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 import winston from "winston";
 import fs from "fs";
 import path from "path";
+import { pinggy } from "@pinggy/pinggy";
 // Singleton logger instance
 let _logger = null;
 function getLogger() {
@@ -22,10 +23,15 @@ function getLogger() {
 }
 export const logger = getLogger();
 export function configureLogger(values, silent = false) {
+    var _a;
     // Parse values from CLI args
     const levelStr = values.loglevel || undefined;
     const filePath = values.logfile || process.env.PINGGY_LOG_FILE || undefined;
-    const printlog = values.printlog;
+    const printlog = values.v || values.vvv || undefined;
+    const source = (_a = values.vvv) !== null && _a !== void 0 ? _a : false;
+    if (values.vv || values.vvv) {
+        enableLoggingByLogLevel();
+    }
     // Ensure log directory exists if file logging is enabled
     if (filePath) {
         const dir = path.dirname(filePath);
@@ -39,7 +45,8 @@ export function configureLogger(values, silent = false) {
         transports.push(new winston.transports.Console({
             format: winston.format.combine(winston.format.colorize(), winston.format.timestamp(), winston.format.printf((_a) => {
                 var { level, message, timestamp } = _a, meta = __rest(_a, ["level", "message", "timestamp"]);
-                return `${timestamp} [${level}] ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
+                const srcLabel = source ? "[CLI] " : "";
+                return `${timestamp} ${srcLabel}[${level}]  ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
             })),
         }));
     }
@@ -65,3 +72,6 @@ export function configureLogger(values, silent = false) {
     log.silent = transports.length === 0 || silent === true;
     return log;
 }
+function enableLoggingByLogLevel() {
+    pinggy.setDebugLogging(true);
+}

package/dist/remote_management/handler.js

@@ -14,168 +14,127 @@ export class TunnelOperations {
     constructor() {
         this.tunnelManager = TunnelManager.getInstance(); // Use singleton instance
     }
-    handleStart(config) {
-        try {
-            // Convert TunnelConfig -> PinggyOptions
-            const pinggyOpts = tunnelConfigToPinggyOptions(config);
-            const tunnelResp = this.tunnelManager.createTunnel(Object.assign(Object.assign({}, pinggyOpts), { configid: config.configid, tunnelName: config.configname }));
-            this.tunnelManager.startTunnel(tunnelResp.tunnelid);
-            const tunnelPconfig = this.tunnelManager.getTunnelConfig("", tunnelResp.tunnelid);
-            const tunnelGreetMsg = this.tunnelManager.getTunnelGreetMessage(tunnelResp.tunnelid);
-            const tlsInfo = this.tunnelManager.getLocalserverTlsInfo(tunnelResp.tunnelid);
-            // Construct TunnelResponse object
-            const tunnelStatus = {
-                tunnelid: tunnelResp.tunnelid,
-                remoteurls: [],
-                tunnelconfig: pinggyOptionsToTunnelConfig(tunnelPconfig, config.configid, tunnelResp.tunnelName, tlsInfo, tunnelGreetMsg),
-                status: newStatus(this.tunnelManager.getTunnelStatus(tunnelResp.tunnelid), TunnelErrorCodeType.NoError, ""),
-                stats: tunnelResp.instance.getLatestUsage()
+    // --- Helper to construct TunnelResponse ---
+    buildTunnelResponse(tunnelid, tunnelConfig, configid, tunnelName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [status, stats, tlsInfo, greetMsg, remoteurls] = yield Promise.all([
+                this.tunnelManager.getTunnelStatus(tunnelid),
+                this.tunnelManager.getTunnelStats(tunnelid),
+                this.tunnelManager.getLocalserverTlsInfo(tunnelid),
+                this.tunnelManager.getTunnelGreetMessage(tunnelid),
+                this.tunnelManager.getTunnelUrls(tunnelid)
+            ]);
+            return {
+                tunnelid,
+                remoteurls,
+                tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, configid, tunnelName, tlsInfo, greetMsg),
+                status: newStatus(status, TunnelErrorCodeType.NoError, ""),
+                stats
             };
-            return tunnelStatus;
-        }
-        catch (error) {
-            return newErrorResponse({
-                code: ErrorCode.ErrorStartingTunnel,
-                message: error instanceof Error ? error.message : 'Unknown error occurred while starting tunnel'
-            });
-        }
+        });
     }
-    handleUpdateConfig(config) {
+    error(code, err, fallback) {
+        return newErrorResponse({
+            code,
+            message: err instanceof Error ? err.message : fallback
+        });
+    }
+    // --- Operations ---
+    handleStart(config) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 // Convert TunnelConfig -> PinggyOptions
-                const pinggyOpts = tunnelConfigToPinggyOptions(config);
-                const managedTunnel = yield this.tunnelManager.updateConfig(Object.assign(Object.assign({}, pinggyOpts), { configid: config.configid, tunnelName: config.configname }));
-                if (!managedTunnel.tunnelConfig) {
-                    throw new Error("Failed to update tunnel configuration");
-                }
-                if (!managedTunnel.instance) {
-                    throw new Error("Tunnel instance not found after configuration update");
-                }
-                const tunnelStatus = {
-                    tunnelid: managedTunnel.tunnelid,
-                    remoteurls: [],
-                    tunnelconfig: pinggyOptionsToTunnelConfig(managedTunnel.tunnelConfig, config.configid, managedTunnel.tunnelName, this.tunnelManager.getLocalserverTlsInfo(managedTunnel.tunnelid), this.tunnelManager.getTunnelGreetMessage(managedTunnel.tunnelid)),
-                    status: newStatus(this.tunnelManager.getTunnelStatus(managedTunnel.tunnelid), TunnelErrorCodeType.NoError, ""),
-                    stats: managedTunnel.instance.getLatestUsage()
-                };
-                return tunnelStatus;
+                const opts = tunnelConfigToPinggyOptions(config);
+                const { tunnelid, instance, tunnelName } = this.tunnelManager.createTunnel(Object.assign(Object.assign({}, opts), { configid: config.configid, tunnelName: config.configname }));
+                this.tunnelManager.startTunnel(tunnelid);
+                const tunnelPconfig = yield this.tunnelManager.getTunnelConfig("", tunnelid);
+                const resp = this.buildTunnelResponse(tunnelid, tunnelPconfig, config.configid, tunnelName);
+                return resp;
+            }
+            catch (err) {
+                return this.error(ErrorCode.ErrorStartingTunnel, err, "Unknown error occurred while starting tunnel");
+            }
+        });
+    }
+    handleUpdateConfig(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const opts = tunnelConfigToPinggyOptions(config);
+                const tunnel = yield this.tunnelManager.updateConfig(Object.assign(Object.assign({}, opts), { configid: config.configid, tunnelName: config.configname }));
+                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);
             }
-            catch (error) {
-                return newErrorResponse({
-                    code: ErrorCode.InternalServerError,
-                    message: error instanceof Error ? error.message : 'Failed to update tunnel configuration'
-                });
+            catch (err) {
+                return this.error(ErrorCode.InternalServerError, err, "Failed to update tunnel configuration");
             }
         });
     }
     handleList() {
-        try {
-            const tunnels = this.tunnelManager.getAllTunnels();
-            const result = tunnels.map(tunnel => {
-                // try to get stats from manager first
-                const statsFromManager = this.tunnelManager.getTunnelStats(tunnel.tunnelid);
-                let stats = statsFromManager;
-                // if null/undefined, return default stats
-                if (!stats) {
-                    stats = newStats();
-                }
-                return {
-                    tunnelid: tunnel.tunnelid,
-                    remoteurls: tunnel.remoteurls,
-                    status: newStatus(this.tunnelManager.getTunnelStatus(tunnel.tunnelid), TunnelErrorCodeType.NoError, ""),
-                    stats: stats,
-                    // Convert PinggyOptions -> TunnelConfig
-                    tunnelconfig: pinggyOptionsToTunnelConfig(this.tunnelManager.getTunnelConfig("", tunnel.tunnelid), tunnel.configid, tunnel.tunnelName, this.tunnelManager.getLocalserverTlsInfo(tunnel.tunnelid), this.tunnelManager.getTunnelGreetMessage(tunnel.tunnelid))
-                };
-            });
-            return result;
-        }
-        catch (error) {
-            return newErrorResponse({
-                code: ErrorCode.InternalServerError,
-                message: error instanceof Error ? error.message : 'Failed to list tunnels'
-            });
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tunnels = yield this.tunnelManager.getAllTunnels();
+                return Promise.all(tunnels.map((t) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const stats = ((_a = this.tunnelManager.getTunnelStats(t.tunnelid)) !== null && _a !== void 0 ? _a : newStats());
+                    const [status, config, tlsInfo, greetMsg] = yield Promise.all([
+                        this.tunnelManager.getTunnelStatus(t.tunnelid),
+                        this.tunnelManager.getTunnelConfig("", t.tunnelid),
+                        this.tunnelManager.getLocalserverTlsInfo(t.tunnelid),
+                        this.tunnelManager.getTunnelGreetMessage(t.tunnelid)
+                    ]);
+                    return {
+                        tunnelid: t.tunnelid,
+                        remoteurls: t.remoteurls,
+                        status: newStatus(status, TunnelErrorCodeType.NoError, ""),
+                        stats,
+                        tunnelconfig: pinggyOptionsToTunnelConfig(config, t.configid, t.tunnelName, tlsInfo, greetMsg)
+                    };
+                })));
+            }
+            catch (err) {
+                return this.error(ErrorCode.InternalServerError, err, "Failed to list tunnels");
+            }
+        });
     }
     handleStop(tunnelid) {
-        try {
-            const { configid, tunnelid: stoppedTunnelId } = this.tunnelManager.stopTunnel(tunnelid);
-            const tunnelInstance = this.tunnelManager.getManagedTunnel("", tunnelid);
-            if (!tunnelInstance) {
-                throw new Error(`Tunnel instance for ID "${tunnelid}" not found`);
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { configid } = this.tunnelManager.stopTunnel(tunnelid);
+                const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
+                if (!(managed === null || managed === void 0 ? void 0 : managed.tunnelConfig))
+                    throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+                return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, configid, managed.tunnelName);
             }
-            if (!tunnelInstance.tunnelConfig) {
-                throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+            catch (err) {
+                return this.error(ErrorCode.TunnelNotFound, err, "Failed to stop tunnel");
             }
-            const tunnelResponse = {
-                tunnelid: stoppedTunnelId,
-                remoteurls: [],
-                tunnelconfig: pinggyOptionsToTunnelConfig(tunnelInstance.tunnelConfig, configid, tunnelInstance.tunnelName, this.tunnelManager.getLocalserverTlsInfo(tunnelid), this.tunnelManager.getTunnelGreetMessage(tunnelid)),
-                status: newStatus(this.tunnelManager.getTunnelStatus(stoppedTunnelId), TunnelErrorCodeType.NoError, ""),
-                stats: newStats()
-            };
-            return tunnelResponse;
-        }
-        catch (error) {
-            return newErrorResponse({
-                code: ErrorCode.TunnelNotFound,
-                message: error instanceof Error ? error.message : 'Failed to stop tunnel'
-            });
-        }
+        });
     }
     handleGet(tunnelid) {
-        try {
-            const tunnelState = this.tunnelManager.getTunnelStatus(tunnelid);
-            const tunnelInstance = this.tunnelManager.getManagedTunnel("", tunnelid);
-            if (!tunnelInstance) {
-                throw new Error(`Tunnel instance for ID "${tunnelid}" not found`);
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
+                if (!(managed === null || managed === void 0 ? void 0 : managed.tunnelConfig))
+                    throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+                return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName);
             }
-            if (!tunnelInstance.tunnelConfig) {
-                throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+            catch (err) {
+                return this.error(ErrorCode.TunnelNotFound, err, "Failed to get tunnel information");
             }
-            // TODO: directly calling to getLatestUsage() may through error if tunnel stopped earlier
-            const stats = this.tunnelManager.getTunnelStats(tunnelid) ? this.tunnelManager.getTunnelStats(tunnelid) : tunnelInstance.instance.getLatestUsage();
-            const tunnelResponse = {
-                tunnelid: tunnelid,
-                remoteurls: this.tunnelManager.getTunnelUrls(tunnelid),
-                status: newStatus(tunnelState, TunnelErrorCodeType.NoError, ""),
-                stats: stats,
-                tunnelconfig: pinggyOptionsToTunnelConfig(tunnelInstance.tunnelConfig, tunnelInstance.configid, tunnelInstance.tunnelName, this.tunnelManager.getLocalserverTlsInfo(tunnelid), this.tunnelManager.getTunnelGreetMessage(tunnelid))
-            };
-            return tunnelResponse;
-        }
-        catch (error) {
-            return newErrorResponse({
-                code: ErrorCode.TunnelNotFound,
-                message: error instanceof Error ? error.message : 'Failed to get tunnel information'
-            });
-        }
+        });
     }
     handleRestart(tunnelid) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 yield this.tunnelManager.restartTunnel(tunnelid);
-                const tunnelConfig = this.tunnelManager.getTunnelConfig("", tunnelid);
-                const tunnelInstance = this.tunnelManager.getManagedTunnel("", tunnelid);
-                if (!tunnelInstance) {
-                    throw new Error(`Tunnel instance for ID "${tunnelid}" not found`);
-                }
-                const stats = this.tunnelManager.getTunnelStats(tunnelid) ? this.tunnelManager.getTunnelStats(tunnelid) : tunnelInstance.instance.getLatestUsage();
-                const tunnelResponse = {
-                    tunnelid: tunnelid,
-                    remoteurls: this.tunnelManager.getTunnelUrls(tunnelid),
-                    tunnelconfig: pinggyOptionsToTunnelConfig(tunnelConfig, tunnelInstance.configid, tunnelInstance.tunnelName, this.tunnelManager.getLocalserverTlsInfo(tunnelid), this.tunnelManager.getTunnelGreetMessage(tunnelid)),
-                    status: newStatus(this.tunnelManager.getTunnelStatus(tunnelid), TunnelErrorCodeType.NoError, ""),
-                    stats: stats
-                };
-                return tunnelResponse;
+                const managed = this.tunnelManager.getManagedTunnel("", tunnelid);
+                if (!(managed === null || managed === void 0 ? void 0 : managed.tunnelConfig))
+                    throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+                return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configid, managed.tunnelName);
             }
-            catch (error) {
-                return newErrorResponse({
-                    code: ErrorCode.TunnelNotFound,
-                    message: error instanceof Error ? error.message : 'Failed to restart tunnel'
-                });
+            catch (err) {
+                return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
             }
         });
     }