api-response-manager 2.3.0 → 2.3.1

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-response-manager",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "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",
@@ -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

@@ -185,6 +185,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/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
-```