api-response-manager 2.3.1 → 2.5.0

package/README.md

@@ -1,12 +1,18 @@
 # ARM CLI - API Response Manager Command Line Interface
 
+[![npm version](https://img.shields.io/npm/v/api-response-manager.svg)](https://www.npmjs.com/package/api-response-manager)
+[![npm downloads](https://img.shields.io/npm/dt/api-response-manager.svg)](https://www.npmjs.com/package/api-response-manager)
+[![License: Proprietary](https://img.shields.io/badge/License-Proprietary-red.svg)](https://github.com/vijaypurohit322/api-response-manager/blob/main/LICENSE)
+
 Command-line interface for API Response Manager. Manage tunnels, webhooks, and projects from your terminal.
 
+**Version:** 2.5.0 | **Live Service:** https://tunnelapi.in
+
 ## Installation
 
 ### Option 1: Install from npm (Recommended)
 ```bash
-npm install -g @vijaypurohit322-arm/cli
+npm install -g api-response-manager
 ```
 
 After installation, verify:
@@ -33,9 +39,9 @@ arm --version
 
 ### Option 3: Use with npx (No Installation)
 ```bash
-npx @vijaypurohit322-arm/cli login
-npx @vijaypurohit322-arm/cli tunnel 3000
-npx @vijaypurohit322-arm/cli webhook
+npx api-response-manager login
+npx api-response-manager tunnel 3000
+npx api-response-manager webhook
 ```
 
 ## Quick Start
@@ -444,12 +450,31 @@ Default configuration:
 # Login
 arm login
 
-# Start HTTPS tunnel on port 3000
-arm tunnel 3000 --protocol https --ssl --subdomain myapp
+# Start tunnel on port 3000 with custom subdomain
+arm tunnel 3000 --subdomain myapp
 
 # Your local server is now accessible at:
-# https://myapp.tunnel.arm.dev
-```
+# https://myapp.free-tunnelapi.app
+
+# Output:
+# 🚇 Starting Tunnel...
+# ✔ Tunnel created successfully!
+# ┌─────────────────────────────────────────────┐
+# │  Tunnel Information                         │
+# ├─────────────────────────────────────────────┤
+# │  Name:        myapp                         │
+# │  Public URL:  https://myapp.free-tunnelapi.app│
+# │  Local Port:  3000                          │
+# └─────────────────────────────────────────────┘
+# 🎉 Tunnel Active!
+```
+
+### Tunnel Timeouts (Industry Standard)
+| Setting | Value | Description |
+|---------|-------|-------------|
+| Heartbeat | 30 seconds | CLI sends keepalive every 30s |
+| Idle Timeout | 2 hours | Closes after 2 hours of no requests |
+| Max Session | 24 hours | Requires reconnect after 24 hours |
 
 ### Secure Tunnel with OAuth Authentication
 ```bash
@@ -563,7 +588,7 @@ source ~/.bashrc
 
 **Alternative - Use npx:**
 ```bash
-npx @vijaypurohit322-arm/cli login
+npx api-response-manager login
 ```
 
 ## Publishing to npm
@@ -591,4 +616,11 @@ npm publish --access public
 
 ## License
 
-MIT License - see LICENSE file for details
+This software is proprietary. See [LICENSE](https://github.com/vijaypurohit322/api-response-manager/blob/main/LICENSE) for details.
+
+**Key Points:**
+- ✅ Personal and educational use allowed
+- ✅ Self-hosting for non-commercial use allowed
+- ❌ Commercial use requires separate license
+- ❌ Resale or redistribution prohibited
+- 📧 Contact: vijaypurohit322@gmail.com

package/commands/tunnel.js

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const ora = require('ora');
 const WebSocket = require('ws');
 const Table = require('cli-table3');
+const axios = require('axios');
 const api = require('../utils/api');
 const config = require('../utils/config');
 
@@ -38,18 +39,24 @@ async function start(port, options) {
 
     spinner.succeed(chalk.green('Tunnel created successfully!'));
 
+    // Safe string padding function
+    const safePadEnd = (str, length) => {
+      const s = String(str || '');
+      return s.length >= length ? s : s + ' '.repeat(length - s.length);
+    };
+
     console.log(chalk.gray('\n┌─────────────────────────────────────────────┐'));
     console.log(chalk.gray('│') + chalk.white.bold('  Tunnel Information                        ') + chalk.gray('│'));
     console.log(chalk.gray('├─────────────────────────────────────────────┤'));
-    console.log(chalk.gray('│') + chalk.gray('  Name:        ') + chalk.white(tunnel.name.padEnd(28)) + chalk.gray('│'));
-    console.log(chalk.gray('│') + chalk.gray('  Public URL:  ') + chalk.cyan(tunnel.publicUrl.padEnd(28)) + chalk.gray('│'));
-    console.log(chalk.gray('│') + chalk.gray('  Local Port:  ') + chalk.white(String(tunnel.localPort).padEnd(28)) + chalk.gray('│'));
-    console.log(chalk.gray('│') + chalk.gray('  Tunnel ID:   ') + chalk.yellow(tunnel._id.padEnd(28)) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.gray('  Name:        ') + chalk.white(safePadEnd(tunnel.subdomain || 'Unknown', 28)) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.gray('  Public URL:  ') + chalk.cyan(safePadEnd(tunnel.publicUrl || 'Unknown', 28)) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.gray('  Local Port:  ') + chalk.white(safePadEnd(tunnel.localPort || 'Unknown', 28)) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.gray('  Tunnel ID:   ') + chalk.yellow(safePadEnd(tunnel.id || tunnel._id || 'Unknown', 28)) + chalk.gray('│'));
     console.log(chalk.gray('└─────────────────────────────────────────────┘\n'));
 
     // Connect tunnel client
     console.log(chalk.blue('Connecting tunnel client...\n'));
-    await connectTunnelClient(tunnel._id, tunnel.subdomain, tunnel.localPort);
+    await connectTunnelClient(tunnel.id || tunnel._id, tunnel.subdomain, tunnel.localPort);
 
   } catch (error) {
     spinner.fail(chalk.red('Failed to create tunnel'));
@@ -60,12 +67,14 @@ async function start(port, options) {
 
 // Connect tunnel client
 async function connectTunnelClient(tunnelId, subdomain, localPort) {
-  const tunnelServerUrl = config.get('tunnelServerUrl') || 'ws://localhost:9000';
+  const tunnelServerUrl = config.get('tunnelServerUrl') || 'ws://localhost:8080';
   const token = api.getToken();
   const userId = config.get('userId');
 
   const ws = new WebSocket(tunnelServerUrl);
 
+  let heartbeatInterval;
+
   ws.on('open', () => {
     console.log(chalk.green('✓ Connected to tunnel server'));
     
@@ -77,6 +86,13 @@ async function connectTunnelClient(tunnelId, subdomain, localPort) {
       authToken: token,
       userId
     }));
+
+    // Send heartbeat every 30 seconds to keep connection alive (industry standard)
+    heartbeatInterval = setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'heartbeat', tunnelId, subdomain }));
+      }
+    }, 30000);
   });
 
   ws.on('message', async (data) => {
@@ -90,23 +106,69 @@ async function connectTunnelClient(tunnelId, subdomain, localPort) {
     } else if (message.type === 'request') {
       const timestamp = new Date().toLocaleTimeString();
       console.log(chalk.gray(`[${timestamp}]`), chalk.blue(message.method), chalk.white(message.path));
+      
+      // Forward request to local server
+      try {
+        const localUrl = `http://localhost:${localPort}${message.path}`;
+        const response = await axios({
+          method: message.method.toLowerCase(),
+          url: localUrl,
+          headers: message.headers || {},
+          data: message.body,
+          validateStatus: () => true // Accept any status code
+        });
+        
+        // Clean up headers to avoid conflicts
+        const cleanHeaders = { ...response.headers };
+        delete cleanHeaders['transfer-encoding'];
+        delete cleanHeaders['content-length'];
+        
+        // Send response back to tunnel server
+        ws.send(JSON.stringify({
+          type: 'response',
+          requestId: message.requestId,
+          statusCode: response.status,
+          headers: cleanHeaders,
+          body: response.data
+        }));
+      } catch (error) {
+        console.error(chalk.red(`Error forwarding request: ${error.message}`));
+        ws.send(JSON.stringify({
+          type: 'response',
+          requestId: message.requestId,
+          statusCode: 500,
+          headers: { 'Content-Type': 'application/json' },
+          body: { error: 'Tunnel client error', message: error.message }
+        }));
+      }
+    } else if (message.type === 'timeout') {
+      // Handle server-side timeout notifications
+      if (message.reason === 'idle') {
+        console.log(chalk.yellow('\n⏰ Tunnel closed due to 2 hours of inactivity.'));
+      } else if (message.reason === 'max_session') {
+        console.log(chalk.yellow('\n⏰ Tunnel session expired after 24 hours.'));
+      }
+      console.log(chalk.gray(message.message || 'Please reconnect to continue.'));
     } else if (message.type === 'error') {
       console.error(chalk.red(`Error: ${message.error}`));
     }
   });
 
   ws.on('close', () => {
+    if (heartbeatInterval) clearInterval(heartbeatInterval);
     console.log(chalk.yellow('\n⚠ Tunnel disconnected'));
     process.exit(0);
   });
 
   ws.on('error', (error) => {
+    if (heartbeatInterval) clearInterval(heartbeatInterval);
     console.error(chalk.red(`\n✗ Connection error: ${error.message}`));
     process.exit(1);
   });
 
   // Handle Ctrl+C
   process.on('SIGINT', () => {
+    if (heartbeatInterval) clearInterval(heartbeatInterval);
     console.log(chalk.yellow('\n\n⚠ Stopping tunnel...'));
     ws.close();
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-response-manager",
-  "version": "2.3.1",
+  "version": "2.5.0",
   "description": "Command-line interface for API Response Manager",
   "main": "index.js",
   "bin": {
@@ -29,7 +29,7 @@
     "developer-tools"
   ],
   "author": "Vijay Singh Purohit",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "dependencies": {
     "axios": "^1.6.2",
     "boxen": "^5.1.2",

package/utils/api.js

@@ -4,7 +4,8 @@ const chalk = require('chalk');
 
 class APIClient {
   constructor() {
-    this.baseURL = config.get('apiUrl') || 'http://localhost:5000/api';
+    // Check both API_URL and apiUrl for backwards compatibility
+    this.baseURL = config.get('API_URL') || config.get('apiUrl') || 'https://api.tunnelapi.in/api';
     this.client = axios.create({
       baseURL: this.baseURL,
       timeout: 30000,

package/utils/config.js

@@ -4,7 +4,8 @@ const path = require('path');
 const config = new Conf({
   projectName: 'arm-cli',
   defaults: {
-    apiUrl: 'http://localhost:5000/api',
+    apiUrl: 'https://api.tunnelapi.in/api',
+    API_URL: 'https://api.tunnelapi.in/api', // Support both camelCase and UPPER_CASE
     token: null,
     userId: null,
     email: null,
@@ -16,6 +17,10 @@ const config = new Conf({
       type: 'string',
       format: 'uri'
     },
+    API_URL: {
+      type: 'string',
+      format: 'uri'
+    },
     token: {
       type: ['string', 'null']
     },