api-response-manager 2.6.0 → 2.6.3

package/README.md

@@ -6,7 +6,7 @@
 
 Command-line interface for API Response Manager. Manage tunnels, webhooks, and projects from your terminal.
 
-**Version:** 2.6.0 | **Live Service:** https://tunnelapi.in
+**Version:** 2.6.2 | **Live Service:** https://tunnelapi.in
 
 ## Installation
 

package/commands/serve.js

@@ -443,125 +443,177 @@ async function connectFileTunnel(tunnelId, subdomain, localPort) {
   const token = api.getToken();
   const userId = config.get('userId');
 
-  const ws = new WebSocket(tunnelServerUrl);
-
-  ws.on('open', () => {
-    console.log(chalk.green('✓ Connected to tunnel server'));
-    
-    ws.send(JSON.stringify({
-      type: 'register',
-      tunnelId,
-      subdomain,
-      localPort,
-      protocol: 'http',
-      authToken: token,
-      userId
-    }));
-
-    // Heartbeat
-    setInterval(() => {
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify({ type: 'heartbeat', tunnelId, subdomain }));
-      }
-    }, 30000);
-  });
-
-  // Track total bytes transferred
+  // Track total bytes transferred (persists across reconnects)
   let totalBytesTransferred = 0;
   let limitReached = false;
+  let heartbeatInterval = null;
+  let reconnectAttempts = 0;
+  const maxReconnectAttempts = 50; // Allow many reconnects
+  let isShuttingDown = false;
 
-  ws.on('message', async (data) => {
-    const message = JSON.parse(data.toString());
+  function connect() {
+    if (isShuttingDown) return;
 
-    if (message.type === 'registered') {
-      console.log(chalk.green.bold('\n🎉 File Server is now publicly accessible!\n'));
-      console.log(chalk.white('Share this URL:'));
-      console.log(chalk.cyan.bold(`   ${message.publicUrl}\n`));
-    } else if (message.type === 'request') {
-      const timestamp = new Date().toLocaleTimeString();
+    const ws = new WebSocket(tunnelServerUrl, {
+      // Keep connection alive with WebSocket-level ping/pong
+      perMessageDeflate: false
+    });
+
+    ws.on('open', () => {
+      reconnectAttempts = 0; // Reset on successful connection
+      console.log(chalk.green('✓ Connected to tunnel server'));
       
-      // Check if limit was reached
-      if (limitReached) {
-        console.log(chalk.red(`[${timestamp}]`), chalk.red('BLOCKED'), chalk.white(message.path), chalk.red('- Transfer limit reached'));
-        ws.send(JSON.stringify({
-          type: 'response',
-          requestId: message.requestId,
-          statusCode: 429,
-          headers: { 'content-type': 'application/json' },
-          body: Buffer.from(JSON.stringify({ 
-            error: 'Monthly file transfer limit reached',
-            message: 'Upgrade your plan at https://tunnelapi.in/pricing for more transfer quota.'
-          })).toString('base64'),
-          encoding: 'base64'
-        }));
-        return;
+      ws.send(JSON.stringify({
+        type: 'register',
+        tunnelId,
+        subdomain,
+        localPort,
+        protocol: 'http',
+        authToken: token,
+        userId,
+        persistent: true // File serving tunnels should not have idle timeout
+      }));
+
+      // Clear any existing heartbeat
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
       }
 
-      console.log(chalk.gray(`[${timestamp}]`), chalk.blue(message.method), chalk.white(message.path));
-      
-      try {
-        const localUrl = `http://localhost:${localPort}${message.path}`;
+      // Heartbeat every 10 seconds to keep connection alive during large transfers
+      heartbeatInterval = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'heartbeat', tunnelId, subdomain }));
+        }
+      }, 10000);
+    });
+
+    // Respond to WebSocket-level ping from server
+    ws.on('ping', () => {
+      ws.pong();
+    });
+
+    ws.on('message', async (data) => {
+      const message = JSON.parse(data.toString());
+
+      if (message.type === 'registered') {
+        console.log(chalk.green.bold('\n🎉 File Server is now publicly accessible!\n'));
+        console.log(chalk.white('Share this URL:'));
+        console.log(chalk.cyan.bold(`   ${message.publicUrl}\n`));
+      } else if (message.type === 'request') {
+        const timestamp = new Date().toLocaleTimeString();
+        
+        // Check if limit was reached
+        if (limitReached) {
+          console.log(chalk.red(`[${timestamp}]`), chalk.red('BLOCKED'), chalk.white(message.path), chalk.red('- Transfer limit reached'));
+          ws.send(JSON.stringify({
+            type: 'response',
+            requestId: message.requestId,
+            statusCode: 429,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ 
+              error: 'Monthly file transfer limit reached',
+              message: 'Upgrade your plan at https://tunnelapi.in/pricing for more transfer quota.'
+            })).toString('base64'),
+            encoding: 'base64'
+          }));
+          return;
+        }
+
+        console.log(chalk.gray(`[${timestamp}]`), chalk.blue(message.method), chalk.white(message.path));
         
