api-response-manager 2.3.0 → 2.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vijay Singh Purohit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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/bin/arm.js

@@ -17,6 +17,10 @@ const webhookCommand = require('../commands/webhook');
 const projectCommand = require('../commands/project');
 const logsCommand = require('../commands/logs');
 const configCommand = require('../commands/config');
+const ipWhitelistCommand = require('../commands/ipWhitelist');
+const ipBlacklistCommand = require('../commands/ipBlacklist');
+const rateLimitCommand = require('../commands/rateLimit');
+const healthCommand = require('../commands/health');
 
 // CLI setup
 program
@@ -127,6 +131,85 @@ program
   .option('--tls', 'Enable TLS for ingress')
   .action(tunnelCommand.configureIngress);
 
+// IP Whitelist commands
+program
+  .command('tunnel:ip-whitelist:add')
+  .description('Add IP to tunnel whitelist')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .argument('<ip>', 'IP address or CIDR range (e.g., 192.168.1.100 or 10.0.0.0/8)')
+  .action(ipWhitelistCommand.add);
+
+program
+  .command('tunnel:ip-whitelist:remove')
+  .description('Remove IP from tunnel whitelist')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .argument('<ip>', 'IP address or CIDR range')
+  .action(ipWhitelistCommand.remove);
+
+program
+  .command('tunnel:ip-whitelist:list')
+  .description('List tunnel IP whitelist')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .action(ipWhitelistCommand.list);
+
+program
+  .command('tunnel:ip-whitelist:clear')
+  .description('Clear tunnel IP whitelist')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .action(ipWhitelistCommand.clear);
+
+// IP Blacklist commands
+program
+  .command('tunnel:ip-blacklist:add')
+  .description('Add IP to tunnel blacklist')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .argument('<ip>', 'IP address or CIDR range')
+  .action(ipBlacklistCommand.add);
+
+program
+  .command('tunnel:ip-blacklist:remove')
+  .description('Remove IP from tunnel blacklist')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .argument('<ip>', 'IP address or CIDR range')
+  .action(ipBlacklistCommand.remove);
+
+program
+  .command('tunnel:ip-blacklist:list')
+  .description('List tunnel IP blacklist')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .action(ipBlacklistCommand.list);
+
+program
+  .command('tunnel:ip-blacklist:clear')
+  .description('Clear tunnel IP blacklist')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .action(ipBlacklistCommand.clear);
+
+// Rate Limit commands
+program
+  .command('tunnel:rate-limit')
+  .description('Configure tunnel rate limits')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .option('--rpm <number>', 'Requests per minute')
+  .option('--rph <number>', 'Requests per hour')
+  .option('--rpd <number>', 'Requests per day')
+  .option('--enable', 'Enable rate limiting')
+  .option('--disable', 'Disable rate limiting')
+  .action(rateLimitCommand.configure);
+
+program
+  .command('tunnel:rate-limit:show')
+  .description('Show tunnel rate limits')
+  .argument('<tunnelId>', 'Tunnel ID')
+  .action(rateLimitCommand.show);
+
+// Health check command
+program
+  .command('health')
+  .description('Check server health')
+  .option('-d, --detailed', 'Show detailed health information')
+  .action(healthCommand.check);
+
 // Webhook commands
 program
   .command('webhook')

package/commands/health.js

