added session timeout

abhisawesome · abhisawesome · commit a327ab7caab2 · 2025-08-02T12:02:47.000+05:30
diff --git a/.env.example b/.env.example
@@ -0,0 +1,14 @@
+# ProxyHub Configuration
+
+# Server Configuration
+CONNECTION_TIMEOUT_MINUTES=30    # Server-side connection timeout in minutes (0 to disable)
+SOCKET_URL=https://connect.proxyhub.cloud
+SOCKET_PATH=/socket.io
+BASE_DOMAIN=proxyhub.cloud
+PROTOCOL=https
+
+# Pricing Plan Examples:
+# Free tier: CONNECTION_TIMEOUT_MINUTES=5     # 5 minute sessions
+# Basic tier: CONNECTION_TIMEOUT_MINUTES=30   # 30 minute sessions  
+# Pro tier: CONNECTION_TIMEOUT_MINUTES=120    # 2 hour sessions
+# Premium tier: CONNECTION_TIMEOUT_MINUTES=0  # Unlimited sessions
diff --git a/packages/client/package.json b/packages/client/package.json
@@ -10,8 +10,8 @@
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "dev": "nodemon --exec \"tsx src/index.ts\" -- -p 3000 ",
-    "dev:custom": "nodemon --exec \"tsx src/index.ts\" --",
+    "dev": "tsx src/index.ts",
+    "dev:watch": "nodemon --exec \"tsx src/index.ts\" --",
     "test": "tsx src/index.ts -p 8080 -d --keep-history",
     "example-server": "node example-server.js",
     "prepublish": "npm run build"
diff --git a/packages/client/src/lib/socket.ts b/packages/client/src/lib/socket.ts
@@ -5,6 +5,36 @@ import * as http from "http";
 import ResponseChannel from "./tunnel.js";
 import * as crypto from "crypto";
 
