pinggy 0.1.0

package/dist/remote_management/handler.js

@@ -0,0 +1,182 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ErrorCode, newErrorResponse, newStatus, TunnelErrorCodeType, newStats } from "../types.js";
+import { TunnelManager } from "../tunnel_manager/TunnelManager.js";
+import { pinggyOptionsToTunnelConfig, tunnelConfigToPinggyOptions } from "./remote_schema.js";
+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()
+            };
+            return tunnelStatus;
+        }
+        catch (error) {
+            return newErrorResponse({
+                code: ErrorCode.ErrorStartingTunnel,
+                message: error instanceof Error ? error.message : 'Unknown error occurred while starting tunnel'
+            });
+        }
+    }
+    handleUpdateConfig(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;
+            }
+            catch (error) {
+                return newErrorResponse({
+                    code: ErrorCode.InternalServerError,
+                    message: error instanceof Error ? error.message : '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'
+            });
+        }
+    }
+    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`);
+            }
+            if (!tunnelInstance.tunnelConfig) {
+                throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+            }
+            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`);
+            }
+            if (!tunnelInstance.tunnelConfig) {
+                throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+            }
+            // 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;
+            }
+            catch (error) {
+                return newErrorResponse({
+                    code: ErrorCode.TunnelNotFound,
+                    message: error instanceof Error ? error.message : 'Failed to restart tunnel'
+                });
+            }
+        });
+    }
+}

package/dist/remote_management/remoteManagement.js

