api-response-manager 2.3.1 → 2.5.1

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

@@ -21,6 +21,9 @@ const ipWhitelistCommand = require('../commands/ipWhitelist');
 const ipBlacklistCommand = require('../commands/ipBlacklist');
 const rateLimitCommand = require('../commands/rateLimit');
 const healthCommand = require('../commands/health');
+const gatewayCommand = require('../commands/gateway');
+const ingressCommand = require('../commands/ingress');
+const accountCommand = require('../commands/account');
 
 // CLI setup
 program
@@ -313,6 +316,128 @@ program
   .argument('<key>', 'Configuration key')
   .action(configCommand.delete);
 
+// Gateway commands (paid feature)
+program
+  .command('gateway:list')
+  .description('List all API gateways')
+  .action(gatewayCommand.list);
+
+program
+  .command('gateway:create')
+  .description('Create a new API gateway')
+  .argument('<name>', 'Gateway name')
+  .argument('<subdomain>', 'Subdomain for the gateway')
+  .option('-d, --description <description>', 'Gateway description')
+  .action(gatewayCommand.create);
+
+program
+  .command('gateway:get')
+  .description('Get gateway details')
+  .argument('<gatewayId>', 'Gateway ID')
+  .action(gatewayCommand.get);
+
+program
+  .command('gateway:delete')
+  .description('Delete a gateway')
+  .argument('<gatewayId>', 'Gateway ID')
+  .action(gatewayCommand.remove);
+
+program
+  .command('gateway:route:add')
+  .description('Add route to gateway')
+  .argument('<gatewayId>', 'Gateway ID')
+  .argument('<path>', 'Route path (e.g., /api/v1)')
+  .argument('<backendUrl>', 'Backend URL')
+  .option('-n, --name <name>', 'Route name')
+  .option('-p, --protocol <protocol>', 'Protocol (http, websocket, kafka, mqtt)', 'http')
+  .option('-t, --pathType <type>', 'Path type (prefix, exact, regex)', 'prefix')
+  .option('-m, --methods <methods>', 'HTTP methods (comma-separated)', 'GET,POST,PUT,DELETE')
+  .option('--brokers <brokers>', 'Kafka brokers (comma-separated)')
+  .option('--broker <broker>', 'MQTT broker URL')
+  .option('--topic <topic>', 'Kafka/MQTT topic')
+  .action(gatewayCommand.addRoute);
+
+program
+  .command('gateway:route:remove')
+  .description('Remove route from gateway')
+  .argument('<gatewayId>', 'Gateway ID')
+  .argument('<routeId>', 'Route ID')
+  .action(gatewayCommand.removeRoute);
+
+program
+  .command('gateway:analytics')
+  .description('View gateway analytics')
+  .argument('<gatewayId>', 'Gateway ID')
+  .option('-p, --period <period>', 'Time period (1h, 24h, 7d, 30d)', '24h')
+  .action(gatewayCommand.analytics);
+
+// Ingress commands (paid feature)
+program
+  .command('ingress:list')
+  .description('List all ingress rules')
+  .action(ingressCommand.list);
+
+program
+  .command('ingress:create')
+  .description('Create ingress rule')
+  .argument('<name>', 'Ingress name')
+  .option('-n, --namespace <namespace>', 'Namespace', 'default')
+  .option('-h, --host <host>', 'Host')
+  .option('-p, --path <path>', 'Path', '/')
+  .option('-t, --pathType <type>', 'Path type (Prefix, Exact)', 'Prefix')
+  .option('-b, --backend <url>', 'Backend URL')
+  .action(ingressCommand.create);
+
+program
+  .command('ingress:apply')
+  .description('Create ingress from YAML file')
+  .argument('<yamlFile>', 'Path to YAML file')
+  .action(ingressCommand.createFromYaml);
+
+program
+  .command('ingress:get')
+  .description('Get ingress details')
+  .argument('<name>', 'Ingress name')
+  .option('-n, --namespace <namespace>', 'Namespace', 'default')
+  .action(ingressCommand.get);
+
+program
+  .command('ingress:delete')
+  .description('Delete ingress rule')
+  .argument('<name>', 'Ingress name')
+  .option('-n, --namespace <namespace>', 'Namespace', 'default')
+  .action(ingressCommand.remove);
+
+program
+  .command('ingress:export')
+  .description('Export ingress as YAML')
+  .argument('<name>', 'Ingress name')
+  .option('-n, --namespace <namespace>', 'Namespace', 'default')
+  .option('-o, --output <file>', 'Output file path')
+  .action(ingressCommand.exportYaml);
+
+program
+  .command('ingress:validate')
+  .description('Validate ingress YAML')
+  .argument('<yamlFile>', 'Path to YAML file')
+  .action(ingressCommand.validate);
+
+// Account commands
+program
+  .command('account')
+  .description('View account information')
+  .action(accountCommand.info);
+
+program
+  .command('account:features')
+  .description('View available features for your plan')
+  .action(accountCommand.features);
+
+program
+  .command('account:usage')
+  .description('View usage statistics')
+  .action(accountCommand.usage);
+
 // Parse arguments
 program.parse(process.argv);
 

