pinggy 0.3.4 → 0.3.6

package/src/remote_management/websocket_handlers.ts

@@ -1,180 +0,0 @@
-import WebSocket from "ws";
-import { logger } from "../logger.js";
-import { ErrorCode, NewErrorResponseObject, ResponseObj, ErrorResponse, isErrorResponse, NewResponseObject } from "../types.js";
-import { TunnelOperations, TunnelResponse } from "./handler.js";
-import { GetSchema, RestartSchema, StartSchema, StopSchema, UpdateConfigSchema } from "./remote_schema.js";
-import z from "zod";
-import CLIPrinter from "../utils/printer.js";
-
-export interface ConnectionStatus {
-  success: boolean;
-  error_code?: number;
-  error_msg?: string;
-}
-
-export interface WebSocketRequest {
-  requestid: string;
-  command: string;
-  data?: string;
-}
-
-type CommandName = "start" | "stop" | "get" | "restart" | "updateconfig" | "list";
-
-export class WebSocketCommandHandler {
-  private tunnelHandler = new TunnelOperations();
-
-  private safeParse(text?: string): unknown {
-    if (!text) return undefined;
-    try {
-      return JSON.parse(text);
-    } catch (e) {
-      logger.warn("Invalid JSON payload", { error: String(e), text });
-      return undefined;
-    }
-  }
-
-  private sendResponse(ws: WebSocket, resp: ResponseObj) {
-    const payload = {
-      ...resp,
-      response: Buffer.from(resp.response || []).toString("base64"),
-    };
-    ws.send(JSON.stringify(payload));
-  }
-
-  private sendError(ws: WebSocket, req: Partial<WebSocketRequest>, message: string, code = ErrorCode.InternalServerError) {
-    const resp = NewErrorResponseObject({ code, message });
-    resp.command = req.command || "";
-    resp.requestid = req.requestid || "";
-    this.sendResponse(ws, resp);
-  }
-
-  private async handleStartReq(req: WebSocketRequest, raw: unknown): Promise<ResponseObj> {
-    const dc = StartSchema.parse(raw);
-    CLIPrinter.info("Starting tunnel with config name: " + dc.tunnelConfig.configname);
-    const result = await this.tunnelHandler.handleStart(dc.tunnelConfig);
-    return this.wrapResponse(result, req);
-  }
-
-  private async handleStopReq(req: WebSocketRequest, raw: unknown): Promise<ResponseObj> {
-    const dc = StopSchema.parse(raw);
-    CLIPrinter.info("Stopping tunnel with ID: " + dc.tunnelID);
-    const result = await this.tunnelHandler.handleStop(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-
-  private async handleGetReq(req: WebSocketRequest, raw: unknown): Promise<ResponseObj> {
-    const dc = GetSchema.parse(raw);
-    const result = await this.tunnelHandler.handleGet(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-
-  private async handleRestartReq(req: WebSocketRequest, raw: unknown): Promise<ResponseObj> {
-    const dc = RestartSchema.parse(raw);
-    const result = await this.tunnelHandler.handleRestart(dc.tunnelID);
-    return this.wrapResponse(result, req);
-  }
-
-  private async handleUpdateConfigReq(req: WebSocketRequest, raw: unknown): Promise<ResponseObj> {
-    const dc = UpdateConfigSchema.parse(raw);
-    const result = await this.tunnelHandler.handleUpdateConfig(dc.tunnelConfig);
-    return this.wrapResponse(result, req);
-  }
-
-  private async handleListReq(req: WebSocketRequest): Promise<ResponseObj> {
-    const result = await this.tunnelHandler.handleList();
-    return this.wrapResponse(result, req);
-  }
-
-  private wrapResponse(result: ResponseObj | ErrorResponse | TunnelResponse | TunnelResponse[], req: WebSocketRequest): ResponseObj {
-    if (isErrorResponse(result)) {
-      const errResp = NewErrorResponseObject(result);
-      errResp.command = req.command;
-      errResp.requestid = req.requestid;
-      return errResp;
-    }
-
-    // Temporary workaround to remove allowPreflight from response
-    const finalResult = JSON.parse(JSON.stringify(result));
-    if (Array.isArray(finalResult)) {
-      finalResult.forEach(item => {
-        if (item?.tunnelconfig) {
-          delete item.tunnelconfig.allowPreflight;
-        }
-      });
-    } else if (finalResult?.tunnelconfig) {
-      delete finalResult.tunnelconfig.allowPreflight;
-    }
-    const respObj = NewResponseObject(finalResult);
-    respObj.command = req.command;
-    respObj.requestid = req.requestid;
-    return respObj;
-  }
-
-  async handle(ws: WebSocket, req: WebSocketRequest) {
-    const cmd = (req.command || "").toLowerCase() as CommandName | string;
-    const raw = this.safeParse(req.data);
-
-    try {
-      let response: ResponseObj;
-      switch (cmd as CommandName) {
-        case "start": {
-          response = await this.handleStartReq(req, raw);
-          break;
-        }
-        case "stop": {
-          response = await this.handleStopReq(req, raw);
-          break;
-        }
-        case "get": {
-          response = await this.handleGetReq(req, raw);
-          break;
-        }
-        case "restart": {
-          response = await this.handleRestartReq(req, raw);
-          break;
-        }
-        case "updateconfig": {
-          response = await this.handleUpdateConfigReq(req, raw);
-          break;
-        }
-        case "list": {
-          response = await 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: any) {
-      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?.message || "Internal error");
-    }
-  }
-}
-
-// // Returns true if connection status is OK else sends logs and returns false
-export function handleConnectionStatusMessage(firstMessage: WebSocket.Data): boolean {
-  try {
-    const text = typeof firstMessage === 'string' ? firstMessage : firstMessage.toString();
-    const cs = JSON.parse(text) as ConnectionStatus;
-    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/src/tui/blessed/TunnelTui.ts

@@ -1,340 +0,0 @@
-import blessed from "blessed";
-import { FinalConfig, ReqResPair } from "../../types.js";
-import { TunnelUsageType } from "@pinggy/pinggy";
-import { createQrCodes } from "./qrCodeGenerator.js";
-import { createWebDebuggerConnection, WebDebuggerConnection } from "./webDebuggerConnection.js";
-import { ManagedTunnel, TunnelManager } from "../../tunnel_manager/TunnelManager.js";
-import {
-    createFullUI,
-    createSimpleUI,
-    createWarningUI,
-    UIElements,
-    MIN_WIDTH_WARNING,
-    SIMPLE_LAYOUT_THRESHOLD,
-} from "./components/UIComponents.js";
-import {
-    updateUrlsDisplay,
-    updateStatsDisplay,
-    updateRequestsDisplay,
-    updateQrCodeDisplay,
-} from "./components/DisplayUpdaters.js";
-import {
-    ModalManager,
-    showDisconnectModal,
-} from "./components/Modals.js";
-import {
-    setupKeyBindings,
-    KeyBindingsState,
-    KeyBindingsCallbacks,
-} from "./components/KeyBindings.js";
-
-interface TunnelAppProps {
-    urls: string[];
-    greet?: string;
-    tunnelConfig?: FinalConfig;
-    disconnectInfo?: {
-        disconnected: boolean;
-        error?: string;
-        messages?: string[];
-    } | null;
-    tunnelInstance?:ManagedTunnel
-}
-
-export class TunnelTui {
-    private screen: blessed.Widgets.Screen;
-    private urls: string[];
-    private greet: string;
-    private tunnelConfig: FinalConfig | undefined;
-    private disconnectInfo: TunnelAppProps["disconnectInfo"];
-
-    // State
-    private currentQrIndex: number = 0;
-    private selectedIndex: number = -1;  // -1 means no selection
-    private selectedRequestKey: number | null = null;  // Track selected request by key
-    private qrCodes: string[] = [];
-    private stats: TunnelUsageType = {
-        elapsedTime: 0,
-        numLiveConnections: 0,
-        numTotalConnections: 0,
-        numTotalReqBytes: 0,
-        numTotalResBytes: 0,
-        numTotalTxBytes: 0,
-    };
-    private pairs: ReqResPair[] = [];
-    private webDebuggerConnection: WebDebuggerConnection | null = null;
-
-    // UI Elements
-    private uiElements!: UIElements;
-    private modalManager: ModalManager = {
-        detailModal: null,
-        keyBindingsModal: null,
-        disconnectModal: null,
-        inDetailView: false,
-        keyBindingView: false,
-        inDisconnectView: false,
-        loadingBox: null,
-        loadingView: false,
-        fetchAbortController: null,
-    };
-    private tunnelInstance?: ManagedTunnel
-
-    private exitPromiseResolve: (() => void) | null = null;
-    private exitPromise: Promise<void>;
-
-    constructor(props: TunnelAppProps) {
-        this.urls = props.urls;
-        this.greet = props.greet || "";
-        this.tunnelConfig = props.tunnelConfig;
-        this.disconnectInfo = props.disconnectInfo;
-        if(props.tunnelInstance){
-            this.tunnelInstance=props.tunnelInstance
-        }
-
-        this.exitPromise = new Promise((resolve) => {
-            this.exitPromiseResolve = resolve;
-        });
-
-        this.screen = blessed.screen({
-            smartCSR: true,
-            title: "Pinggy Tunnel",
-            fullUnicode: true,
-        });
-
-        this.setupStatsListener();
-        this.setupWebDebugger();
-        this.generateQrCodes();
-        this.createUI();
-        this.setupKeyBindings();
-    }
-
-    private setupStatsListener() {
-        globalThis.__PINGGY_TUNNEL_STATS__ = (newStats: TunnelUsageType) => {
-            this.stats = { ...newStats };
-            this.updateStatsDisplay();
-        };
-    }
-
-    private clearSelection() {
-        this.selectedIndex = -1;
-        this.selectedRequestKey = null;
-    }
-
-    private setupWebDebugger() {
-        if (this.tunnelConfig?.webDebugger) {
-            this.webDebuggerConnection = createWebDebuggerConnection(
-                this.tunnelConfig.webDebugger,
-                (pairs) => {
-                    this.pairs = pairs;
-                    
-                    // If there's a selected request key, find its new index
-                    if (this.selectedRequestKey !== null) {
-                        const newIndex = pairs.findIndex(
-                            (pair) => pair.request?.key === this.selectedRequestKey
-                        );
-                        
-                        if (newIndex !== -1) {
-                            // Request still exists, update index
-                            this.selectedIndex = newIndex;
-                        } else {
-                            // Request no longer exists, clear selection
-                            this.clearSelection();
-                        }
-                    }
-                    
-                    this.updateRequestsDisplay();
-                }
-            );
-        }
-    }
-
-    private async generateQrCodes() {
-        if (this.tunnelConfig?.qrCode && this.urls.length > 0) {
-            this.qrCodes = await createQrCodes(this.urls);
-            this.updateQrCodeDisplay();
-        }
-    }
-
-    // Create the UI based on terminal size
-    private createUI() {
-        this.buildUI();
-        
-        this.screen.on("resize", () => {
-            this.handleResize();
-        });
-    }
-
-    private buildUI() {
-        const width = this.screen.width as number;
-
-        if (width < MIN_WIDTH_WARNING) {
-            this.uiElements = {
-                mainContainer: createWarningUI(this.screen),
-                urlsBox: null as any,
-                statsBox: null as any,
-                requestsBox: null as any,
-                footerBox: null as any,
-                warningBox: createWarningUI(this.screen),
-            };
-            this.screen.render();
-            return;
-        }
-
-        if (width < SIMPLE_LAYOUT_THRESHOLD) {
-            this.uiElements = createSimpleUI(this.screen, this.urls, this.greet);
-        } else {
-            this.uiElements = createFullUI(this.screen, this.urls, this.greet, this.tunnelConfig);
-        }
-
-        this.refreshDisplays();
-        this.screen.render();
-    }
-
-    private refreshDisplays() {
-        this.updateUrlsDisplay();
-        this.updateStatsDisplay();
-        this.updateRequestsDisplay();
-        this.updateQrCodeDisplay();
-    }
-
-    private updateUrlsDisplay() {
-        updateUrlsDisplay(
-            this.uiElements?.urlsBox,
-            this.screen,
-            this.urls,
-            this.currentQrIndex
-        );
-    }
-
-    private updateStatsDisplay() {
-        updateStatsDisplay(
-            this.uiElements?.statsBox,
-            this.screen,
-            this.stats
-        );
-    }
-
-    private updateRequestsDisplay() {
-        const result = updateRequestsDisplay(
-            this.uiElements?.requestsBox,
-            this.screen,
-            this.pairs,
-            this.selectedIndex
-        );
-        
-        // Update selectedIndex if it was adjusted due to trimming
-        if (result.adjustedSelectedIndex !== this.selectedIndex) {
-            if (result.adjustedSelectedIndex === -1) {
-                // Selection was cleared due to trimming
-                this.clearSelection();
-            } else {
-                // Update to new index
-                this.selectedIndex = result.adjustedSelectedIndex;
-            }
-        }
-        
-        // Update pairs if they were trimmed (different reference means trimming occurred)
-        if (result.trimmedPairs !== this.pairs) {
-            this.pairs = result.trimmedPairs;
-        }
-    }
-
-    private updateQrCodeDisplay() {
-        updateQrCodeDisplay(
-            this.uiElements?.qrCodeBox,
-            this.screen,
-            this.qrCodes,
-            this.urls,
-            this.currentQrIndex
-        );
-    }
-
-    private setupKeyBindings() {
-        const self = this;
-        
-
-        // Create a state object with getters to always get current values
-        const state: KeyBindingsState = {
-            get currentQrIndex() { return self.currentQrIndex; },
-            set currentQrIndex(value: number) { self.currentQrIndex = value; },
-            get selectedIndex() { return self.selectedIndex; },
-            set selectedIndex(value: number) { self.selectedIndex = value; },
-            get pairs() { return self.pairs; },
-            get urls() { return self.urls; },
-        };
-
-        const callbacks: KeyBindingsCallbacks = {
-            onQrIndexChange: (index: number) => {
-                self.currentQrIndex = index;
-            },
-            onSelectedIndexChange: (index: number, requestKey: number | null) => {
-                self.selectedIndex = index;
-                self.selectedRequestKey = requestKey;
-            },
-            onDestroy: () => self.destroy(),
-            updateUrlsDisplay: () => self.updateUrlsDisplay(),
-            updateQrCodeDisplay: () => self.updateQrCodeDisplay(),
-            updateRequestsDisplay: () => self.updateRequestsDisplay(),
-        };
-
-        setupKeyBindings(
-            this.screen,
-            this.modalManager,
-            state,
-            callbacks,
-            this.tunnelConfig,
-        );
-    }
-
-    private handleResize() {
-        // Destroy current UI and recreate based on new size
-        this.screen.children.forEach((child) => child.destroy());
-        this.buildUI();
-    }
-
-    public updateDisconnectInfo(info: TunnelAppProps["disconnectInfo"]) {
-        this.disconnectInfo = info;
-        if (info?.disconnected) {
-            const message = info.error 
-                ? `Error: ${info.error}\nTunnel will be closed.`
-                : info.messages?.join('\n') || 'Disconnect request received. Tunnel will be closed.';
-            
-            showDisconnectModal(
-                this.screen,
-                this.modalManager,
-                message,
-                () => this.destroy()
-            );
-        }
-    }
-
-    public start() {
-        this.screen.render();
-    }
-
-    public waitUntilExit(): Promise<void> {
-        return this.exitPromise;
-    }
-
-    public destroy() {
-        // Stop the tunnel first
-        if (this.tunnelInstance?.tunnelid) {
-            const manager = TunnelManager.getInstance();
-            manager.stopTunnel(this.tunnelInstance.tunnelid);
-        }
-
-        // Cleanup
-        delete globalThis.__PINGGY_TUNNEL_STATS__;
-
-        if (this.webDebuggerConnection) {
-            this.webDebuggerConnection.close();
-        }
-
-        this.screen.destroy();
-
-        if (this.exitPromiseResolve) {
-            this.exitPromiseResolve();
-        }
-    }
-}
-
-export default TunnelTui;

package/src/tui/blessed/components/DisplayUpdaters.ts

@@ -1,189 +0,0 @@
-import blessed from "blessed";
-import { TunnelUsageType } from "@pinggy/pinggy";
-import { ReqResPair } from "../../../types.js";
-import { getBytesInt, getStatusColor } from "../../ink/utils/utils.js";
-import { getTuiConfig } from "../config.js";
-
-/**
- * Updates the URLs display box
- */
-export function updateUrlsDisplay(
-    urlsBox: blessed.Widgets.BoxElement | undefined,
-    screen: blessed.Widgets.Screen,
-    urls: string[],
-    currentQrIndex: number
-): void {
-    if (!urlsBox) return;
-
-    let content = "{green-fg}{bold}Public URLs{/bold}{/green-fg}\n";
-    urls.forEach((url, index) => {
-        const isSelected = index === currentQrIndex;
-        const prefix = isSelected ? "→ " : "• ";
-        const color = isSelected ? "yellow" : "magenta";
-
-        if (isSelected) {
-            content += `{bold}{${color}-fg}${prefix}${url}{/${color}-fg}{/bold}\n`;
-        } else {
-            content += `{${color}-fg}${prefix}${url}{/${color}-fg}\n`;
-        }
-    });
-
-    urlsBox.setContent(content);
-    screen.render();
-}
-
-/**
- * Updates the stats display box
- */
-export function updateStatsDisplay(
-    statsBox: blessed.Widgets.BoxElement | undefined,
-    screen: blessed.Widgets.Screen,
-    stats: TunnelUsageType
-): void {
-    if (!statsBox) return;
-
-    const content = `{green-fg}{bold}Live Stats{/bold}{/green-fg}
-Elapsed: ${stats.elapsedTime}s
-Live Connections: ${stats.numLiveConnections}
-Total Connections: ${stats.numTotalConnections}
-Request: ${getBytesInt(stats.numTotalReqBytes)}
-Response: ${getBytesInt(stats.numTotalResBytes)}
-Total Transfer: ${getBytesInt(stats.numTotalTxBytes)}`;
-
-    statsBox.setContent(content);
-    statsBox.style = { ...statsBox.style };
-    (statsBox as any).parseContent();
-    screen.render();
-}
-
-/**
- * Updates the requests display box
- * This function displays HTTP requests with reversed order (latest at top):
- * - Limits the total pairs to maxRequestPairs (configurable)
- * - Shows latest requests at top when no selection (selectedIndex = -1)
- * - Ensures the selected item is always visible when there is selection
- * - selectedIndex -1 means no selection, viewport shows top (latest requests)
- */
-export function updateRequestsDisplay(
-    requestsBox: blessed.Widgets.BoxElement | undefined,
-    screen: blessed.Widgets.Screen,
-    pairs: ReqResPair[],
-    selectedIndex: number
-): { adjustedSelectedIndex: number; trimmedPairs: ReqResPair[] } {
-    const config = getTuiConfig();
-    const { maxRequestPairs, visibleRequestCount, viewportScrollMargin } = config;
-    
-    if (!requestsBox) {
-        return { adjustedSelectedIndex: selectedIndex, trimmedPairs: pairs };
-    }
-
-    // pairs array (latest first)
-    let allPairs = pairs;
-    let trimmedPairs = pairs;
-    
-    if (allPairs.length > maxRequestPairs) {
-        // Keep only the first maxRequestPairs (which are the latest ones)
-        allPairs = allPairs.slice(0, maxRequestPairs);
-        trimmedPairs = allPairs;
-    }
-
-    const totalPairs = allPairs.length;
-    
-    // Adjust selectedIndex if it's now out of bounds due to trimming
-    // If the selected item was trimmed, clear the selection
-    let adjustedSelectedIndex = selectedIndex;
-    if (adjustedSelectedIndex >= totalPairs) {
-        adjustedSelectedIndex = -1;
-    }
-
-    // Calculate viewport window
-    let viewportStart: number;
-    
-    if (totalPairs <= visibleRequestCount) {
-        // All pairs fit in the viewport
-        viewportStart = 0;
-    } else if (adjustedSelectedIndex === -1) {
-        // No selection: show latest requests (top of the list)
-        viewportStart = 0;
-    } else {
-        // Has selection: ensure selector is visible
-        viewportStart = 0;
-        
-        // If selector would be below the visible area, scroll down
-        if (adjustedSelectedIndex >= visibleRequestCount - viewportScrollMargin) {
-            viewportStart = Math.min(
-                totalPairs - visibleRequestCount,
-                adjustedSelectedIndex - viewportScrollMargin
-            );
-        }
-        
-        // If selector would be above the visible area, scroll up
-        if (adjustedSelectedIndex < viewportStart + viewportScrollMargin) {
-            viewportStart = Math.max(0, adjustedSelectedIndex - viewportScrollMargin);
-        }
-    }
-
-    const viewportEnd = Math.min(viewportStart + visibleRequestCount, totalPairs);
-    const visiblePairs = allPairs.slice(viewportStart, viewportEnd);
-
-    let content = "{yellow-fg}HTTP Requests:{/yellow-fg}";
-    
-    // Show scroll indicator if there are items above the viewport
-    if (viewportStart > 0) {
-        content += ` {gray-fg}↑ ${viewportStart} more{/gray-fg}`;
-    }
-    content += "\n";
-
-    visiblePairs.forEach((pair, i) => {
-        const globalIndex = viewportStart + i;
-        const isSelected = adjustedSelectedIndex !== -1 && adjustedSelectedIndex === globalIndex;
-        const prefix = isSelected ? "> " : "  ";
-        const method = pair.request?.method || "";
-        const uri = pair.request?.uri || "";
-        const status = pair.response?.status || "";
-        const statusColor = getStatusColor(String(status));
-
-        if (isSelected) {
-            content += `{cyan-fg}${prefix}${method} ${status} ${uri}{/cyan-fg}\n`;
-        } else if (pair.response) {
-            content += `{${statusColor}-fg}${prefix}${method} ${status} ${uri}{/${statusColor}-fg}\n`;
-        } else {
-            content += `${prefix}${method} ...${uri}\n`;
-        }
-    });
-
-    // Show scroll indicator if there are items below the viewport
-    const itemsBelow = totalPairs - viewportEnd;
-    if (itemsBelow > 0) {
-        content += `{gray-fg}  ↓ ${itemsBelow} more{/gray-fg}\n`;
-    }
-
-
-    requestsBox.setContent(content);
-    screen.render();
-    
-    return { adjustedSelectedIndex, trimmedPairs };
-}
-
-/**
- * Updates the QR code display box
- */
-export function updateQrCodeDisplay(
-    qrCodeBox: blessed.Widgets.BoxElement | undefined,
-    screen: blessed.Widgets.Screen,
-    qrCodes: string[],
-    urls: string[],
-    currentQrIndex: number
-): void {
-    if (!qrCodeBox || qrCodes.length === 0) return;
-
-    let content = `{green-fg}{bold}QR Code ${currentQrIndex + 1}/${urls.length}{/bold}{/green-fg}\n`;
-    if (urls.length > 1) {
-        content += "\n{yellow-fg}← → to switch QR codes{/yellow-fg}\n";
-    }
-    content += qrCodes[currentQrIndex] || "";
-    qrCodeBox.setContent(content);
-    qrCodeBox.style = { ...qrCodeBox.style };
-    (qrCodeBox as any).parseContent();
-    screen.render();
-}