@@ -0,0 +1,159 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import WebSocket from "ws";
+import { logger } from "../logger.js";
+import { handleConnectionStatusMessage, WebSocketCommandHandler } from "./websocket_handlers.js";
+import CLIPrinter from "../utils/printer.js";
+const RECONNECT_SLEEP_MS = 5000; // 5 seconds
+const PING_INTERVAL_MS = 30000; // 30 seconds
+export function buildRemoteManagementWsUrl(manage) {
+    let baseUrl = (manage || "dashboard.pinggy.io").trim();
+    if (!(baseUrl.startsWith("ws://") || baseUrl.startsWith("wss://"))) {
+        baseUrl = "wss://" + baseUrl;
+    }
+    // Avoid duplicate slashes when concatenating
+    const trimmed = baseUrl.replace(/\/$/, "");
+    return `${trimmed}/backend/api/v1/remote-management/connect`;
+}
+function extractHostname(u) {
+    try {
+        const url = new URL(u);
+        return url.host;
+    }
+    catch (_a) {
+        return u;
+    }
+}
+function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+}
+export function parseRemoteManagement(values) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rmToken = values["remote-management"];
+        if (typeof rmToken === "string" && rmToken.trim().length > 0) {
+            const manageHost = values["manage"];
+            try {
+                yield initiateRemoteManagement(rmToken, manageHost);
+                return { ok: true };
+            }
+            catch (e) {
+                logger.error("Failed to initiate remote management:", e);
+                return { ok: false, error: e };
+            }
+        }
+    });
+}
+/**
+ * Initiate remote management mode with a WebSocket connection.
+ * - Connect with Authorization: Bearer <token>
+ * - On HTTP 401: print Unauthorized and exit
+ * - On other failures: retry every 15 seconds
+ * - Keep running until closed or SIGINT
+ */
+export function initiateRemoteManagement(token, manage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!token || token.trim().length === 0) {
+            throw new Error("Remote management token is required (use --remote-management <TOKEN>)");
+        }
+        const wsUrl = buildRemoteManagementWsUrl(manage);
+        const wsHost = extractHostname(wsUrl);
+        logger.info("Remote management mode enabled.");
+        // Ensure process exits cleanly on Ctrl+C
+        let stopRequested = false;
+        const sigintHandler = () => { stopRequested = true; };
+        process.once('SIGINT', sigintHandler);
+        let firstTry = true;
+        while (!stopRequested) {
+            if (firstTry) {
+                firstTry = false;
+                CLIPrinter.print(`Connecting to ${wsHost}`);
+                logger.info("Connecting to remote management", { wsUrl });
+            }
+            else {
+                CLIPrinter.warn(`Reconnecting in ${RECONNECT_SLEEP_MS / 1000} seconds.`);
+                logger.info("Reconnecting after sleep", { seconds: RECONNECT_SLEEP_MS / 1000 });
+                yield sleep(RECONNECT_SLEEP_MS);
+                if (stopRequested)
+                    break;
+                CLIPrinter.print(`Connecting to ${wsHost}`);
+                logger.info("Connecting to remote management", { wsUrl });
+            }
+            const ws = new WebSocket(wsUrl, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            yield new Promise((resolve) => {
+                let heartbeat;
+                const startHeartbeat = () => {
+                    heartbeat = setInterval(() => {
+                        if (ws.readyState !== WebSocket.OPEN)
+                            return;
+                        ws.ping(); // ask server for pong
+                    }, PING_INTERVAL_MS);
+                };
+                ws.on("open", () => {
+                    CLIPrinter.success(`Connected to ${wsHost}`);
+                    startHeartbeat();
+                });
+                // Respond to server pings
+                ws.on("ping", () => ws.pong());
+                let firstMessage = true;
+                ws.on('message', (data) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        if (firstMessage) {
+                            firstMessage = false;
+                            const ok = handleConnectionStatusMessage(data);
+                            if (!ok) {
+                                // The status message itself indicates failure, so close and retry.
+                                ws.close();
+                            }
+                            return; // Wait for the next message (commands)
+                        }
+                        const text = data.toString('utf8');
+                        const req = JSON.parse(text);
+                        const webSocketHandler = new WebSocketCommandHandler();
+                        yield webSocketHandler.handle(ws, req);
+                    }
+                    catch (e) {
+                        logger.warn("Failed handling websocket message", { error: String(e) });
+                    }
+                }));
+                ws.on('unexpected-response', (_req, res) => {
+                    if (res.statusCode === 401) {
+                        CLIPrinter.error("Unauthorized. Please enter a valid token.");
+                        logger.error("Unauthorized (401) on remote management connect");
+                        stopRequested = true; // Mark to stop retrying
+                        ws.close(); // This will trigger 'close' and resolve the promise
+                    }
+                    else {
+                        CLIPrinter.warn(`Unexpected HTTP response ${res.statusCode} from server. Retrying...`);
+                        logger.warn("Unexpected HTTP response on WebSocket connect", { statusCode: res.statusCode });
+                        ws.close(); // Trigger 'close' to retry
+                    }
+                });
+                ws.on('close', (code, reason) => {
+                    logger.info("WebSocket closed", { code, reason: reason.toString() });
+                    CLIPrinter.warn(`Disconnected from remote management (code: ${code}).Retrying...`);
+                    clearInterval(heartbeat);
+                    resolve(); // End the promise, allowing the while loop to continue
+                });
+                ws.on('error', (err) => {
+                    CLIPrinter.error(err);
+                    logger.warn("WebSocket error", { error: err.message });
+                    clearInterval(heartbeat);
+                    resolve(); // End the promise, allowing the while loop to continue
+                });
+            });
+            if (stopRequested)
+                break;
+        }
+        process.removeListener('SIGINT', sigintHandler);
+        logger.info("Remote management stopped.");
+    });
+}

package/dist/remote_management/remote_schema.js

