pinggy 0.3.2 → 0.3.3

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

@@ -7,6 +7,9 @@ export interface ModalManager {
     inDetailView: boolean;
     keyBindingView: boolean;
     inDisconnectView: boolean;
+    loadingBox: blessed.Widgets.BoxElement | null;
+    loadingView: boolean;
+    fetchAbortController: AbortController | null;
 }
 
 /**
@@ -113,11 +116,13 @@ export function showKeyBindingsModal(
 {bold}Ctrl+c{/bold}    Exit
 
 Enter/Return    Open selected request
-Esc             Return to main page
+Esc             Return to main page (or close modals)
 UP (↑)          Scroll up the requests
 Down (↓)        Scroll down the requests
 Left (←)        Show qr code for previous url
 Right (→)       Show qr code for next url
+Home           Jump to top of requests
+End            Jump to bottom of requests
 Ctrl+c          Force Exit
 
 {white-bg}{black-fg}Press ESC to close{/black-fg}{/white-bg}`;
@@ -214,3 +219,84 @@ export function closeDisconnectModal(
     manager.inDisconnectView = false;
     screen.render();
 }
+
+export function showLoadingModal(
+    screen: blessed.Widgets.Screen,
+    modalManager: ModalManager,
+    message: string = "Loading..."
+): void {
+    if (modalManager.loadingView) return;
+
+    modalManager.loadingBox = blessed.box({
+        parent: screen,
+        top: "center",
+        left: "center",
+        width: "60%",
+        height: 8,
+        border: { type: "line" },
+        style: {
+            border: { fg: "yellow" },
+        },
+        tags: true,
+        content: `{center}{yellow-fg}{bold}${message}{/bold}{/yellow-fg}
+
+{gray-fg}Press ESC to cancel{/gray-fg}{/center}`,
+        valign: "middle",
+    });
+
+    modalManager.loadingView = true;
+    screen.render();
+}
+
+/**
+ * Closes the loading modal
+ */
+export function closeLoadingModal(
+    screen: blessed.Widgets.Screen,
+    modalManager: ModalManager
+): void {
+    if (!modalManager.loadingView || !modalManager.loadingBox) return;
+
+    modalManager.loadingBox.destroy();
+    modalManager.loadingBox = null;
+    modalManager.loadingView = false;
+    screen.render();
+}
+
+/**
+ * Shows an error modal with a message
+ */
+export function showErrorModal(
+    screen: blessed.Widgets.Screen,
+    modalManager: ModalManager,
+    title: string = "Error",
+    message: string
+): void {
+    // Reuse the loading box for error display
+    if (modalManager.loadingBox) {
+        modalManager.loadingBox.destroy();
+        modalManager.loadingBox = null;
+    }
+
+    modalManager.loadingBox = blessed.box({
+        parent: screen,
+        top: "center",
+        left: "center",
+        width: "60%",
+        height: 9,
+        border: { type: "line" },
+        style: {
+            border: { fg: "red" },
+        },
+        tags: true,
+        content: `{center}{red-fg}{bold}${title}{/bold}{/red-fg}
+
+{white-fg}${message}{/white-fg}
+
+{gray-fg}Press ESC to close{/gray-fg}{/center}`,
+        valign: "middle",
+    });
+
+    modalManager.loadingView = true;
+    screen.render();
+}

package/src/tui/blessed/config.ts

@@ -0,0 +1,53 @@
+/**
+ * TUI Configuration Settings
+ */
+
+export interface TuiConfig {
+    /**
+     * Maximum number of request/response pairs to keep in memory.
+     * Older requests will be removed when this limit is exceeded.
+     * Default: 100
+     */
+    maxRequestPairs: number;
+
+    /**
+     * Number of visible request items to display in the requests box.
+     * Default: 10
+     */
+    visibleRequestCount: number;
+
+    /**
+     * Margin from the viewport edge when auto-scrolling to keep selector visible.
+     * Default: 2
+     */
+    viewportScrollMargin: number;
+
+    /**
+     * Inactivity timeout in milliseconds to auto-unselect the selected row and adjust viewport to latest request.
+     * Default: 10000 (10 seconds)
+     */
+
+    inactivityHttpSelectorTimeoutMs?: number;
+}
+
+/**
+ * Default TUI configuration values
+ */
+export const defaultTuiConfig: TuiConfig = {
+    maxRequestPairs: 100,
+    visibleRequestCount: 10,
+    viewportScrollMargin: 2,
+    inactivityHttpSelectorTimeoutMs: 10000,
+};
+
+/**
+ * Get the current TUI configuration.
+ */
+export function getTuiConfig(): TuiConfig {
+    return {
+        maxRequestPairs: defaultTuiConfig.maxRequestPairs,
+        visibleRequestCount:defaultTuiConfig.visibleRequestCount,
+        viewportScrollMargin: defaultTuiConfig.viewportScrollMargin,
+        inactivityHttpSelectorTimeoutMs: defaultTuiConfig.inactivityHttpSelectorTimeoutMs,
+    };
+}