@@ -0,0 +1,114 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const axios = require('axios');
+const config = require('../utils/config');
+
+// Check basic health
+async function check(options) {
+  const apiUrl = config.get('apiUrl') || 'http://localhost:5000/api';
+  // Remove /api prefix since apiUrl already includes it
+  const endpoint = options.detailed ? '/health/detailed' : '/health';
+  
+  const spinner = ora('Checking server health...').start();
+
+  try {
+    const response = await axios.get(`${apiUrl}${endpoint}`, {
+      validateStatus: (status) => status < 500 || status === 503 // Accept 503 for degraded status
+    });
+    const health = response.data;
+
+    spinner.stop();
+
+    if (options.detailed) {
+      displayDetailedHealth(health);
+    } else {
+      displayBasicHealth(health);
+    }
+
+    // Exit with 0 for ok/degraded, 1 for error
+    process.exit(health.status === 'ok' || health.status === 'degraded' ? 0 : 1);
+  } catch (error) {
+    spinner.fail(chalk.red('Server is unreachable'));
+    console.error(chalk.red(`\n✗ ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+function displayBasicHealth(health) {
+  console.log(chalk.blue.bold('\n🏥 Server Health Check\n'));
+  
+  const statusColor = health.status === 'ok' ? chalk.green : chalk.red;
+  const statusIcon = health.status === 'ok' ? '✓' : '✗';
+  
+  console.log(chalk.gray('┌─────────────────────────────────────┐'));
+  console.log(chalk.gray('│') + chalk.white('  Status:       ') + statusColor(`${statusIcon} ${health.status.toUpperCase()}`).padEnd(28) + chalk.gray('│'));
+  console.log(chalk.gray('│') + chalk.white('  Uptime:       ') + chalk.cyan(formatUptime(health.uptime)).padEnd(20) + chalk.gray('│'));
+  console.log(chalk.gray('│') + chalk.white('  Environment:  ') + chalk.cyan(health.environment).padEnd(20) + chalk.gray('│'));
+  console.log(chalk.gray('│') + chalk.white('  Timestamp:    ') + chalk.gray(new Date(health.timestamp).toLocaleString()).padEnd(20) + chalk.gray('│'));
+  console.log(chalk.gray('└─────────────────────────────────────┘\n'));
+}
+
+function displayDetailedHealth(health) {
+  console.log(chalk.blue.bold('\n🏥 Detailed Server Health Check\n'));
+  
+  const statusColor = health.status === 'ok' ? chalk.green : (health.status === 'degraded' ? chalk.yellow : chalk.red);
+  const statusIcon = health.status === 'ok' ? '✓' : (health.status === 'degraded' ? '⚠' : '✗');
+  
+  console.log(chalk.gray('┌─────────────────────────────────────────────────────┐'));
+  console.log(chalk.gray('│') + chalk.white.bold('  Overall Status                                    ') + chalk.gray('│'));
+  console.log(chalk.gray('├─────────────────────────────────────────────────────┤'));
+  console.log(chalk.gray('│') + chalk.white('  Status:       ') + statusColor(`${statusIcon} ${health.status.toUpperCase()}`).padEnd(42) + chalk.gray('│'));
+  console.log(chalk.gray('│') + chalk.white('  Uptime:       ') + chalk.cyan(formatUptime(health.uptime)).padEnd(34) + chalk.gray('│'));
+  console.log(chalk.gray('│') + chalk.white('  Environment:  ') + chalk.cyan(health.environment).padEnd(34) + chalk.gray('│'));
+  console.log(chalk.gray('│') + chalk.white('  Version:      ') + chalk.cyan(health.version || 'N/A').padEnd(34) + chalk.gray('│'));
+  console.log(chalk.gray('└─────────────────────────────────────────────────────┘\n'));
+
+  if (health.checks) {
+    // Database
+    console.log(chalk.white.bold('Database:'));
+    displayCheckStatus(health.checks.database);
+    
+    // Redis
+    console.log(chalk.white.bold('\nRedis:'));
+    displayCheckStatus(health.checks.redis);
+    
+    // Memory
+    console.log(chalk.white.bold('\nMemory:'));
+    displayCheckStatus(health.checks.memory);
+    
+    console.log();
+  }
+}
+
+function displayCheckStatus(check) {
+  const statusColor = check.status === 'ok' ? chalk.green : 
+                      check.status === 'warning' ? chalk.yellow : 
+                      check.status === 'not configured' ? chalk.gray : chalk.red;
+  const statusIcon = check.status === 'ok' ? '✓' : 
+                     check.status === 'warning' ? '⚠' : 
+                     check.status === 'not configured' ? '○' : '✗';
+  
+  console.log(`  ${statusColor(statusIcon)} ${statusColor(check.status.toUpperCase())}`);
+  
+  Object.keys(check).forEach(key => {
+    if (key !== 'status') {
+      console.log(`     ${chalk.gray(key + ':')} ${chalk.white(check[key])}`);
+    }
+  });
+}
+
+function formatUptime(seconds) {
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+
+  if (days > 0) return `${days}d ${hours}h ${minutes}m`;
+  if (hours > 0) return `${hours}h ${minutes}m ${secs}s`;
+  if (minutes > 0) return `${minutes}m ${secs}s`;
+  return `${secs}s`;
+}
+
+module.exports = {
+  check
+};

package/commands/ipBlacklist.js

@@ -0,0 +1,121 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const Table = require('cli-table3');
+const api = require('../utils/api');
+
+// Add IP to blacklist
+async function add(tunnelId, ip) {
+  const spinner = ora('Adding IP to blacklist...').start();
+
+  try {
+    // Get current tunnel
+    const tunnel = await api.getTunnel(tunnelId);
+    const currentBlacklist = tunnel.tunnel.ipBlacklist || [];
+
+    // Check if IP already exists
+    if (currentBlacklist.includes(ip)) {
+      spinner.fail(chalk.yellow(`IP ${ip} is already in the blacklist`));
+      return;
+    }
+
+    // Add new IP
+    const updatedBlacklist = [...currentBlacklist, ip];
+    await api.updateIPBlacklist(tunnelId, updatedBlacklist);
+
+    spinner.succeed(chalk.green(`IP ${ip} added to blacklist`));
+    console.log(chalk.gray(`\nTotal blacklisted IPs: ${updatedBlacklist.length}\n`));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to add IP to blacklist'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+// Remove IP from blacklist
+async function remove(tunnelId, ip) {
+  const spinner = ora('Removing IP from blacklist...').start();
+
+  try {
+    // Get current tunnel
+    const tunnel = await api.getTunnel(tunnelId);
+    const currentBlacklist = tunnel.tunnel.ipBlacklist || [];
+
+    // Check if IP exists
+    if (!currentBlacklist.includes(ip)) {
+      spinner.fail(chalk.yellow(`IP ${ip} is not in the blacklist`));
+      return;
+    }
+
+    // Remove IP
+    const updatedBlacklist = currentBlacklist.filter(item => item !== ip);
+    await api.updateIPBlacklist(tunnelId, updatedBlacklist);
+
+    spinner.succeed(chalk.green(`IP ${ip} removed from blacklist`));
+    console.log(chalk.gray(`\nTotal blacklisted IPs: ${updatedBlacklist.length}\n`));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to remove IP from blacklist'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+// List blacklisted IPs
+async function list(tunnelId) {
+  const spinner = ora('Fetching IP blacklist...').start();
+
+  try {
+    const tunnel = await api.getTunnel(tunnelId);
+    const blacklist = tunnel.tunnel.ipBlacklist || [];
+
+    spinner.stop();
+
+    if (blacklist.length === 0) {
+      console.log(chalk.yellow('\n⚠ No IP blacklist configured. No IPs are blocked.\n'));
+      return;
+    }
+
+    console.log(chalk.blue.bold(`\n🚫 IP Blacklist (${blacklist.length} IPs)\n`));
+
+    const table = new Table({
+      head: [chalk.white('IP Address / CIDR')],
+      style: {
+        head: ['cyan'],
+        border: ['gray']
+      }
+    });
+
+    blacklist.forEach(ip => {
+      table.push([chalk.red(ip)]);
+    });
+
+    console.log(table.toString());
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to fetch IP blacklist'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+// Clear all blacklisted IPs
+async function clear(tunnelId) {
+  const spinner = ora('Clearing IP blacklist...').start();
+
+  try {
+    await api.updateIPBlacklist(tunnelId, []);
+
+    spinner.succeed(chalk.green('IP blacklist cleared'));
+    console.log(chalk.gray('\nNo IPs are blocked.\n'));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to clear IP blacklist'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  add,
+  remove,
+  list,
+  clear
+};

package/commands/ipWhitelist.js

@@ -0,0 +1,121 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const Table = require('cli-table3');
+const api = require('../utils/api');
+
+// Add IP to whitelist
+async function add(tunnelId, ip) {
+  const spinner = ora('Adding IP to whitelist...').start();
+
+  try {
+    // Get current tunnel
+    const tunnel = await api.getTunnel(tunnelId);
+    const currentWhitelist = tunnel.tunnel.ipWhitelist || [];
+
+    // Check if IP already exists
+    if (currentWhitelist.includes(ip)) {
+      spinner.fail(chalk.yellow(`IP ${ip} is already in the whitelist`));
+      return;
+    }
+
+    // Add new IP
+    const updatedWhitelist = [...currentWhitelist, ip];
+    await api.updateIPWhitelist(tunnelId, updatedWhitelist);
+
+    spinner.succeed(chalk.green(`IP ${ip} added to whitelist`));
+    console.log(chalk.gray(`\nTotal whitelisted IPs: ${updatedWhitelist.length}\n`));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to add IP to whitelist'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+// Remove IP from whitelist
+async function remove(tunnelId, ip) {
+  const spinner = ora('Removing IP from whitelist...').start();
+
+  try {
+    // Get current tunnel
+    const tunnel = await api.getTunnel(tunnelId);
+    const currentWhitelist = tunnel.tunnel.ipWhitelist || [];
+
+    // Check if IP exists
+    if (!currentWhitelist.includes(ip)) {
+      spinner.fail(chalk.yellow(`IP ${ip} is not in the whitelist`));
+      return;
+    }
+
+    // Remove IP
+    const updatedWhitelist = currentWhitelist.filter(item => item !== ip);
+    await api.updateIPWhitelist(tunnelId, updatedWhitelist);
+
+    spinner.succeed(chalk.green(`IP ${ip} removed from whitelist`));
+    console.log(chalk.gray(`\nTotal whitelisted IPs: ${updatedWhitelist.length}\n`));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to remove IP from whitelist'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+// List whitelisted IPs
+async function list(tunnelId) {
+  const spinner = ora('Fetching IP whitelist...').start();
+
+  try {
+    const tunnel = await api.getTunnel(tunnelId);
+    const whitelist = tunnel.tunnel.ipWhitelist || [];
+
+    spinner.stop();
+
+    if (whitelist.length === 0) {
+      console.log(chalk.yellow('\n⚠ No IP whitelist configured. All IPs are allowed.\n'));
+      return;
+    }
+
+    console.log(chalk.blue.bold(`\n🔒 IP Whitelist (${whitelist.length} IPs)\n`));
+
+    const table = new Table({
+      head: [chalk.white('IP Address / CIDR')],
+      style: {
+        head: ['cyan'],
+        border: ['gray']
+      }
+    });
+
+    whitelist.forEach(ip => {
+      table.push([chalk.green(ip)]);
+    });
+
+    console.log(table.toString());
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to fetch IP whitelist'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+// Clear all whitelisted IPs
+async function clear(tunnelId) {
+  const spinner = ora('Clearing IP whitelist...').start();
+
+  try {
+    await api.updateIPWhitelist(tunnelId, []);
+
+    spinner.succeed(chalk.green('IP whitelist cleared'));
+    console.log(chalk.gray('\nAll IPs are now allowed.\n'));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to clear IP whitelist'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  add,
+  remove,
+  list,
+  clear
+};

package/commands/rateLimit.js

@@ -0,0 +1,69 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const api = require('../utils/api');
+
+// Configure rate limits
+async function configure(tunnelId, options) {
+  const spinner = ora('Updating rate limits...').start();
+
+  try {
+    // Get current tunnel
+    const tunnel = await api.getTunnel(tunnelId);
+    const currentRateLimit = tunnel.tunnel.rateLimit || {};
+
+    // Build update object
+    const updates = {
+      rateLimit: {
+        enabled: options.disable ? false : (options.enable ? true : currentRateLimit.enabled),
+        requestsPerMinute: options.rpm || currentRateLimit.requestsPerMinute,
+        requestsPerHour: options.rph || currentRateLimit.requestsPerHour,
+        requestsPerDay: options.rpd || currentRateLimit.requestsPerDay
+      }
+    };
+
+    await api.updateTunnel(tunnelId, updates);
+
+    spinner.succeed(chalk.green('Rate limits updated successfully'));
+
+    console.log(chalk.blue.bold('\n⚡ Rate Limit Configuration\n'));
+    console.log(chalk.gray('┌─────────────────────────────────────┐'));
+    console.log(chalk.gray('│') + chalk.white('  Status:       ') + (updates.rateLimit.enabled ? chalk.green('Enabled') : chalk.red('Disabled')).padEnd(28) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.white('  Per Minute:   ') + chalk.cyan(String(updates.rateLimit.requestsPerMinute)).padEnd(20) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.white('  Per Hour:     ') + chalk.cyan(String(updates.rateLimit.requestsPerHour)).padEnd(20) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.white('  Per Day:      ') + chalk.cyan(String(updates.rateLimit.requestsPerDay)).padEnd(20) + chalk.gray('│'));
+    console.log(chalk.gray('└─────────────────────────────────────┘\n'));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to update rate limits'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+// Show current rate limits
+async function show(tunnelId) {
+  const spinner = ora('Fetching rate limits...').start();
+
+  try {
+    const tunnel = await api.getTunnel(tunnelId);
+    const rateLimit = tunnel.tunnel.rateLimit || {};
+
+    spinner.stop();
+
+    console.log(chalk.blue.bold('\n⚡ Rate Limit Configuration\n'));
+    console.log(chalk.gray('┌─────────────────────────────────────┐'));
+    console.log(chalk.gray('│') + chalk.white('  Status:       ') + (rateLimit.enabled ? chalk.green('Enabled') : chalk.red('Disabled')).padEnd(28) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.white('  Per Minute:   ') + chalk.cyan(String(rateLimit.requestsPerMinute || 60)).padEnd(20) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.white('  Per Hour:     ') + chalk.cyan(String(rateLimit.requestsPerHour || 1000)).padEnd(20) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.white('  Per Day:      ') + chalk.cyan(String(rateLimit.requestsPerDay || 10000)).padEnd(20) + chalk.gray('│'));
+    console.log(chalk.gray('└─────────────────────────────────────┘\n'));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to fetch rate limits'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  configure,
+  show
+};

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.0",
+  "version": "2.5.0",
   "description": "Command-line interface for API Response Manager",
   "main": "index.js",
   "bin": {
@@ -8,7 +8,17 @@
   },
   "scripts": {
     "test": "jest",
-    "link": "npm link"
+    "link": "npm link",
+    "prepublishOnly": "echo 'Publishing api-response-manager CLI...'"
+  },
+  "files": [
+    "bin/",
+    "commands/",
+    "utils/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
   },
   "keywords": [
     "api",
@@ -19,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",
@@ -47,5 +57,6 @@
   "bugs": {
     "url": "https://github.com/vijaypurohit322/api-response-manager/issues"
   },
-  "homepage": "https://github.com/vijaypurohit322/api-response-manager#readme"
+  "homepage": "https://github.com/vijaypurohit322/api-response-manager#readme",
+  "preferGlobal": true
 }

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,
@@ -185,6 +186,23 @@ class APIClient {
     const response = await this.client.post(`/tunnels/${id}/ingress`, data);
     return response.data;
   }
+
+  // IP Management
+  async updateIPWhitelist(id, ipWhitelist) {
+    const response = await this.client.put(`/tunnels/${id}/ip-whitelist`, { ipWhitelist });
+    return response.data;
+  }
+
+  async updateIPBlacklist(id, ipBlacklist) {
+    const response = await this.client.put(`/tunnels/${id}/ip-blacklist`, { ipBlacklist });
+    return response.data;
+  }
+
+  // Update Tunnel
+  async updateTunnel(id, updates) {
+    const response = await this.client.put(`/tunnels/${id}`, updates);
+    return response.data;
+  }
 }
 
 module.exports = new APIClient();

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']
     },

package/CLI_UPDATES.md

@@ -1,196 +0,0 @@
-# CLI Updates for Advanced Tunnel Features
-
-## ✅ Changes Made
-
-### 1. Enhanced `tunnel` Command
-Added new options to the main tunnel command:
-```bash
-arm tunnel [port] [options]
-
-Options:
-  -s, --subdomain <subdomain>    Custom subdomain
-  -n, --name <name>              Tunnel name
-  -a, --auth                     Enable basic authentication
-  -r, --rate-limit <limit>       Rate limit (requests per minute)
-  -p, --protocol <protocol>      Protocol (http, https, tcp, ws, wss)
-  --ssl                          Enable SSL/HTTPS
-  -d, --domain <domain>          Custom domain
-```
-
-### 2. New Commands Added
-
-#### Custom Domain
-```bash
-arm tunnel:domain <tunnelId> <domain>
-```
-Example:
-```bash
-arm tunnel:domain abc123 api.yourdomain.com
-```
-
-#### SSL Certificate Upload
-```bash
-arm tunnel:ssl <tunnelId> --cert <path> --key <path> [--ca <path>]
-```
-Example:
-```bash
-arm tunnel:ssl abc123 --cert cert.pem --key key.pem --ca ca.pem
-```
-
-#### OAuth Configuration
-```bash
-arm tunnel:auth:oauth <tunnelId> [options]
-
-Options:
-  --provider <provider>          OAuth provider (google, github, microsoft, custom)
-  --client-id <id>              OAuth client ID
-  --client-secret <secret>      OAuth client secret
-  --callback-url <url>          OAuth callback URL
-  --scope <scope>               OAuth scope (comma-separated)
-```
-Example:
-```bash
-arm tunnel:auth:oauth abc123 \
-  --provider google \
-  --client-id YOUR_CLIENT_ID \
-  --client-secret YOUR_SECRET \
-  --callback-url https://yourtunnel.arm.dev/auth/callback \
-  --scope openid,email,profile
-```
-
-#### OIDC Configuration
-```bash
-arm tunnel:auth:oidc <tunnelId> [options]
-
-Options:
-  --issuer <url>                OIDC issuer URL
-  --client-id <id>              OIDC client ID
-  --client-secret <secret>      OIDC client secret
-  --callback-url <url>          OIDC callback URL
-```
-Example:
-```bash
-arm tunnel:auth:oidc abc123 \
-  --issuer https://accounts.google.com \
-  --client-id YOUR_CLIENT_ID \
-  --client-secret YOUR_SECRET \
-  --callback-url https://yourtunnel.arm.dev/auth/callback
-```
-
-#### SAML Configuration
-```bash
-arm tunnel:auth:saml <tunnelId> [options]
-
-Options:
-  --entry-point <url>           SAML entry point URL
-  --issuer <issuer>             SAML issuer
-  --cert <path>                 Path to IdP certificate file
-  --callback-url <url>          SAML callback URL
-```
-Example:
-```bash
-arm tunnel:auth:saml abc123 \
-  --entry-point https://idp.example.com/saml/sso \
-  --issuer https://yourtunnel.arm.dev \
-  --cert idp-cert.pem \
-  --callback-url https://yourtunnel.arm.dev/auth/saml/callback
-```
-
-#### Ingress Configuration
-```bash
-arm tunnel:ingress <tunnelId> <rules> [--tls]
-
-Rules format: "/path=host:port,/path2=host:port"
-```
-Example:
-```bash
-arm tunnel:ingress abc123 "/api=localhost:3000,/admin=localhost:4000" --tls
-```
-
-## 📝 Usage Examples
-
-### Example 1: Create HTTPS Tunnel
-```bash
-arm tunnel 3000 --protocol https --ssl --subdomain myapi
-```
-
-### Example 2: Create TCP Tunnel
-```bash
-arm tunnel 5432 --protocol tcp --subdomain postgres
-```
-
-### Example 3: Create Tunnel with Custom Domain
-```bash
-# Create tunnel
-arm tunnel 3000 --protocol https --ssl
-
-# Set custom domain
-arm tunnel:domain <tunnel-id> api.mycompany.com
-```
-
-### Example 4: Create Tunnel with OAuth
-```bash
-# Create tunnel
-arm tunnel 3000 --protocol https --ssl --subdomain myapi
-
-# Configure OAuth
-arm tunnel:auth:oauth <tunnel-id> \
-  --provider google \
-  --client-id YOUR_CLIENT_ID \
-  --client-secret YOUR_SECRET \
-  --callback-url https://myapi.tunnel.arm.dev/auth/callback
-```
-
-### Example 5: Create Tunnel with Ingress
-```bash
-# Create tunnel
-arm tunnel 3000 --protocol https --ssl
-
-# Configure ingress rules
-arm tunnel:ingress <tunnel-id> \
-  "/v1=localhost:3000,/v2=localhost:4000" \
-  --tls
-```
-
-## 🔧 Updated Files
-
-1. **cli/bin/arm.js** - Added new commands
-2. **cli/commands/tunnel.js** - Added new functions
-3. **cli/utils/api.js** - Added new API methods
-
-## 📦 No New Dependencies Required
-
-All new features use existing dependencies.
-
-## 🚀 Testing
-
-Test the new commands:
-```bash
-# Test HTTPS tunnel
-arm tunnel 3000 --protocol https --ssl
-
-# Test custom domain
-arm tunnel:domain <tunnel-id> test.example.com
-
-# Test SSL upload
-arm tunnel:ssl <tunnel-id> --cert cert.pem --key key.pem
-
-# Test OAuth
-arm tunnel:auth:oauth <tunnel-id> --provider google --client-id test --client-secret test --callback-url http://localhost/callback
-
-# Test ingress
-arm tunnel:ingress <tunnel-id> "/api=localhost:3000" --tls
-```
-
-## 📖 Help Output
-
-```bash
-arm --help
-arm tunnel --help
-arm tunnel:domain --help
-arm tunnel:ssl --help
-arm tunnel:auth:oauth --help
-arm tunnel:auth:oidc --help
-arm tunnel:auth:saml --help
-arm tunnel:ingress --help
-```