@@ -0,0 +1,122 @@
+import { z } from "zod";
+export const HeaderModificationSchema = z.object({
+    key: z.string(),
+    value: z.array(z.string()).optional(),
+    type: z.enum(["add", "remove", "update"]),
+});
+// TunnelConfig schema
+export const TunnelConfigSchema = z.object({
+    allowpreflight: z.boolean(),
+    autoreconnect: z.boolean(),
+    basicauth: z.array(z.object({ username: z.string(), password: z.string() })).nullable(),
+    bearerauth: z.string().nullable(),
+    configid: z.string().uuid(),
+    configname: z.string(),
+    greetmsg: z.string().optional(),
+    force: z.boolean(),
+    forwardedhost: z.string(),
+    fullRequestUrl: z.boolean(),
+    headermodification: z.array(HeaderModificationSchema),
+    httpsOnly: z.boolean(),
+    internalwebdebuggerport: z.number(),
+    ipwhitelist: z.array(z.string()).nullable(),
+    localport: z.number(),
+    localsservertls: z.union([z.boolean(), z.string()]),
+    localservertlssni: z.string().nullable(),
+    regioncode: z.string(),
+    noReverseProxy: z.boolean(),
+    serveraddress: z.string(),
+    serverport: z.number(),
+    statusCheckInterval: z.number(),
+    token: z.string(),
+    tunnelTimeout: z.number(),
+    type: z.enum(["http" /* TunnelType.Http */, "tcp" /* TunnelType.Tcp */, "udp" /* TunnelType.Udp */, "tls" /* TunnelType.Tls */, "tlstcp" /* TunnelType.TlsTcp */]),
+    webdebuggerport: z.number(),
+    xff: z.string(),
+});
+/**
+ * Schema for the payload used to manage tunnels using websocket.
+ *
+ * @remarks
+ * This schema is intended for input validation (e.g. API request bodies or remote management socket data)
+ * and enforces structural and primitive constraints but does not
+ * perform side effects.
+ */
+export const StartSchema = z.object({
+    tunnelID: z.string().uuid().nullable().optional(),
+    tunnelConfig: TunnelConfigSchema,
+});
+export const StopSchema = z.object({
+    tunnelID: z.string().min(1),
+});
+export const GetSchema = StopSchema;
+export const RestartSchema = StopSchema;
+export const UpdateConfigSchema = z.object({
+    tunnelConfig: TunnelConfigSchema,
+});
+export function tunnelConfigToPinggyOptions(config) {
+    return {
+        token: config.token || "",
+        serverAddress: config.serveraddress || "free.pinggy.io",
+        forwarding: `${config.forwardedhost || "localhost"}:${config.localport}`,
+        webDebugger: config.webdebuggerport ? `localhost:${config.webdebuggerport}` : "",
+        tunnelType: Array.isArray(config.type) ? config.type : [config.type || "http" /* TunnelType.Http */],
+        ipWhitelist: config.ipwhitelist || [],
+        basicAuth: config.basicauth ? config.basicauth : [],
+        bearerTokenAuth: config.bearerauth ? [config.bearerauth] : [],
+        headerModification: config.headermodification,
+        xForwardedFor: !!config.xff,
+        httpsOnly: config.httpsOnly,
+        originalRequestUrl: config.fullRequestUrl,
+        allowPreflight: config.allowpreflight,
+        reverseProxy: config.noReverseProxy,
+        force: config.force,
+        optional: {
+            sniServerName: config.localservertlssni || "",
+        },
+    };
+}
+export function pinggyOptionsToTunnelConfig(opts, configid, configName, localserverTls, greetMsg) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const forwarding = Array.isArray(opts.forwarding) ? String(opts.forwarding[0].address).replace("//", "").replace(/\/$/, "") : String(opts.forwarding).replace("//", "").replace(/\/$/, "");
+    const tunnelType = Array.isArray(opts.tunnelType)
+        ? opts.tunnelType[0]
+        : ((_a = opts.tunnelType) !== null && _a !== void 0 ? _a : "http");
+    const parsedTokens = opts.bearerTokenAuth ? (Array.isArray(opts.bearerTokenAuth)
+        ? opts.bearerTokenAuth : JSON.parse(opts.bearerTokenAuth)) : [];
+    return {
+        allowpreflight: (_b = opts.allowPreflight) !== null && _b !== void 0 ? _b : false,
+        autoreconnect: true,
+        basicauth: opts.basicAuth && Object.keys(opts.basicAuth).length
+            ? opts.basicAuth
+            : null,
+        bearerauth: parsedTokens.length ? parsedTokens.join(',') : null,
+        configid: configid,
+        configname: configName,
+        greetmsg: greetMsg || "",
+        force: (_c = opts.force) !== null && _c !== void 0 ? _c : false,
+        forwardedhost: (forwarding === null || forwarding === void 0 ? void 0 : forwarding.split(":")[1]) || "localhost",
+        fullRequestUrl: (_d = opts.originalRequestUrl) !== null && _d !== void 0 ? _d : false,
+        headermodification: opts.headerModification || [], //structured list
+        httpsOnly: (_e = opts.httpsOnly) !== null && _e !== void 0 ? _e : false,
+        internalwebdebuggerport: 0,
+        ipwhitelist: opts.ipWhitelist
+            ? (Array.isArray(opts.ipWhitelist)
+                ? opts.ipWhitelist
+                : JSON.parse(opts.ipWhitelist))
+            : null,
+        localport: parseInt((forwarding === null || forwarding === void 0 ? void 0 : forwarding.split(":")[2]) || "0", 10),
+        localservertlssni: null,
+        regioncode: "",
+        noReverseProxy: (_f = opts.reverseProxy) !== null && _f !== void 0 ? _f : false,
+        serveraddress: opts.serverAddress || "free.pinggy.io",
+        serverport: 0,
+        statusCheckInterval: 0,
+        token: opts.token || "",
+        tunnelTimeout: 0,
+        type: tunnelType,
+        webdebuggerport: Number((_g = opts.webDebugger) === null || _g === void 0 ? void 0 : _g.split(":")[0]) || 0,
+        xff: opts.xForwardedFor ? "1" : "",
+        localsservertls: localserverTls || false
+    };
+}