package/src/tui/blessed/headerFetcher.ts

@@ -10,7 +10,8 @@ export interface HeadersResult {
  */
 export async function fetchReqResHeaders(
     baseUrl: string,
-    key: number
+    key: number,
+    signal?: AbortSignal
 ): Promise<HeadersResult> {
     if (!baseUrl) {
         return { req: "", res: "" };
@@ -20,16 +21,22 @@ export async function fetchReqResHeaders(
         const [reqRes, resRes] = await Promise.all([
             fetch(`http://${baseUrl}/introspec/getrawrequestheader`, {
                 headers: { "X-Introspec-Key": key.toString() },
+                signal,
             }),
             fetch(`http://${baseUrl}/introspec/getrawresponseheader`, {
                 headers: { "X-Introspec-Key": key.toString() },
+                signal,
             }),
         ]);
 
         const [req, res] = await Promise.all([reqRes.text(), resRes.text()]);
         return { req, res };
     } catch (err: any) {
+        // Re-throw abort errors so caller can handle cancellation
+        if (err?.name === 'AbortError') {
+            throw err;
+        }
         logger.error("Error fetching headers:", err.message || err);
-        return { req: "", res: "" };
+        throw err;
     }
 }

package/src/tui/blessed/webDebuggerConnection.ts

@@ -1,6 +1,7 @@
 import WebSocket from "ws";
 import { ReqResPair, WebDebuggerSocketRequest } from "../../types.js";
 import { logger } from "../../logger.js";
+import { getTuiConfig } from "./config.js";
 
 export interface WebDebuggerConnection {
     close: () => void;
@@ -15,13 +16,38 @@ export interface WebDebuggerConnection {
  */
 export function createWebDebuggerConnection(
     webDebuggerUrl: string,
-    onUpdate: (pairs: Map<number, ReqResPair>) => void
+    onUpdate: (pairs: ReqResPair[]) => void
 ): WebDebuggerConnection {
     const pairs = new Map<number, ReqResPair>();
+    const pairKeys: number[] = [];
     let socket: WebSocket | null = null;
     let reconnectTimeout: NodeJS.Timeout | null = null;
     let isStopped = false;
 
+    const config = getTuiConfig();
+    const maxPairs = config.maxRequestPairs;
+
+
+    // Trim pairs to keep only the latest maxPairs entries
+    const trimPairs = () => {
+        while (pairKeys.length > maxPairs) {
+            const oldestKey = pairKeys.shift();
+            if (oldestKey !== undefined) {
+                pairs.delete(oldestKey);
+            }
+        }
+    };
+
+
+    // Add or update a pair and track its key for ordering
+    const upsertPair = (key: number, pair: ReqResPair) => {
+        if (!pairs.has(key)) {
+            pairKeys.push(key);
+        }
+        pairs.set(key, pair);
+        trimPairs();
+    };
+
     const connect = () => {
         const ws = new WebSocket(`ws://${webDebuggerUrl}/introspec/websocket`);
         socket = ws;
@@ -35,8 +61,8 @@ export function createWebDebuggerConnection(
                 const raw = data.toString();
                 const parsed = JSON.parse(raw);
                 const msg = {
-                    Req: parsed.Req || parsed.req,
-                    Res: parsed.Res || parsed.res,
+                    Req: parsed.req,
+                    Res: parsed.res,
                 } as Partial<WebDebuggerSocketRequest>;
 
                 if (msg.Req) {
@@ -45,11 +71,8 @@ export function createWebDebuggerConnection(
                     const merged: ReqResPair = {
                         request: msg.Req,
                         response: existing?.response,
-                        reqHeaders: existing?.reqHeaders ?? {},
-                        resHeaders: existing?.resHeaders ?? {},
-                        headersLoaded: existing?.headersLoaded ?? false,
                     } as ReqResPair;
-                    pairs.set(key, merged);
+                    upsertPair(key, merged);
                 }
 
                 if (msg.Res) {
@@ -58,15 +81,20 @@ export function createWebDebuggerConnection(
                     const merged: ReqResPair = {
                         request: existing?.request ?? ({} as any),
                         response: msg.Res,
-                        reqHeaders: existing?.reqHeaders ?? {},
-                        resHeaders: existing?.resHeaders ?? {},
-                        headersLoaded: existing?.headersLoaded ?? false,
                     } as ReqResPair;
-                    pairs.set(key, merged);
+                    upsertPair(key, merged);
                 }
 
-                // Notify listener with a copy of the pairs map
-                onUpdate(new Map(pairs));
+                // Notify listener with reversed array (latest first)
+                const reversedPairs: ReqResPair[] = [];
+                for (let i = pairKeys.length - 1; i >= 0; i--) {
+                    const key = pairKeys[i];
+                    const pair = pairs.get(key);
+                    if (pair) {
+                        reversedPairs.push(pair);
+                    }
+                }
+                onUpdate(reversedPairs);
             } catch (err: any) {
                 logger.error("Error parsing WebSocket message:", err.message || err);
             }

package/src/tui/ink/utils/utils.ts

@@ -6,7 +6,7 @@ export function getStatusColor(status: string): string {
 
     switch (true) {
         case statusCode >= 100 && statusCode < 200:
-            return "orange";
+            return "yellow";
         case statusCode >= 200 && statusCode < 300:
             return "green";
         case statusCode >= 300 && statusCode < 400:

package/src/tunnel_manager/TunnelManager.ts

@@ -15,7 +15,7 @@
  */
 import { ForwardingEntry, pinggy, TunnelType, type PinggyOptions, type TunnelInstance, type TunnelUsageType } from "@pinggy/pinggy";
 import { logger } from "../logger.js";
-import { AdditionalForwarding, Forwarding, TunnelWarningCode, Warning } from "../types.js";
+import { AdditionalForwarding, TunnelWarningCode, Warning } from "../types.js";
 import path from "node:path";
 import { Worker } from "node:worker_threads";
 import { fileURLToPath } from "node:url";
@@ -240,8 +240,8 @@ export class TunnelManager implements ITunnelManager {
             for (const rule of additionalForwarding) {
                 if (rule && rule.localDomain && rule.localPort && rule.remoteDomain && isValidPort(rule.localPort)) {
                     const forwardingRule: ForwardingEntry = {
-                        type: TunnelType.Http,  // In Future we can make this dynamic based on user input
-                        address: `${rule.localDomain}:${rule.localPort}`,
+                        type: rule.protocol as TunnelType,  // In Future we can make this dynamic based on user input
+                        address:`${rule.localDomain}:${rule.localPort}`,
                         listenAddress: rule.remotePort && isValidPort(rule.remotePort) ? `${rule.remoteDomain}:${rule.remotePort}` : rule.remoteDomain,
                     };
                     forwardingRules.push(forwardingRule);

package/src/types.ts

@@ -2,10 +2,11 @@ import { PinggyOptions, TunnelUsageType } from "@pinggy/pinggy";
 
 // Local representation of additional forwarding
 export interface AdditionalForwarding {
-    remoteDomain?: string;
-    remotePort?: number;
     localDomain: string;
     localPort: number;
+    remoteDomain?: string;
+    remotePort?: number;
+    protocol?: 'http' | 'tcp' | 'udp' | 'tls';
 }
 
 
@@ -63,20 +64,13 @@ export interface Status {
     warnings: Warning[];
 }
 
-export type Forwarding = {
-    remoteDomain?: string;
-    remotePort: number;
-    localDomain: string;
-    localPort: number;
-};
-
 export type FinalConfig = (PinggyOptions & { configid: string }) & {
     tunnelType: string[];
     conf?: string;
     saveconf?: string;
     serve?: string;
     remoteManagement?: string;
-    additionalForwarding?: Forwarding[];
+    additionalForwarding?: AdditionalForwarding[];
     manage?: string;
     version?: boolean;
     NoTUI?: boolean;