api-response-manager 2.5.1 → 2.5.3

package/README.md

@@ -6,7 +6,7 @@
 
 Command-line interface for API Response Manager. Manage tunnels, webhooks, and projects from your terminal.
 
-**Version:** 2.5.0 | **Live Service:** https://tunnelapi.in
+**Version:** 2.5.3 | **Live Service:** https://tunnelapi.in
 
 ## Installation
 

package/bin/arm.js

@@ -38,6 +38,7 @@ program
   .option('-e, --email <email>', 'Email address')
   .option('-p, --password <password>', 'Password')
   .option('--provider <provider>', 'OAuth provider (google, github, microsoft)')
+  .option('-t, --token <token>', 'API token for CI/CD automation')
   .action(loginCommand);
 
 // Logout command
@@ -58,6 +59,7 @@ program
   .option('-p, --protocol <protocol>', 'Protocol (http, https, tcp, ws, wss)', 'http')
   .option('--ssl', 'Enable SSL/HTTPS')
   .option('-d, --domain <domain>', 'Custom domain')
+  .option('--json', 'Output in JSON format (for CI/CD automation)')
   .action(tunnelCommand.start);
 
 program
@@ -71,6 +73,11 @@ program
   .argument('<tunnelId>', 'Tunnel ID to stop')
   .action(tunnelCommand.stop);
 
+program
+  .command('tunnel:stop-all')
+  .description('Stop all active tunnels')
+  .action(tunnelCommand.stopAll);
+
 program
   .command('tunnel:logs')
   .description('View tunnel request logs')

package/commands/account.js

@@ -1,7 +1,7 @@
 const chalk = require('chalk');
 const ora = require('ora');
 const Table = require('cli-table3');