package/dist/remote_management/websocket_handlers.js

@@ -0,0 +1,163 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { logger } from "../logger.js";
+import { ErrorCode, NewErrorResponseObject, isErrorResponse, NewResponseObject } from "../types.js";
+import { TunnelOperations } from "./handler.js";
+import { GetSchema, RestartSchema, StartSchema, StopSchema, UpdateConfigSchema } from "./remote_schema.js";
+import z from "zod";
+import CLIPrinter from "../utils/printer.js";
+export class WebSocketCommandHandler {
+    constructor() {
+        this.tunnelHandler = new TunnelOperations();
+    }
+    safeParse(text) {
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch (e) {
+            logger.warn("Invalid JSON payload", { error: String(e), text });
+            return undefined;
+        }
+    }
+    sendResponse(ws, resp) {
+        const payload = Object.assign(Object.assign({}, resp), { response: Buffer.from(resp.response || []).toString("base64") });
+        ws.send(JSON.stringify(payload));
+    }
+    sendError(ws, req, message, code = ErrorCode.InternalServerError) {
+        const resp = NewErrorResponseObject({ code, message });
+        resp.command = req.command || "";
+        resp.requestid = req.requestid || "";
+        this.sendResponse(ws, resp);
+    }
+    handleStartReq(req, raw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dc = StartSchema.parse(raw);
+            const result = yield this.tunnelHandler.handleStart(dc.tunnelConfig);
+            return this.wrapResponse(result, req);
+        });
+    }
+    handleStopReq(req, raw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dc = StopSchema.parse(raw);
+            const result = yield this.tunnelHandler.handleStop(dc.tunnelID);
+            return this.wrapResponse(result, req);
+        });
+    }
+    handleGetReq(req, raw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dc = GetSchema.parse(raw);
+            const result = yield this.tunnelHandler.handleGet(dc.tunnelID);
+            return this.wrapResponse(result, req);
+        });
+    }
+    handleRestartReq(req, raw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dc = RestartSchema.parse(raw);
+            const result = yield this.tunnelHandler.handleRestart(dc.tunnelID);
+            return this.wrapResponse(result, req);
+        });
+    }
+    handleUpdateConfigReq(req, raw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dc = UpdateConfigSchema.parse(raw);
+            const result = yield this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
+            return this.wrapResponse(result, req);
+        });
+    }
+    handleListReq(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.tunnelHandler.handleList();
+            return this.wrapResponse(result, req);
+        });
+    }
+    wrapResponse(result, req) {
+        if (isErrorResponse(result)) {
+            const errResp = NewErrorResponseObject(result);
+            errResp.command = req.command;
+            errResp.requestid = req.requestid;
+            return errResp;
+        }
+        const respObj = NewResponseObject(result);
+        respObj.command = req.command;
+        respObj.requestid = req.requestid;
+        return respObj;
+    }
+    handle(ws, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cmd = (req.command || "").toLowerCase();
+            const raw = this.safeParse(req.data);
+            try {
+                let response;
+                switch (cmd) {
+                    case "start": {
+                        response = yield this.handleStartReq(req, raw);
+                        break;
+                    }
+                    case "stop": {
+                        response = yield this.handleStopReq(req, raw);
+                        break;
+                    }
+                    case "get": {
+                        response = yield this.handleGetReq(req, raw);
+                        break;
+                    }
+                    case "restart": {
+                        response = yield this.handleRestartReq(req, raw);
+                        break;
+                    }
+                    case "updateconfig": {
+                        response = yield this.handleUpdateConfigReq(req, raw);
+                        break;
+                    }
+                    case "list": {
+                        response = yield this.handleListReq(req);
+                        break;
+                    }
+                    default:
+                        if (typeof req.command === 'string') {
+                            logger.warn("Unknown command", { command: req.command });
+                        }
+                        return this.sendError(ws, req, "Invalid command");
+                }
+                logger.debug("Sending response", { command: response.command, requestid: response.requestid });
+                this.sendResponse(ws, response);
+            }
+            catch (e) {
+                if (e instanceof z.ZodError) {
+                    logger.warn("Validation failed", { cmd, issues: e.issues });
+                    return this.sendError(ws, req, "Invalid request data", ErrorCode.InvalidBodyFormatError);
+                }
+                logger.error("Error handling command", { cmd, error: String(e) });
+                return this.sendError(ws, req, (e === null || e === void 0 ? void 0 : e.message) || "Internal error");
+            }
+        });
+    }
+}
+// // Returns true if connection status is OK else sends logs and returns false
+export function handleConnectionStatusMessage(firstMessage) {
+    try {
+        const text = typeof firstMessage === 'string' ? firstMessage : firstMessage.toString();
+        const cs = JSON.parse(text);
+        if (!cs.success) {
+            const msg = cs.error_msg || "Connection failed";
+            CLIPrinter.warn(`Connection failed: ${msg}`);
+            logger.warn("Remote management connection failed", { error_code: cs.error_code, error_msg: msg });
+            return false;
+        }
+        return true;
+    }
+    catch (e) {
+        logger.warn("Failed to parse connection status message", { error: String(e) });
+        // If parsing fails, assume connection is okay
+        return true;
+    }
+}

package/dist/tui/asciArt.js

@@ -0,0 +1,7 @@
+export const asciiArtPinggyLogo = `
+██████╗ ██╗███╗   ██╗ ██████╗  ██████╗██╗   ██╗
+██╔══██╗██║████╗  ██║██╔════╝ ██╔════╝╚██╗ ██╔╝
+██████╔╝██║██╔██╗ ██║██║  ███╗██║  ███╗╚████╔╝ 
+██╔═══╝ ██║██║╚██╗██║██║   ██║██║   ██║ ╚██╔╝  
+██║     ██║██║ ╚████║╚██████╔╝╚██████╔╝  ██║   
+╚═╝     ╚═╝╚═╝  ╚═══╝ ╚═════╝  ╚═════╝   ╚═╝   `;