package/commands/account.js

@@ -0,0 +1,189 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const Table = require('cli-table3');
+const { getApiClient, requireAuth } = require('../utils/api');
+
+/**
+ * Get current user info
+ */
+async function info() {
+  const spinner = ora('Fetching account info...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const response = await api.get('/auth/me');
+    const user = response.data.user;
+    
+    spinner.stop();
+    
+    console.log('\n' + chalk.green('Account Information:'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`  ${chalk.bold('Name:')}     ${user.name || '-'}`);
+    console.log(`  ${chalk.bold('Email:')}    ${user.email}`);
+    console.log(`  ${chalk.bold('Role:')}     ${user.role}`);
+    console.log(`  ${chalk.bold('Tier:')}     ${getTierBadge(user.tier)}`);
+    console.log(`  ${chalk.bold('Verified:')} ${user.emailVerified ? chalk.green('Yes') : chalk.yellow('No')}`);
+    
+    if (user.subscription) {
+      console.log('\n' + chalk.cyan('Subscription:'));
+      console.log(`  ${chalk.bold('Status:')}   ${getStatusBadge(user.subscription.status)}`);
+      if (user.subscription.endDate) {
+        console.log(`  ${chalk.bold('Expires:')}  ${new Date(user.subscription.endDate).toLocaleDateString()}`);
+      }
+    }
+    
+    if (user.usage) {
+      console.log('\n' + chalk.cyan('Usage This Month:'));
+      console.log(`  ${chalk.bold('HTTP Requests:')} ${user.usage.httpRequests || 0}`);
+      console.log(`  ${chalk.bold('Bandwidth:')}     ${formatBytes(user.usage.bandwidth || 0)}`);
+    }
+  } catch (error) {
+    spinner.fail('Failed to fetch account info');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+/**
+ * Get user's feature access
+ */
+async function features() {
+  const spinner = ora('Fetching feature access...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const response = await api.get('/auth/features');
+    const { tier, features } = response.data;
+    
+    spinner.stop();
+    
+    console.log('\n' + chalk.green(`Feature Access (${getTierBadge(tier)} Plan):`));
+    console.log(chalk.gray('─'.repeat(60)));
+    
+    // Group by category
+    const categories = {};
+    Object.entries(features).forEach(([key, feature]) => {
+      const cat = feature.category || 'other';
+      if (!categories[cat]) categories[cat] = [];
+      categories[cat].push({ key, ...feature });
+    });
+    
+    Object.entries(categories).forEach(([category, featureList]) => {
+      console.log('\n' + chalk.cyan(category.toUpperCase()));
+      
+      const table = new Table({
+        head: [chalk.cyan('Feature'), chalk.cyan('Status'), chalk.cyan('Limit')],
+        colWidths: [30, 12, 20]
+      });
+      
+      featureList.forEach(f => {
+        const status = f.enabled ? chalk.green('✓ Enabled') : chalk.red('✗ Disabled');
+        const limit = f.limit === null ? 'Unlimited' : (f.limit || '0');
+        table.push([f.name, status, limit]);
+      });
+      
+      console.log(table.toString());
+    });
+    
+    console.log('\n' + chalk.gray('Upgrade your plan at https://tunnelapi.in/pricing'));
+  } catch (error) {
+    spinner.fail('Failed to fetch features');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+/**
+ * Get usage statistics
+ */
+async function usage() {
+  const spinner = ora('Fetching usage stats...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const [userRes, featuresRes] = await Promise.all([
+      api.get('/auth/me'),
+      api.get('/auth/features')
+    ]);
+    
+    const user = userRes.data.user;
+    const { tier, features } = featuresRes.data;
+    
+    spinner.stop();
+    
+    console.log('\n' + chalk.green('Usage Statistics:'));
+    console.log(chalk.gray('─'.repeat(50)));
+    
+    // HTTP Requests
+    const httpLimit = features.http_requests?.limit;
+    const httpUsed = user.usage?.httpRequests || 0;
+    console.log(`\n${chalk.bold('HTTP Requests:')}`);
+    console.log(`  Used: ${httpUsed} / ${httpLimit || 'Unlimited'}`);
+    if (httpLimit) {
+      const percent = Math.round((httpUsed / httpLimit) * 100);
+      console.log(`  ${getProgressBar(percent)} ${percent}%`);
+    }
+    
+    // Bandwidth
+    const bwLimit = features.bandwidth?.limit;
+    const bwUsed = user.usage?.bandwidth || 0;
+    console.log(`\n${chalk.bold('Bandwidth:')}`);
+    console.log(`  Used: ${formatBytes(bwUsed)} / ${bwLimit ? formatBytes(bwLimit * 1024 * 1024) : 'Unlimited'}`);
+    if (bwLimit) {
+      const bwLimitBytes = bwLimit * 1024 * 1024;
+      const percent = Math.round((bwUsed / bwLimitBytes) * 100);
+      console.log(`  ${getProgressBar(percent)} ${percent}%`);
+    }
+    
+    console.log('\n' + chalk.gray(`Last reset: ${new Date(user.usage?.lastResetAt || Date.now()).toLocaleDateString()}`));
+  } catch (error) {
+    spinner.fail('Failed to fetch usage');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+// Helper functions
+function getTierBadge(tier) {
+  const badges = {
+    free: chalk.gray('Free'),
+    solo: chalk.blue('Solo'),
+    team: chalk.magenta('Team'),
+    enterprise: chalk.yellow('Enterprise')
+  };
+  return badges[tier] || tier;
+}
+
+function getStatusBadge(status) {
+  const badges = {
+    active: chalk.green('Active'),
+    trial: chalk.blue('Trial'),
+    cancelled: chalk.yellow('Cancelled'),
+    expired: chalk.red('Expired')
+  };
+  return badges[status] || status;
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+function getProgressBar(percent) {
+  const filled = Math.round(percent / 5);
+  const empty = 20 - filled;
+  const color = percent > 80 ? chalk.red : percent > 50 ? chalk.yellow : chalk.green;
+  return color('█'.repeat(filled) + '░'.repeat(empty));
+}
+
+module.exports = {
+  info,
+  features,
+  usage
+};

package/commands/gateway.js

@@ -0,0 +1,275 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const Table = require('cli-table3');
+const { getApiClient, requireAuth } = require('../utils/api');
+
+/**
+ * List all gateways
+ */
+async function list() {
+  const spinner = ora('Fetching gateways...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const response = await api.get('/gateways');
+    const gateways = response.data.gateways || [];
+    
+    spinner.stop();
+    
+    if (gateways.length === 0) {
+      console.log(chalk.yellow('\nNo gateways found. Create one with: arm gateway:create <name> <subdomain>'));
+      return;
+    }
+    
+    const table = new Table({
+      head: [
+        chalk.cyan('Name'),
+        chalk.cyan('Subdomain'),
+        chalk.cyan('Status'),
+        chalk.cyan('Routes'),
+        chalk.cyan('Public URL')
+      ],
+      colWidths: [20, 15, 10, 8, 45]
+    });
+    
+    gateways.forEach(gw => {
+      table.push([
+        gw.name,
+        gw.subdomain,
+        gw.status === 'active' ? chalk.green('active') : chalk.red(gw.status),
+        gw.routes?.length || 0,
+        chalk.blue(gw.publicUrl || '-')
+      ]);
+    });
+    
+    console.log('\n' + table.toString());
+    console.log(chalk.gray(`\nTotal: ${gateways.length} gateway(s)`));
+  } catch (error) {
+    spinner.fail('Failed to fetch gateways');
+    if (error.response?.status === 403) {
+      console.log(chalk.red('\n⚠ API Gateway is a paid feature. Upgrade your plan to access it.'));
+    } else {
+      console.error(chalk.red(error.response?.data?.error || error.message));
+    }
+  }
+}
+
+/**
+ * Create a new gateway
+ */
+async function create(name, subdomain, options) {
+  const spinner = ora('Creating gateway...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const response = await api.post('/gateways', {
+      name,
+      subdomain,
+      description: options.description || ''
+    });
+    
+    spinner.succeed('Gateway created successfully!');
+    
+    const gw = response.data.gateway;
+    console.log('\n' + chalk.green('Gateway Details:'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`  ${chalk.bold('Name:')}       ${gw.name}`);
+    console.log(`  ${chalk.bold('Subdomain:')}  ${gw.subdomain}`);
+    console.log(`  ${chalk.bold('Public URL:')} ${chalk.blue(gw.publicUrl)}`);
+    console.log(`  ${chalk.bold('Status:')}     ${chalk.green(gw.status)}`);
+    console.log('\n' + chalk.gray('Add routes with: arm gateway:route:add <gateway-id> <path> <backend-url>'));
+  } catch (error) {
+    spinner.fail('Failed to create gateway');
+    if (error.response?.status === 403) {
+      console.log(chalk.red('\n⚠ API Gateway is a paid feature. Upgrade your plan to access it.'));
+      console.log(chalk.yellow('Visit https://tunnelapi.in/pricing to upgrade.'));
+    } else {
+      console.error(chalk.red(error.response?.data?.error || error.message));
+    }
+  }
+}
+
+/**
+ * Get gateway details
+ */
+async function get(gatewayId) {
+  const spinner = ora('Fetching gateway...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const response = await api.get(`/gateways/${gatewayId}`);
+    const gw = response.data.gateway;
+    
+    spinner.stop();
+    
+    console.log('\n' + chalk.green('Gateway Details:'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`  ${chalk.bold('ID:')}         ${gw._id}`);
+    console.log(`  ${chalk.bold('Name:')}       ${gw.name}`);
+    console.log(`  ${chalk.bold('Subdomain:')}  ${gw.subdomain}`);
+    console.log(`  ${chalk.bold('Public URL:')} ${chalk.blue(gw.publicUrl)}`);
+    console.log(`  ${chalk.bold('Status:')}     ${gw.status === 'active' ? chalk.green('active') : chalk.red(gw.status)}`);
+    
+    if (gw.routes && gw.routes.length > 0) {
+      console.log('\n' + chalk.cyan('Routes:'));
+      const table = new Table({
+        head: [chalk.cyan('Path'), chalk.cyan('Protocol'), chalk.cyan('Backend'), chalk.cyan('Methods')],
+        colWidths: [20, 12, 35, 25]
+      });
+      
+      gw.routes.forEach(route => {
+        const backend = route.backends?.[0]?.url || 
+                       (route.kafka?.brokers?.join(',')) ||
+                       (route.mqtt?.broker) || '-';
+        table.push([
+          route.path,
+          route.protocol || 'http',
+          backend,
+          (route.methods || ['ALL']).join(', ')
+        ]);
+      });
+      
+      console.log(table.toString());
+    } else {
+      console.log(chalk.yellow('\nNo routes configured.'));
+    }
+  } catch (error) {
+    spinner.fail('Failed to fetch gateway');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+/**
+ * Delete a gateway
+ */
+async function remove(gatewayId) {
+  const spinner = ora('Deleting gateway...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    await api.delete(`/gateways/${gatewayId}`);
+    
+    spinner.succeed('Gateway deleted successfully!');
+  } catch (error) {
+    spinner.fail('Failed to delete gateway');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+/**
+ * Add route to gateway
+ */
+async function addRoute(gatewayId, path, backendUrl, options) {
+  const spinner = ora('Adding route...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const routeData = {
+      name: options.name || `Route ${path}`,
+      protocol: options.protocol || 'http',
+      path,
+      pathType: options.pathType || 'prefix',
+      methods: options.methods ? options.methods.split(',') : ['GET', 'POST', 'PUT', 'DELETE'],
+      backends: [{ url: backendUrl, weight: 100 }]
+    };
+    
+    // Add protocol-specific config
+    if (options.protocol === 'kafka') {
+      routeData.kafka = {
+        brokers: options.brokers ? options.brokers.split(',') : [],
+        topic: options.topic || ''
+      };
+    } else if (options.protocol === 'mqtt') {
+      routeData.mqtt = {
+        broker: options.broker || '',
+        topic: options.topic || ''
+      };
+    }
+    
+    const response = await api.post(`/gateways/${gatewayId}/routes`, routeData);
+    
+    spinner.succeed('Route added successfully!');
+    console.log(chalk.gray(`Path: ${path} → ${backendUrl}`));
+  } catch (error) {
+    spinner.fail('Failed to add route');
+    if (error.response?.status === 403) {
+      const msg = error.response?.data?.message || '';
+      if (msg.includes('protocol')) {
+        console.log(chalk.red('\n⚠ This protocol is not available on your plan.'));
+        console.log(chalk.yellow('Upgrade to Team or Enterprise for Kafka/MQTT support.'));
+      } else {
+        console.log(chalk.red('\n⚠ ' + msg));
+      }
+    } else {
+      console.error(chalk.red(error.response?.data?.error || error.message));
+    }
+  }
+}
+
+/**
+ * Remove route from gateway
+ */
+async function removeRoute(gatewayId, routeId) {
+  const spinner = ora('Removing route...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    await api.delete(`/gateways/${gatewayId}/routes/${routeId}`);
+    
+    spinner.succeed('Route removed successfully!');
+  } catch (error) {
+    spinner.fail('Failed to remove route');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+/**
+ * Get gateway analytics
+ */
+async function analytics(gatewayId, options) {
+  const spinner = ora('Fetching analytics...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const response = await api.get(`/gateways/${gatewayId}/analytics`, {
+      params: { period: options.period || '24h' }
+    });
+    
+    spinner.stop();
+    
+    const stats = response.data;
+    console.log('\n' + chalk.green('Gateway Analytics:'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`  ${chalk.bold('Total Requests:')}  ${stats.totalRequests || 0}`);
+    console.log(`  ${chalk.bold('Success Rate:')}    ${stats.successRate || 0}%`);
+    console.log(`  ${chalk.bold('Avg Latency:')}     ${stats.avgLatency || 0}ms`);
+    console.log(`  ${chalk.bold('Errors:')}          ${stats.errors || 0}`);
+  } catch (error) {
+    spinner.fail('Failed to fetch analytics');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+module.exports = {
+  list,
+  create,
+  get,
+  remove,
+  addRoute,
+  removeRoute,
+  analytics
+};

package/commands/ingress.js

@@ -0,0 +1,275 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const Table = require('cli-table3');
+const fs = require('fs');
+const { getApiClient, requireAuth } = require('../utils/api');
+
+/**
+ * List all ingress rules
+ */
+async function list() {
+  const spinner = ora('Fetching ingress rules...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const response = await api.get('/ingress');
+    const rules = response.data.ingresses || [];
+    
+    spinner.stop();
+    
+    if (rules.length === 0) {
+      console.log(chalk.yellow('\nNo ingress rules found. Create one with: arm ingress:create <name>'));
+      return;
+    }
+    
+    const table = new Table({
+      head: [
+        chalk.cyan('Name'),
+        chalk.cyan('Namespace'),
+        chalk.cyan('Host'),
+        chalk.cyan('Paths'),
+        chalk.cyan('Status')
+      ],
+      colWidths: [20, 15, 40, 8, 10]
+    });
+    
+    rules.forEach(rule => {
+      const pathCount = rule.spec?.rules?.[0]?.http?.paths?.length || 0;
+      table.push([
+        rule.metadata?.name || '-',
+        rule.metadata?.namespace || 'default',
+        rule.spec?.rules?.[0]?.host || '-',
+        pathCount,
+        rule.status === 'active' ? chalk.green('active') : chalk.yellow(rule.status || 'pending')
+      ]);
+    });
+    
+    console.log('\n' + table.toString());
+    console.log(chalk.gray(`\nTotal: ${rules.length} ingress rule(s)`));
+  } catch (error) {
+    spinner.fail('Failed to fetch ingress rules');
+    if (error.response?.status === 403) {
+      console.log(chalk.red('\n⚠ Kubernetes Ingress is a paid feature. Upgrade your plan to access it.'));
+    } else {
+      console.error(chalk.red(error.response?.data?.error || error.message));
+    }
+  }
+}
+
+/**
+ * Create ingress from YAML file
+ */
+async function createFromYaml(yamlFile) {
+  const spinner = ora('Creating ingress from YAML...').start();
+  
+  try {
+    if (!fs.existsSync(yamlFile)) {
+      spinner.fail('YAML file not found');
+      console.error(chalk.red(`File not found: ${yamlFile}`));
+      return;
+    }
+    
+    const yamlContent = fs.readFileSync(yamlFile, 'utf8');
+    
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const response = await api.post('/ingress/yaml', { yaml: yamlContent });
+    
+    spinner.succeed('Ingress created successfully!');
+    
+    const ingress = response.data.ingress;
+    console.log('\n' + chalk.green('Ingress Details:'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`  ${chalk.bold('Name:')}      ${ingress.metadata?.name}`);
+    console.log(`  ${chalk.bold('Namespace:')} ${ingress.metadata?.namespace || 'default'}`);
+    console.log(`  ${chalk.bold('Host:')}      ${ingress.spec?.rules?.[0]?.host || '-'}`);
+  } catch (error) {
+    spinner.fail('Failed to create ingress');
+    if (error.response?.status === 403) {
+      console.log(chalk.red('\n⚠ Kubernetes Ingress is a paid feature. Upgrade your plan to access it.'));
+      console.log(chalk.yellow('Visit https://tunnelapi.in/pricing to upgrade.'));
+    } else {
+      console.error(chalk.red(error.response?.data?.error || error.message));
+    }
+  }
+}
+
+/**
+ * Create ingress interactively
+ */
+async function create(name, options) {
+  const spinner = ora('Creating ingress...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const ingressData = {
+      name,
+      namespace: options.namespace || 'default',
+      host: options.host,
+      paths: [{
+        path: options.path || '/',
+        pathType: options.pathType || 'Prefix',
+        backend: {
+          url: options.backend
+        }
+      }]
+    };
+    
+    const response = await api.post('/ingress', ingressData);
+    
+    spinner.succeed('Ingress created successfully!');
+    
+    const ingress = response.data.ingress;
+    console.log('\n' + chalk.green('Ingress Details:'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`  ${chalk.bold('Name:')}      ${ingress.metadata?.name}`);
+    console.log(`  ${chalk.bold('Namespace:')} ${ingress.metadata?.namespace || 'default'}`);
+    console.log(`  ${chalk.bold('Host:')}      ${ingress.spec?.rules?.[0]?.host || '-'}`);
+    console.log(`  ${chalk.bold('URL:')}       ${chalk.blue(ingress.publicUrl || '-')}`);
+  } catch (error) {
+    spinner.fail('Failed to create ingress');
+    if (error.response?.status === 403) {
+      console.log(chalk.red('\n⚠ Kubernetes Ingress is a paid feature. Upgrade your plan to access it.'));
+      console.log(chalk.yellow('Visit https://tunnelapi.in/pricing to upgrade.'));
+    } else {
+      console.error(chalk.red(error.response?.data?.error || error.message));
+    }
+  }
+}
+
+/**
+ * Get ingress details
+ */
+async function get(name, options) {
+  const spinner = ora('Fetching ingress...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const namespace = options.namespace || 'default';
+    const response = await api.get(`/ingress/${namespace}/${name}`);
+    const ingress = response.data.ingress;
+    
+    spinner.stop();
+    
+    console.log('\n' + chalk.green('Ingress Details:'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`  ${chalk.bold('Name:')}      ${ingress.metadata?.name}`);
+    console.log(`  ${chalk.bold('Namespace:')} ${ingress.metadata?.namespace || 'default'}`);
+    
+    const rules = ingress.spec?.rules || [];
+    if (rules.length > 0) {
+      console.log('\n' + chalk.cyan('Rules:'));
+      rules.forEach((rule, i) => {
+        console.log(`  ${chalk.bold(`Rule ${i + 1}:`)} ${rule.host || '*'}`);
+        const paths = rule.http?.paths || [];
+        paths.forEach(p => {
+          const backend = p.backend?.service?.name || p.backend?.url || '-';
+          console.log(`    ${p.path} → ${backend}`);
+        });
+      });
+    }
+  } catch (error) {
+    spinner.fail('Failed to fetch ingress');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+/**
+ * Delete ingress
+ */
+async function remove(name, options) {
+  const spinner = ora('Deleting ingress...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const namespace = options.namespace || 'default';
+    await api.delete(`/ingress/${namespace}/${name}`);
+    
+    spinner.succeed('Ingress deleted successfully!');
+  } catch (error) {
+    spinner.fail('Failed to delete ingress');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+/**
+ * Export ingress as YAML
+ */
+async function exportYaml(name, options) {
+  const spinner = ora('Exporting ingress...').start();
+  
+  try {
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const namespace = options.namespace || 'default';
+    const response = await api.get(`/ingress/${namespace}/${name}/yaml`);
+    
+    spinner.stop();
+    
+    const yaml = response.data.yaml;
+    
+    if (options.output) {
+      fs.writeFileSync(options.output, yaml);
+      console.log(chalk.green(`✓ YAML exported to ${options.output}`));
+    } else {
+      console.log('\n' + chalk.cyan('Ingress YAML:'));
+      console.log(chalk.gray('─'.repeat(50)));
+      console.log(yaml);
+    }
+  } catch (error) {
+    spinner.fail('Failed to export ingress');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+/**
+ * Validate YAML
+ */
+async function validate(yamlFile) {
+  const spinner = ora('Validating YAML...').start();
+  
+  try {
+    if (!fs.existsSync(yamlFile)) {
+      spinner.fail('YAML file not found');
+      console.error(chalk.red(`File not found: ${yamlFile}`));
+      return;
+    }
+    
+    const yamlContent = fs.readFileSync(yamlFile, 'utf8');
+    
+    const api = await getApiClient();
+    await requireAuth(api);
+    
+    const response = await api.post('/ingress/validate', { yaml: yamlContent });
+    
+    if (response.data.valid) {
+      spinner.succeed('YAML is valid!');
+    } else {
+      spinner.fail('YAML validation failed');
+      console.error(chalk.red(response.data.errors?.join('\n') || 'Unknown error'));
+    }
+  } catch (error) {
+    spinner.fail('Validation failed');
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
+}
+
+module.exports = {
+  list,
+  create,
+  createFromYaml,
+  get,
+  remove,
+  exportYaml,
+  validate
+};

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.1",
   "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,9 @@ 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
+    tunnelServerUrl: 'wss://tunnel.tunnelapi.in',
     token: null,
     userId: null,
     email: null,
@@ -16,6 +18,13 @@ const config = new Conf({
       type: 'string',
       format: 'uri'
     },
+    API_URL: {
+      type: 'string',
+      format: 'uri'
+    },
+    tunnelServerUrl: {
+      type: 'string'
+    },
     token: {
       type: ['string', 'null']
     },