pinggy 0.1.0

package/dist/cli/remoteManagement.js

@@ -0,0 +1,167 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRemoteManagementWsUrl = buildRemoteManagementWsUrl;
+exports.parseRemoteManagement = parseRemoteManagement;
+exports.initiateRemoteManagement = initiateRemoteManagement;
+const ws_1 = __importDefault(require("ws"));
+const logger_1 = require("../logger");
+const websocket_handlers_1 = require("./websocket_handlers");
+const RECONNECT_SLEEP_MS = 5000; // 5 seconds
+const PING_INTERVAL_MS = 30000; // 30 seconds
+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));
+}
+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; // Exit after initiating remote management
+            }
+            catch (e) {
+                logger_1.logger.error("Failed to initiate remote management:", e);
+                return { 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
+ */
+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_1.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;
+                console.log(`Connecting to ${wsHost}`);
+                logger_1.logger.info("Connecting to remote management", { wsUrl });
+            }
+            else {
+                console.log(`Reconnecting in ${RECONNECT_SLEEP_MS / 1000} seconds.`);
+                logger_1.logger.info("Reconnecting after sleep", { seconds: RECONNECT_SLEEP_MS / 1000 });
+                yield sleep(RECONNECT_SLEEP_MS);
+                if (stopRequested)
+                    break;
+                console.log(`Connecting to ${wsHost}`);
+                logger_1.logger.info("Connecting to remote management", { wsUrl });
+            }
+            const ws = new ws_1.default(wsUrl, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            yield new Promise((resolve) => {
+                let heartbeat;
+                const startHeartbeat = () => {
+                    heartbeat = setInterval(() => {
+                        if (ws.readyState !== ws_1.default.OPEN)
+                            return;
+                        ws.ping(); // ask server for pong
+                    }, PING_INTERVAL_MS);
+                };
+                ws.on("open", () => {
+                    console.log(`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;
+                            console.log("First msg", data.toString("utf-8"));
+                            const ok = (0, websocket_handlers_1.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');
+                        console.log("WebSocket message received", { text });
+                        const req = JSON.parse(text);
+                        console.log("req in management", req);
+                        const webSocketHandler = new websocket_handlers_1.WebSocketCommandHandler();
+                        yield webSocketHandler.handle(ws, req);
+                    }
+                    catch (e) {
+                        logger_1.logger.warn("Failed handling websocket message", { error: String(e) });
+                    }
+                }));
+                ws.on('unexpected-response', (_req, res) => {
+                    if (res.statusCode === 401) {
+                        console.error("Unauthorized. Please enter a valid token.");
+                        logger_1.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 {
+                        logger_1.logger.warn("Unexpected HTTP response on WebSocket connect", { statusCode: res.statusCode });
+                        ws.close(); // Trigger 'close' to retry
+                    }
+                });
+                ws.on('close', (code, reason) => {
+                    logger_1.logger.info("WebSocket closed", { code, reason: reason.toString() });
+                    console.log("Connection closed.");
+                    clearInterval(heartbeat);
+                    resolve(); // End the promise, allowing the while loop to continue
+                });
+                ws.on('error', (err) => {
+                    logger_1.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_1.logger.info("Remote management stopped.");
+    });
+}

package/dist/cli/starCli.js

@@ -0,0 +1,62 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import CLIPrinter from "../utils/printer.js";
+import chalk from "chalk";
+import TunnelTui from "../tui/index.js";
+import { withFullScreen } from "fullscreen-ink";
+export function startCli(finalConfig, manager) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let tunnelListenerId;
+            CLIPrinter.startSpinner("Connecting to Pinggy...");
+            const tunnel = manager.createTunnel(finalConfig);
+            if (!finalConfig.NoTUI) {
+                tunnelListenerId = manager.registerStatsListener(tunnel.tunnelid, (tunnelId, stats) => {
+                    var _a;
+                    // Emit stats to TUI via global callback
+                    (_a = globalThis.__PINGGY_TUNNEL_STATS__) === null || _a === void 0 ? void 0 : _a.call(globalThis, stats);
+                });
+            }
+            yield manager.startTunnel(tunnel.tunnelid);
+            CLIPrinter.stopSpinnerSuccess("Connected to Pinggy");
+            const urls = manager.getTunnelUrls(tunnel.tunnelid);
+            const greet = manager.getTunnelGreetMessage(tunnel.tunnelid);
+            CLIPrinter.success(chalk.bold("Tunnel established!"));
+            CLIPrinter.print(chalk.gray("───────────────────────────────"));
+            CLIPrinter.info(chalk.cyanBright("Remote URLs:"));
+            urls.forEach((url) => CLIPrinter.print("  " + chalk.magentaBright(url)));
+            CLIPrinter.print(chalk.gray("───────────────────────────────"));
+            // handle greet messages
+            if (greet === null || greet === void 0 ? void 0 : greet.includes("not authenticated")) {
+                // show unauthenticated warning
+                CLIPrinter.warn(chalk.yellowBright(greet));
+            }
+            else if (greet === null || greet === void 0 ? void 0 : greet.includes("authenticated as")) {
+                // extract email
+                const emailMatch = /authenticated as (.+)/.exec(greet);
+                const email = emailMatch ? emailMatch[1] : greet;
+                CLIPrinter.info("Authenticated as: " + chalk.greenBright(email));
+            }
+            if (!finalConfig.NoTUI) {
+                const tui = withFullScreen(_jsx(TunnelTui, { urls: urls, greet: greet || "", tunnelConfig: finalConfig }));
+                yield tui.start();
+            }
+            else {
+                CLIPrinter.print(chalk.gray("\nPress Ctrl+C to stop the tunnel.\n"));
+            }
+        }
+        catch (err) {
+            CLIPrinter.stopSpinnerFail("Failed to connect");
+            CLIPrinter.error(err.message || "Unknown error");
+            throw err;
+        }
+    });
+}

package/dist/cli/websocket_handlers.js

@@ -0,0 +1,160 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketCommandHandler = void 0;
+exports.handleConnectionStatusMessage = handleConnectionStatusMessage;
+const logger_1 = require("../logger");
+const types_1 = require("../types");
+const handler_1 = require("../tunnel_manager/handler");
+const remote_schema_1 = require("../tunnel_manager/remote_schema");
+const zod_1 = __importDefault(require("zod"));
+class WebSocketCommandHandler {
+    constructor() {
+        this.tunnelHandler = new handler_1.TunnelOperations();
+    }
+    safeParse(text) {
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch (e) {
+            logger_1.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 = types_1.ErrorCode.InternalServerError) {
+        const resp = (0, types_1.NewErrorResponseObject)({ code, message });
+        resp.command = req.command || "";
+        resp.requestid = req.requestid || "";
+        this.sendResponse(ws, resp);
+    }
+    handleStartReq(req, raw) {
+        console.log("Handle Start Request :", req.requestid);
+        const dc = remote_schema_1.StartSchema.parse(raw);
+        const result = this.tunnelHandler.handleStart(dc.tunnelConfig);
+        console.log("Start result", result);
+        return this.wrapResponse(result, req);
+    }
+    handleStopReq(req, raw) {
+        const dc = remote_schema_1.StopSchema.parse(raw);
+        const result = this.tunnelHandler.handleStop(dc.tunnelID);
+        return this.wrapResponse(result, req);
+    }
+    handleGetReq(req, raw) {
+        const dc = remote_schema_1.GetSchema.parse(raw);
+        const result = this.tunnelHandler.handleGet(dc.tunnelID);
+        return this.wrapResponse(result, req);
+    }
+    handleRestartReq(req, raw) {
+        const dc = remote_schema_1.RestartSchema.parse(raw);
+        const result = this.tunnelHandler.handleRestart(dc.tunnelID);
+        return this.wrapResponse(result, req);
+    }
+    handleUpdateConfigReq(req, raw) {
+        const dc = remote_schema_1.UpdateConfigSchema.parse(raw);
+        const result = this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
+        return this.wrapResponse(result, req);
+    }
+    handleListReq(req) {
+        const result = this.tunnelHandler.handleList();
+        return this.wrapResponse(result, req);
+    }
+    wrapResponse(result, req) {
+        if ((0, types_1.isErrorResponse)(result)) {
+            console.log("Error Response:", result);
+            const errResp = (0, types_1.NewErrorResponseObject)(result);
+            errResp.command = req.command;
+            errResp.requestid = req.requestid;
+            return errResp;
+        }
+        const respObj = (0, types_1.NewResponseObject)(result);
+        respObj.command = req.command;
+        respObj.requestid = req.requestid;
+        console.log("Response Object:", respObj);
+        return respObj;
+    }
+    handle(ws, req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("request received", req);
+            const cmd = (req.command || "").toLowerCase();
+            const raw = this.safeParse(req.data);
+            try {
+                let response;
+                switch (cmd) {
+                    case "start": {
+                        response = this.handleStartReq(req, raw);
+                        break;
+                    }
+                    case "stop": {
+                        response = this.handleStopReq(req, raw);
+                        break;
+                    }
+                    case "get": {
+                        response = this.handleGetReq(req, raw);
+                        break;
+                    }
+                    case "restart": {
+                        response = this.handleRestartReq(req, raw);
+                        break;
+                    }
+                    case "updateconfig": {
+                        response = this.handleUpdateConfigReq(req, raw);
+                        break;
+                    }
+                    case "list": {
+                        response = this.handleListReq(req);
+                        break;
+                    }
+                    default:
+                        return this.sendError(ws, req, "Invalid command");
+                }
+                console.log("Sending response", response);
+                this.sendResponse(ws, response);
+            }
+            catch (e) {
+                if (e instanceof zod_1.default.ZodError) {
+                    logger_1.logger.warn("Validation failed", { cmd, issues: e.issues });
+                    return this.sendError(ws, req, "Invalid request data", types_1.ErrorCode.InvalidBodyFormatError);
+                }
+                logger_1.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");
+            }
+        });
+    }
+}
+exports.WebSocketCommandHandler = WebSocketCommandHandler;
+// // Returns true if connection status is OK else sends logs and returns false
+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";
+            console.log("Connection failed:", msg);
+            logger_1.logger.warn("Remote management connection failed", { error_code: cs.error_code, error_msg: msg });
+            return false;
+        }
+        return true;
+    }
+    catch (e) {
+        logger_1.logger.warn("Failed to parse connection status message", { error: String(e) });
+        // If parsing fails, assume connection is okay
+        return true;
+    }
+}

package/dist/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+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 { TunnelManager } from "./tunnel_manager/TunnelManager.js";
+import { printHelpMessage } from "./cli/help.js";
+import { cliOptions } from "./cli/options.js";
+import { buildFinalConfig } from "./cli/buildConfig.js";
+import { configureLogger, logger } from "./logger.js";
+import { parseRemoteManagement } from "./remote_management/remoteManagement.js";
+import { parseCliArgs } from "./utils/parseArgs.js";
+import CLIPrinter from "./utils/printer.js";
+import { startCli } from "./cli/starCli.js";
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Parse arguments from the command line
+            const { values, positionals } = parseCliArgs(cliOptions);
+            // Configure logger from CLI args
+            configureLogger(values);
+            if (values.help) {
+                printHelpMessage();
+                return;
+            }
+            // Remote management mode
+            const parseResult = yield parseRemoteManagement(values);
+            if ((parseResult === null || parseResult === void 0 ? void 0 : parseResult.ok) === false) {
+                CLIPrinter.error(parseResult.error);
+                logger.error("Failed to initiate remote management:", parseResult.error);
+                process.exit(1);
+            }
+            // Build final configuration from parsed args
+            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);
+            });
+        }
+        catch (error) {
+            logger.error("Unhandled error in CLI:", error);
+            CLIPrinter.error(error);
+        }
+    });
+}
+main();

package/dist/logger.js

@@ -0,0 +1,67 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import winston from "winston";
+import fs from "fs";
+import path from "path";
+// Singleton logger instance
+let _logger = null;
+function getLogger() {
+    if (!_logger) {
+        _logger = winston.createLogger({ level: "info", silent: true });
+    }
+    return _logger;
+}
+export const logger = getLogger();
+export function configureLogger(values, silent = false) {
+    // Parse values from CLI args
+    const levelStr = values.loglevel || undefined;
+    const filePath = values.logfile || process.env.PINGGY_LOG_FILE || undefined;
+    const printlog = values.printlog;
+    // Ensure log directory exists if file logging is enabled
+    if (filePath) {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+    }
+    const transports = [];
+    // Console transport: only if explicitly requested or env var is set
+    const stdoutEnabled = printlog === true || (process.env.PINGGY_LOG_STDOUT || "").toLowerCase() === "true";
+    if (stdoutEnabled) {
+        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) : ""}`;
+            })),
+        }));
+    }
+    // File transport
+    if (filePath) {
+        transports.push(new winston.transports.File({
+            filename: filePath,
+            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 level = (levelStr || process.env.PINGGY_LOG_LEVEL || "info").toLowerCase();
+    // Mutate the singleton logger instead of replacing it so all imports keep the same instance.
+    const log = getLogger();
+    // Remove existing transports and add the new ones
+    log.clear();
+    for (const t of transports) {
+        log.add(t);
+    }
+    log.level = level;
+    log.silent = transports.length === 0 || silent === true;
+    return log;
+}