+// Global variable to store timeout interval
+let timeoutInterval: NodeJS.Timeout | null = null;
+
+const formatTimeRemaining = (remainingMs: number): string => {
+    if (remainingMs <= 0) return '0s';
+    
+    const totalSeconds = Math.floor(remainingMs / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    
+    if (hours > 0) {
+        return `${hours}h ${minutes}m`;
+    } else if (minutes > 0) {
+        return `${minutes}m ${seconds}s`;
+    } else {
+        return `${seconds}s`;
+    }
+};
+
+const formatExpirationTime = (sessionStartTime: number, durationMs: number): string => {
+    const expirationTime = new Date(sessionStartTime + durationMs);
+    return expirationTime.toLocaleTimeString('en-US', { 
+        hour12: true, 
+        hour: 'numeric', 
+        minute: '2-digit',
+        second: '2-digit'
+    });
+};
+
 const displayTunnelInfo = (data: any) => {
     const line = '─'.repeat(80);
     console.log(chalk.cyan(line));
@@ -25,11 +55,131 @@ const displayTunnelInfo = (data: any) => {
     console.log(formatLine('Session Status', data.status || 'online', chalk.green));
     console.log(formatLine('Version', data.version || '1.0.0', chalk.white));
     console.log(formatLine('Forwarding', `${data.tunnelUrl || 'N/A'} -> http://localhost:${data.port || 'N/A'}`, chalk.cyan));
+    
+    // Display timeout information if available
+    if (data.timeout) {
+        const timeout = data.timeout;
+        if (timeout.enabled) {
+            const timeoutDisplay = `${timeout.minutes} minutes (enabled)`;
+            console.log(formatLine('Session Timeout', timeoutDisplay, chalk.yellow));
+            
+            // Show actual expiration time
+            const expirationTime = formatExpirationTime(timeout.sessionStartTime, timeout.durationMs);
+            const expirationDisplay = `🕒 ${expirationTime}`;
+            console.log(formatLine('Session Expires', expirationDisplay, chalk.cyan));
+            
+            // Start top-of-terminal countdown
+            startTopCountdown(timeout);
+        } else {
+            console.log(formatLine('Session Timeout', 'Unlimited session', chalk.green));
+        }
+    }
+    
     console.log();
     console.log(chalk.cyan(line));
     console.log();
 };
 
+let lastWarningTime = 0;
+
+const startTopCountdown = (timeoutConfig: any) => {
+    // Clear any existing interval
+    if (timeoutInterval) {
+        clearInterval(timeoutInterval);
+    }
+    
+    // Store original cursor position (if possible)
+    const saveCursor = () => process.stdout.write('\u001b[s');
+    const restoreCursor = () => process.stdout.write('\u001b[u');
+    const moveToTop = () => process.stdout.write('\u001b[1;1H');
+    const clearLine = () => process.stdout.write('\u001b[2K');
+    
+    // Try to use top-of-terminal display, fallback to warnings
+    let useTopDisplay = true;
+    
+    timeoutInterval = setInterval(() => {
+        const elapsed = Date.now() - timeoutConfig.sessionStartTime;
+        const remaining = timeoutConfig.durationMs - elapsed;
+        
+        if (remaining <= 0) {
+            // Time expired, clear interval
+            if (timeoutInterval) {
+                clearInterval(timeoutInterval);
+                timeoutInterval = null;
+            }
+            
+            if (useTopDisplay) {
+                // Clear top line
+                moveToTop();
+                clearLine();
+                restoreCursor();
+            }
+            
+            // Show final expiration message
+            console.log(chalk.red.bold('\n🔴 Session expired - Connection will be terminated'));
+            return;
+        }
+        
+        const remainingMs = remaining;
+        const shouldShowWarning = 
+            remainingMs <= 10 * 60 * 1000 && // Less than 10 minutes
+            (Date.now() - lastWarningTime) > 60000; // At least 1 minute since last warning
+        
+        if (useTopDisplay) {
+            try {
+                // Try top-of-terminal display
+                saveCursor();
+                moveToTop();
+                clearLine();
+                
+                const expirationTime = formatExpirationTime(timeoutConfig.sessionStartTime, timeoutConfig.durationMs);
+                const remainingDisplay = formatTimeRemaining(remaining);
+                let color = chalk.cyan;
+                let icon = '🕒';
+                
+                if (remaining < 2 * 60 * 1000) { // Less than 2 minutes
+                    color = chalk.red;
+                    icon = '🔴';
+                } else if (remaining < 5 * 60 * 1000) { // Less than 5 minutes
+                    color = chalk.red;
+                    icon = '⚠️';
+                } else if (remaining < 10 * 60 * 1000) { // Less than 10 minutes
+                    color = chalk.yellow;
+                    icon = '⚠️';
+                }
+                
+                process.stdout.write(color(`${icon} Session expires at: ${expirationTime} (${remainingDisplay} left)`));
+                restoreCursor();
+            } catch (error) {
+                // Fallback to warning system if top display fails
+                useTopDisplay = false;
+            }
+        }
+        
+        // Warning system (either as fallback or when time is critical)
+        if (!useTopDisplay && shouldShowWarning) {
+            showTimeoutWarning(remaining, timeoutConfig);
+            lastWarningTime = Date.now();
+        }
+        
+    }, useTopDisplay ? 30000 : 60000); // 30s for top display, 60s for warnings
+};
+
+const showTimeoutWarning = (remainingMs: number, timeoutConfig: any) => {
+    const remaining = formatTimeRemaining(remainingMs);
+    const expirationTime = formatExpirationTime(timeoutConfig.sessionStartTime, timeoutConfig.durationMs);
+    
+    if (remainingMs <= 60 * 1000) { // 1 minute
+        console.log(chalk.red.bold(`\n🔴 Session expires at ${expirationTime} (${remaining} left) - Connection will be terminated soon!`));
+    } else if (remainingMs <= 2 * 60 * 1000) { // 2 minutes
+        console.log(chalk.red.bold(`\n🔴 Session expires at ${expirationTime} (${remaining} left)`));
+    } else if (remainingMs <= 5 * 60 * 1000) { // 5 minutes
+        console.log(chalk.red(`\n⚠️  Session expires at ${expirationTime} (${remaining} left)`));
+    } else if (remainingMs <= 10 * 60 * 1000) { // 10 minutes
+        console.log(chalk.yellow(`\n⚠️  Session expires at ${expirationTime} (${remaining} left)`));
+    }
+};
+
 /**
  * Generate a stable tunnel ID that persists across reconnections
  * This ID is based on the user's machine and port to ensure consistency
@@ -76,7 +226,7 @@ const socketHandler = (option: ClientInitializationOptions) => {
         reconnection: true,
         reconnectionAttempts: 3,
         reconnectionDelay: 500,
-        timeout: 10000,
+        timeout: 10000, // 10 second connection timeout
         autoConnect: true,
         forceNew: true,
         protocols: ["websocket"],
@@ -154,6 +304,25 @@ const socketHandler = (option: ClientInitializationOptions) => {
 
     // Handle disconnection
     socket.on("disconnect", (reason) => {
+        // Clear timeout interval and top display on disconnect
+        if (timeoutInterval) {
+            clearInterval(timeoutInterval);
+            timeoutInterval = null;
+        }
+        
+        // Clear top line if it was being used
+        try {
+            const moveToTop = () => process.stdout.write('\u001b[1;1H');
+            const clearLine = () => process.stdout.write('\u001b[2K');
+            const restoreCursor = () => process.stdout.write('\u001b[u');
+            
+            moveToTop();
+            clearLine();
+            restoreCursor();
+        } catch (error) {
+            // Ignore cleanup errors
+        }
+        
         console.log(chalk.red.bold("🔌 Disconnected from ProxyHub server"), reason);
         if (option.debug) {
             printDebug("Disconnect reason", reason);
@@ -202,7 +371,7 @@ const socketHandler = (option: ClientInitializationOptions) => {
                 keepAliveMsecs: 1000,
                 maxSockets: 100,
             }),
-            timeout: 5000,
+            timeout: 5000, // 5 second timeout for local requests
         });
 
         // Prepare request body
@@ -211,6 +380,15 @@ const socketHandler = (option: ClientInitializationOptions) => {
                 ? JSON.stringify(request.body) 
                 : request.body;
 
+        // Handle request timeout
+        proxyRequest.on("timeout", () => {
+            printError(`Request timeout after 5 seconds`);
+            proxyRequest.destroy();
+            if (option.debug) {
+                printDebug("Request timeout", { timeout: 5, path: request.path });
+            }
+        });
+
         // Handle request errors
         proxyRequest.once("error", (error: Error) => {
             printError(`Request failed: ${error.message}`);
@@ -274,12 +452,46 @@ const socketHandler = (option: ClientInitializationOptions) => {
     // Handle graceful shutdown
     process.on('SIGINT', () => {
         console.log(chalk.yellow.bold('\n🛑 Shutting down ProxyHub client...'));
+        
+        // Clear timeout interval and top display
+        if (timeoutInterval) {
+            clearInterval(timeoutInterval);
+            timeoutInterval = null;
+        }
+        
+        // Clear top line if it was being used
+        try {
+            const moveToTop = () => process.stdout.write('\u001b[1;1H');
+            const clearLine = () => process.stdout.write('\u001b[2K');
+            moveToTop();
+            clearLine();
+        } catch (error) {
+            // Ignore cleanup errors
+        }
+        
         socket.disconnect();
         process.exit(0);
     });
 
     process.on('SIGTERM', () => {
         console.log(chalk.yellow.bold('\n🛑 Shutting down ProxyHub client...'));
+        
+        // Clear timeout interval and top display
+        if (timeoutInterval) {
+            clearInterval(timeoutInterval);
+            timeoutInterval = null;
+        }
+        
+        // Clear top line if it was being used
+        try {
+            const moveToTop = () => process.stdout.write('\u001b[1;1H');
+            const clearLine = () => process.stdout.write('\u001b[2K');
+            moveToTop();
+            clearLine();
+        } catch (error) {
+            // Ignore cleanup errors
+        }
+        
         socket.disconnect();
         process.exit(0);
     });
diff --git a/packages/server/src/lib/socket.ts b/packages/server/src/lib/socket.ts
@@ -106,23 +106,47 @@ class SocketHandler {
     }
     
     private setConnectionTimeout(socket: any) {
-        const timeoutDuration = 30 * 60 * 1000; // 30 minutes in milliseconds
+        // Clear any existing timeout for this socket
+        this.clearConnectionTimeout(socket.id);
+        
+        // Get timeout duration from environment variable (in minutes), default to 30 minutes
+        const timeoutMinutes = parseInt(process.env.CONNECTION_TIMEOUT_MINUTES || '30', 10);
+        
+        // If timeout is 0 or negative, disable timeout
+        if (timeoutMinutes <= 0) {
+            console.log(`Timeout disabled for socket ${socket.id} (CONNECTION_TIMEOUT_MINUTES=${timeoutMinutes})`);
+            return;
+        }
+        
+        const timeoutDuration = timeoutMinutes * 60 * 1000; // Convert minutes to milliseconds
         
         const timeout = setTimeout(() => {
-            console.log(`Connection timeout reached for socket ${socket.id}, disconnecting...`);
-            socket.emit('connection-timeout', {
-                message: 'Connection has been active for 30 minutes and will be disconnected.',
-                timeoutMinutes: 30
-            });
+            console.log(`Connection timeout reached for socket ${socket.id} after ${timeoutMinutes} minutes, disconnecting...`);
             
-            // Give client 5 seconds to handle the timeout message, then disconnect
-            setTimeout(() => {
-                socket.disconnect(true);
-            }, 5000);
+            // Check if socket is still connected before emitting
+            if (socket.connected) {
+                socket.emit('connection-timeout', {
+                    message: `Connection has been active for ${timeoutMinutes} minutes and will be disconnected.`,
+                    timeoutMinutes: timeoutMinutes
+                });
+                
+                // Give client 5 seconds to handle the timeout message, then disconnect
+                setTimeout(() => {
+                    if (socket.connected) {
+                        console.log(`Forcefully disconnecting socket ${socket.id} after timeout`);
+                        socket.disconnect(true);
+                    }
+                }, 5000);
+            } else {
+                console.log(`Socket ${socket.id} already disconnected, skipping timeout disconnect`);
+            }
+            
+            // Clean up the timeout reference
+            this.connectionTimeouts.delete(socket.id);
         }, timeoutDuration);
         
         this.connectionTimeouts.set(socket.id, timeout);
-        console.log(`Set 30-minute timeout for socket ${socket.id}`);
+        console.log(`Set ${timeoutMinutes}-minute timeout for socket ${socket.id} (timeout in ${timeoutDuration}ms)`);
     }
     
     private clearConnectionTimeout(socketId: string) {
@@ -205,9 +229,20 @@ class SocketHandler {
                 const tunnelInfo = this.getTunnelInfo(data.stableTunnelId);
                 console.log('Generated tunnel info:', tunnelInfo);
 
+                // Get timeout configuration for client display
+                const timeoutMinutes = parseInt(process.env.CONNECTION_TIMEOUT_MINUTES || '30', 10);
+                const timeoutEnabled = timeoutMinutes > 0;
+                const sessionStartTime = Date.now();
+
                 socket.emit('on-connect-tunnel', {
                     id: data.stableTunnelId,
-                    ...tunnelInfo
+                    ...tunnelInfo,
+                    timeout: {
+                        minutes: timeoutMinutes,
+                        enabled: timeoutEnabled,
+                        sessionStartTime: sessionStartTime,
+                        durationMs: timeoutEnabled ? timeoutMinutes * 60 * 1000 : 0
+                    }
                 });
             });
 
