api-response-manager 2.5.0 → 2.5.2

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

@@ -110,18 +110,31 @@ async function connectTunnelClient(tunnelId, subdomain, localPort) {
       // Forward request to local server
       try {
         const localUrl = `http://localhost:${localPort}${message.path}`;
+        
+        // Remove problematic headers that cause issues with local server
+        const forwardHeaders = { ...message.headers };
+        delete forwardHeaders['host'];
+        delete forwardHeaders['connection'];
+        delete forwardHeaders['accept-encoding']; // Prevent compression issues
+        
         const response = await axios({
           method: message.method.toLowerCase(),
           url: localUrl,
-          headers: message.headers || {},
+          headers: forwardHeaders,
           data: message.body,
-          validateStatus: () => true // Accept any status code
+          validateStatus: () => true, // Accept any status code
+          responseType: 'arraybuffer', // Handle binary data properly
+          maxRedirects: 0, // Don't follow redirects, let the client handle them
+          timeout: 25000 // 25 second timeout
         });
         
         // Clean up headers to avoid conflicts
         const cleanHeaders = { ...response.headers };
         delete cleanHeaders['transfer-encoding'];
-        delete cleanHeaders['content-length'];
+        delete cleanHeaders['connection'];
+        
+        // Convert binary data to base64 for JSON transport
+        const bodyBase64 = Buffer.from(response.data).toString('base64');
         
         // Send response back to tunnel server
         ws.send(JSON.stringify({
@@ -129,7 +142,8 @@ async function connectTunnelClient(tunnelId, subdomain, localPort) {
           requestId: message.requestId,
           statusCode: response.status,
           headers: cleanHeaders,
-          body: response.data
+          body: bodyBase64,
+          encoding: 'base64'
         }));
       } catch (error) {
         console.error(chalk.red(`Error forwarding request: ${error.message}`));

package/package.json

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

package/utils/config.js

@@ -6,6 +6,7 @@ const config = new Conf({
   defaults: {
     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,
@@ -21,6 +22,9 @@ const config = new Conf({
       type: 'string',
       format: 'uri'
     },
+    tunnelServerUrl: {
+      type: 'string'
+    },
     token: {
       type: ['string', 'null']
     },