-        const response = await axios({
-          method: message.method.toLowerCase(),
-          url: localUrl,
-          headers: { ...message.headers, host: `localhost:${localPort}` },
-          data: message.body,
-          validateStatus: () => true,
-          responseType: 'arraybuffer',
-          maxRedirects: 0,
-          timeout: 30000
-        });
-
-        const cleanHeaders = { ...response.headers };
-        delete cleanHeaders['transfer-encoding'];
-        delete cleanHeaders['connection'];
-
-        const responseData = Buffer.from(response.data);
-        const bodyBase64 = responseData.toString('base64');
-        const bytesTransferred = responseData.length;
-
-        // Track file transfer usage
         try {
-          await api.trackFileTransfer(userId, bytesTransferred);
-          totalBytesTransferred += bytesTransferred;
-        } catch (trackError) {
-          if (trackError.response?.data?.limitReached) {
-            limitReached = true;
-            console.log(chalk.red.bold('\n⚠️  Monthly file transfer limit reached!'));
-            console.log(chalk.yellow('💡 Upgrade your plan at https://tunnelapi.in/pricing for more transfer quota.\n'));
+          const localUrl = `http://localhost:${localPort}${message.path}`;
+          
+          const response = await axios({
+            method: message.method.toLowerCase(),
+            url: localUrl,
+            headers: { ...message.headers, host: `localhost:${localPort}` },
+            data: message.body,
+            validateStatus: () => true,
+            responseType: 'arraybuffer',
+            maxRedirects: 0,
+            timeout: 0 // No timeout for large file transfers
+          });
+
+          const cleanHeaders = { ...response.headers };
+          delete cleanHeaders['transfer-encoding'];
+          delete cleanHeaders['connection'];
+
+          const responseData = Buffer.from(response.data);
+          const bodyBase64 = responseData.toString('base64');
+          const bytesTransferred = responseData.length;
+
+          // Track file transfer usage
+          try {
+            await api.trackFileTransfer(userId, bytesTransferred);
+            totalBytesTransferred += bytesTransferred;
+          } catch (trackError) {
+            if (trackError.response?.data?.limitReached) {
+              limitReached = true;
+              console.log(chalk.red.bold('\n⚠️  Monthly file transfer limit reached!'));
+              console.log(chalk.yellow('💡 Upgrade your plan at https://tunnelapi.in/pricing for more transfer quota.\n'));
+            }
           }
+
+          ws.send(JSON.stringify({
+            type: 'response',
+            requestId: message.requestId,
+            statusCode: response.status,
+            headers: cleanHeaders,
+            body: bodyBase64,
+            encoding: 'base64'
+          }));
+        } catch (error) {
+          console.error(chalk.red(`Error: ${error.message}`));
+          ws.send(JSON.stringify({
+            type: 'response',
+            requestId: message.requestId,
+            statusCode: 502,
+            headers: { 'content-type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ error: 'File server error' })).toString('base64'),
+            encoding: 'base64'
+          }));
         }
+      }
+    });
 
-        ws.send(JSON.stringify({
-          type: 'response',
-          requestId: message.requestId,
-          statusCode: response.status,
-          headers: cleanHeaders,
-          body: bodyBase64,
-          encoding: 'base64'
-        }));
-      } catch (error) {
-        console.error(chalk.red(`Error: ${error.message}`));
-        ws.send(JSON.stringify({
-          type: 'response',
-          requestId: message.requestId,
-          statusCode: 502,
-          headers: { 'content-type': 'application/json' },
-          body: Buffer.from(JSON.stringify({ error: 'File server error' })).toString('base64'),
-          encoding: 'base64'
-        }));
+    ws.on('error', (error) => {
+      console.error(chalk.red(`WebSocket error: ${error.message}`));
+    });
+
+    ws.on('close', (code, reason) => {
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
       }
-    }
-  });
 
-  ws.on('error', (error) => {
-    console.error(chalk.red(`WebSocket error: ${error.message}`));
-  });
+      if (isShuttingDown) {
+        console.log(chalk.yellow('Tunnel connection closed'));
+        return;
+      }
+
+      reconnectAttempts++;
+      if (reconnectAttempts <= maxReconnectAttempts) {
+        const delay = Math.min(1000 * Math.pow(2, reconnectAttempts - 1), 30000); // Exponential backoff, max 30s
+        console.log(chalk.yellow(`Connection lost. Reconnecting in ${delay / 1000}s... (attempt ${reconnectAttempts}/${maxReconnectAttempts})`));
+        setTimeout(connect, delay);
+      } else {
+        console.log(chalk.red('Max reconnection attempts reached. Please restart the serve command.'));
+      }
+    });
+
+    // Handle process shutdown
+    process.on('SIGINT', () => {
+      isShuttingDown = true;
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+      }
+      ws.close();
+    });
+  }
 
-  ws.on('close', () => {
-    console.log(chalk.yellow('Tunnel connection closed'));
-  });
+  // Start initial connection
+  connect();
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-response-manager",
-  "version": "2.6.0",
+  "version": "2.6.3",
   "description": "Command-line interface for API Response Manager",
   "main": "index.js",
   "bin": {