-const { getApiClient, requireAuth } = require('../utils/api');
+const api = require('../utils/api');
 
 /**
  * Get current user info
@@ -10,10 +10,14 @@ async function info() {
   const spinner = ora('Fetching account info...').start();
   
   try {
-    const api = await getApiClient();
-    await requireAuth(api);
+    const token = api.getToken();
+    if (!token) {
+      spinner.fail('Not authenticated');
+      console.error(chalk.red('Please run: arm login'));
+      process.exit(1);
+    }
     
-    const response = await api.get('/auth/me');
+    const response = await api.client.get('/auth/me');
     const user = response.data.user;
     
     spinner.stop();
@@ -52,10 +56,14 @@ async function features() {
   const spinner = ora('Fetching feature access...').start();
   
   try {
-    const api = await getApiClient();
-    await requireAuth(api);
+    const token = api.getToken();
+    if (!token) {
+      spinner.fail('Not authenticated');
+      console.error(chalk.red('Please run: arm login'));
+      process.exit(1);
+    }
     
-    const response = await api.get('/auth/features');
+    const response = await api.client.get('/auth/features');
     const { tier, features } = response.data;
     
     spinner.stop();
@@ -102,12 +110,16 @@ async function usage() {
   const spinner = ora('Fetching usage stats...').start();
   
   try {
-    const api = await getApiClient();
-    await requireAuth(api);
+    const token = api.getToken();
+    if (!token) {
+      spinner.fail('Not authenticated');
+      console.error(chalk.red('Please run: arm login'));
+      process.exit(1);
+    }
     
     const [userRes, featuresRes] = await Promise.all([
-      api.get('/auth/me'),
-      api.get('/auth/features')
+      api.client.get('/auth/me'),
+      api.client.get('/auth/features')
     ]);
     
     const user = userRes.data.user;

package/commands/login.js

@@ -6,6 +6,31 @@ const api = require('../utils/api');
 const config = require('../utils/config');
 
 async function login(options) {
+  // Token-based login for CI/CD automation
+  if (options.token) {
+    const spinner = ora('Authenticating with token...').start();
+    try {
+      // Validate token by making a test API call
+      config.set('token', options.token);
+      const response = await api.getUser();
+      
+      if (response && response.user) {
+        config.set('userId', response.user._id || response.user.id);
+        config.set('email', response.user.email);
+        spinner.succeed(chalk.green('Authenticated successfully!'));
+        console.log(chalk.gray(`\nLogged in as: ${response.user.email}\n`));
+      } else {
+        throw new Error('Invalid token');
+      }
+    } catch (error) {
+      config.delete('token');
+      spinner.fail(chalk.red('Authentication failed'));
+      console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+      process.exit(1);
+    }
+    return;
+  }
+
   console.log(chalk.blue.bold('\n🔐 API Response Manager - Login\n'));
 
   // Check if social login is requested

package/commands/tunnel.js

@@ -8,14 +8,20 @@ const config = require('../utils/config');
 
 // Start tunnel
 async function start(port, options) {
-  console.log(chalk.blue.bold('\n🚇 Starting Tunnel...\n'));
+  const jsonOutput = options.json || false;
+  
+  if (!jsonOutput) {
+    console.log(chalk.blue.bold('\n🚇 Starting Tunnel...\n'));
+  }
 
   if (!port) {
     port = config.get('defaultTunnelPort');
-    console.log(chalk.gray(`Using default port: ${port}`));
+    if (!jsonOutput) {
+      console.log(chalk.gray(`Using default port: ${port}`));
+    }
   }
 
-  const spinner = ora('Creating tunnel...').start();
+  const spinner = jsonOutput ? null : ora('Creating tunnel...').start();
 
   try {
     const tunnelData = {
@@ -37,7 +43,22 @@ async function start(port, options) {
     const response = await api.createTunnel(tunnelData);
     const tunnel = response.tunnel;
 
-    spinner.succeed(chalk.green('Tunnel created successfully!'));
+    if (spinner) spinner.succeed(chalk.green('Tunnel created successfully!'));
+
+    // JSON output for automation/CI
+    if (jsonOutput) {
+      console.log(JSON.stringify({
+        success: true,
+        id: tunnel.id || tunnel._id,
+        subdomain: tunnel.subdomain,
+        publicUrl: tunnel.publicUrl,
+        localPort: tunnel.localPort,
+        protocol: tunnel.protocol || 'https'
+      }));
+      // For JSON mode, connect silently
+      await connectTunnelClient(tunnel.id || tunnel._id, tunnel.subdomain, tunnel.localPort, true);
+      return;
+    }
 
     // Safe string padding function
     const safePadEnd = (str, length) => {
@@ -56,17 +77,30 @@ async function start(port, options) {
 
     // Connect tunnel client
     console.log(chalk.blue('Connecting tunnel client...\n'));
-    await connectTunnelClient(tunnel.id || tunnel._id, tunnel.subdomain, tunnel.localPort);
+    await connectTunnelClient(tunnel.id || tunnel._id, tunnel.subdomain, tunnel.localPort, false);
 
   } catch (error) {
-    spinner.fail(chalk.red('Failed to create tunnel'));
-    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    if (spinner) spinner.fail(chalk.red('Failed to create tunnel'));
+    
+    const errorMsg = error.response?.data?.msg || error.message;
+    
+    // Handle subdomain already taken error
+    if (error.response?.status === 409 && errorMsg.toLowerCase().includes('subdomain')) {
+      console.error(chalk.yellow(`\n⚠ ${errorMsg}`));
+      console.log(chalk.gray('\nOptions:'));
+      console.log(chalk.gray('  1. Try again with a different subdomain: ') + chalk.cyan(`arm tunnel ${port} -s <new-subdomain>`));
+      console.log(chalk.gray('  2. Let the system generate a unique subdomain: ') + chalk.cyan(`arm tunnel ${port}`));
+      console.log();
+      process.exit(1);
+    }
+    
+    console.error(chalk.red(`\n✗ ${errorMsg}\n`));
     process.exit(1);
   }
 }
 
 // Connect tunnel client
-async function connectTunnelClient(tunnelId, subdomain, localPort) {
+async function connectTunnelClient(tunnelId, subdomain, localPort, silent = false) {
   const tunnelServerUrl = config.get('tunnelServerUrl') || 'ws://localhost:8080';
   const token = api.getToken();
   const userId = config.get('userId');
@@ -76,7 +110,7 @@ async function connectTunnelClient(tunnelId, subdomain, localPort) {
   let heartbeatInterval;
 
   ws.on('open', () => {
-    console.log(chalk.green('✓ Connected to tunnel server'));
+    if (!silent) console.log(chalk.green('✓ Connected to tunnel server'));
     
     ws.send(JSON.stringify({
       type: 'register',
@@ -99,29 +133,46 @@ async function connectTunnelClient(tunnelId, subdomain, localPort) {
     const message = JSON.parse(data.toString());
 
     if (message.type === 'registered') {
-      console.log(chalk.green.bold('\n🎉 Tunnel Active!\n'));
-      console.log(chalk.white('Your local server is now accessible at:'));
-      console.log(chalk.cyan.bold(`   ${message.publicUrl}\n`));
-      console.log(chalk.gray('Press Ctrl+C to stop the tunnel\n'));
+      if (!silent) {
+        console.log(chalk.green.bold('\n🎉 Tunnel Active!\n'));
+        console.log(chalk.white('Your local server is now accessible at:'));
+        console.log(chalk.cyan.bold(`   ${message.publicUrl}\n`));
+        console.log(chalk.gray('Press Ctrl+C to stop the tunnel\n'));
+      }
     } else if (message.type === 'request') {
-      const timestamp = new Date().toLocaleTimeString();
-      console.log(chalk.gray(`[${timestamp}]`), chalk.blue(message.method), chalk.white(message.path));
+      if (!silent) {
+        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}`;
+        
+        // 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 +180,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}`));
@@ -245,6 +297,38 @@ async function stop(tunnelId) {
   }
 }
 
+// Stop all tunnels
+async function stopAll() {
+  const spinner = ora('Stopping all tunnels...').start();
+
+  try {
+    const response = await api.getTunnels();
+    const tunnels = response.tunnels || [];
+
+    if (tunnels.length === 0) {
+      spinner.info(chalk.yellow('No active tunnels to stop'));
+      return;
+    }
+
+    let stopped = 0;
+    for (const tunnel of tunnels) {
+      try {
+        await api.deleteTunnel(tunnel._id || tunnel.id);
+        stopped++;
+      } catch (e) {
+        // Continue stopping other tunnels
+      }
+    }
+
+    spinner.succeed(chalk.green(`Stopped ${stopped} tunnel(s)`));
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to stop tunnels'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
 // View tunnel logs
 async function logs(tunnelId, options) {
   const spinner = ora('Fetching logs...').start();
@@ -423,6 +507,7 @@ module.exports = {
   start,
   list,
   stop,
+  stopAll,
   logs,
   setDomain,
   uploadSSL,

package/package.json

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

package/utils/api.js

@@ -59,6 +59,11 @@ class APIClient {
     return response.data;
   }
 
+  async getUser() {
+    const response = await this.client.get('/auth/me');
+    return response.data;
+  }
+
   // OAuth Device Flow for CLI
   async requestDeviceCode(provider) {
     const response = await this.client.post('/auth/device/code', { provider });