api-response-manager 2.5.2 → 2.5.4

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

@@ -24,6 +24,8 @@ const healthCommand = require('../commands/health');
 const gatewayCommand = require('../commands/gateway');
 const ingressCommand = require('../commands/ingress');
 const accountCommand = require('../commands/account');
+const installCommand = require('../commands/install');
+const uninstallCommand = require('../commands/uninstall');
 
 // CLI setup
 program
@@ -38,6 +40,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
@@ -55,9 +58,10 @@ program
   .option('-n, --name <name>', 'Tunnel name')
   .option('-a, --auth', 'Enable basic authentication')
   .option('-r, --rate-limit <limit>', 'Rate limit (requests per minute)', '60')
-  .option('-p, --protocol <protocol>', 'Protocol (http, https, tcp, ws, wss)', 'http')
+  .option('-p, --protocol <protocol>', 'Protocol (http, https, tcp, ssh, 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 +75,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')
@@ -422,6 +431,18 @@ program
   .argument('<yamlFile>', 'Path to YAML file')
   .action(ingressCommand.validate);
 
+// Install command (self-install with PATH configuration)
+program
+  .command('install')
+  .description('Install CLI to system and configure PATH')
+  .action(installCommand);
+
+// Uninstall command (remove CLI and PATH configuration)
+program
+  .command('uninstall')
+  .description('Uninstall CLI from system and remove from PATH')
+  .action(uninstallCommand);
+
 // Account commands
 program
   .command('account')

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/install.js

@@ -0,0 +1,136 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const install = async () => {
+  const platform = os.platform();
+  const currentPath = process.execPath;
+  
+  console.log('');
+  console.log(chalk.cyan('  TunnelAPI CLI Installer'));
+  console.log(chalk.cyan('  ======================='));
+  console.log('');
+
+  // Determine if running as standalone binary or via Node
+  const isStandalone = !currentPath.includes('node');
+  
+  if (!isStandalone) {
+    console.log(chalk.yellow('  You are running via npm/Node.js.'));
+    console.log(chalk.yellow('  The CLI is already installed globally via npm.'));
+    console.log('');
+    console.log('  To verify: ' + chalk.white('arm --version'));
+    console.log('');
+    return;
+  }
+
+  try {
+    if (platform === 'win32') {
+      await installWindows(currentPath);
+    } else if (platform === 'darwin' || platform === 'linux') {
+      await installUnix(currentPath, platform);
+    } else {
+      console.log(chalk.red(`  Unsupported platform: ${platform}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.log(chalk.red(`  Installation failed: ${error.message}`));
+    process.exit(1);
+  }
+};
+
+async function installWindows(currentPath) {
+  const installDir = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'TunnelAPI');
+  const targetPath = path.join(installDir, 'arm.exe');
+
+  console.log(chalk.yellow('[1/3] Creating install directory...'));
+  if (!fs.existsSync(installDir)) {
+    fs.mkdirSync(installDir, { recursive: true });
+  }
+  console.log(chalk.gray(`      ${installDir}`));
+
+  console.log(chalk.yellow('[2/3] Copying binary...'));
+  if (currentPath !== targetPath) {
+    fs.copyFileSync(currentPath, targetPath);
+  }
+  console.log(chalk.green('      Copied successfully'));
+
+  console.log(chalk.yellow('[3/3] Configuring PATH...'));
+  try {
+    // Get current user PATH
+    const currentUserPath = execSync('powershell -Command "[Environment]::GetEnvironmentVariable(\'Path\', \'User\')"', { encoding: 'utf8' }).trim();
+    
+    if (!currentUserPath.includes(installDir)) {
+      // Add to user PATH
+      const newPath = currentUserPath ? `${currentUserPath};${installDir}` : installDir;
+      execSync(`powershell -Command "[Environment]::SetEnvironmentVariable('Path', '${newPath.replace(/'/g, "''")}', 'User')"`, { encoding: 'utf8' });
+      console.log(chalk.green('      Added to user PATH'));
+    } else {
+      console.log(chalk.gray('      Already in PATH'));
+    }
+  } catch (err) {
+    console.log(chalk.yellow('      Could not update PATH automatically.'));
+    console.log(chalk.yellow(`      Please add this to your PATH manually: ${installDir}`));
+  }
+
+  printSuccess('Windows');
+}
+
+async function installUnix(currentPath, platform) {
+  const installDir = '/usr/local/bin';
+  const targetPath = path.join(installDir, 'arm');
+  const needsSudo = !isWritable(installDir);
+
+  console.log(chalk.yellow('[1/2] Copying binary...'));
+  
+  try {
+    if (needsSudo) {
+      console.log(chalk.gray('      (requires sudo)'));
+      execSync(`sudo cp "${currentPath}" "${targetPath}"`, { stdio: 'inherit' });
+      execSync(`sudo chmod +x "${targetPath}"`, { stdio: 'inherit' });
+    } else {
+      fs.copyFileSync(currentPath, targetPath);
+      fs.chmodSync(targetPath, '755');
+    }
+    console.log(chalk.green('      Installed to ' + targetPath));
+  } catch (err) {
+    throw new Error(`Failed to copy binary: ${err.message}`);
+  }
+
+  console.log(chalk.yellow('[2/2] Verifying installation...'));
+  try {
+    const version = execSync(`"${targetPath}" --version`, { encoding: 'utf8' }).trim();
+    console.log(chalk.green(`      Installed: arm v${version}`));
+  } catch (err) {
+    console.log(chalk.yellow('      Could not verify installation'));
+  }
+
+  printSuccess(platform === 'darwin' ? 'macOS' : 'Linux');
+}
+
+function isWritable(dir) {
+  try {
+    fs.accessSync(dir, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function printSuccess(platform) {
+  console.log('');
+  console.log(chalk.green('  ✓ Installation complete!'));
+  console.log('');
+  console.log(chalk.cyan('  To get started:'));
+  if (platform === 'Windows') {
+    console.log(chalk.white('    1. Open a NEW terminal window'));
+  }
+  console.log(chalk.white('    1. Run: arm login'));
+  console.log(chalk.white('    2. Run: arm tunnel 3000'));
+  console.log('');
+  console.log(chalk.gray('  Documentation: https://docs.tunnelapi.in'));
+  console.log('');
+}
+
+module.exports = install;

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

@@ -3,19 +3,29 @@ const ora = require('ora');
 const WebSocket = require('ws');
 const Table = require('cli-table3');
 const axios = require('axios');
+const net = require('net');
 const api = require('../utils/api');
 const config = require('../utils/config');
 
+// Track TCP connections for SSH/TCP tunnels
+const tcpConnections = new Map();
+
 // 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 +47,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 +81,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, options.protocol || 'http', 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, protocol = 'http', silent = false) {
   const tunnelServerUrl = config.get('tunnelServerUrl') || 'ws://localhost:8080';
   const token = api.getToken();
   const userId = config.get('userId');
@@ -74,15 +112,17 @@ async function connectTunnelClient(tunnelId, subdomain, localPort) {
   const ws = new WebSocket(tunnelServerUrl);
 
   let heartbeatInterval;
+  const isTcpTunnel = protocol === 'tcp' || protocol === 'ssh';
 
   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',
       tunnelId,
       subdomain,
       localPort,
+      protocol,
       authToken: token,
       userId
     }));
@@ -99,13 +139,42 @@ 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`));
+        
+        // Show TCP/SSH specific info
+        if (isTcpTunnel && message.tcpHost && message.tcpPort) {
+          console.log(chalk.yellow.bold('🔌 TCP/SSH Connection Info:\n'));
+          console.log(chalk.white(`   TCP Host: ${message.tcpHost}`));
+          console.log(chalk.white(`   TCP Port: ${message.tcpPort}\n`));
+          if (message.sshCommand) {
+            console.log(chalk.gray('SSH Command (Linux/Mac):'));
+            console.log(chalk.cyan(`   ${message.sshCommand}\n`));
+            console.log(chalk.gray('SSH Command (Windows with ncat):'));
+            console.log(chalk.cyan(`   ssh -o ProxyCommand="ncat ${message.tcpHost} ${message.tcpPort}" user@${message.tcpHost}\n`));
+            console.log(chalk.gray('SSH with Key (passwordless):'));
+            console.log(chalk.cyan(`   ssh -i ~/.ssh/your_key.pem -o ProxyCommand="echo 'SUBDOMAIN:${subdomain}' | nc %h %p" user@${message.tcpHost} -p ${message.tcpPort}\n`));
+          }
+        }
+        
+        console.log(chalk.gray('Press Ctrl+C to stop the tunnel\n'));
+      }
+    } else if (message.type === 'tcp-connect') {
+      // Handle new TCP connection for SSH/TCP tunnels
+      handleTcpConnect(message, localPort, ws, silent);
+    } else if (message.type === 'tcp-data') {
+      // Handle TCP data from tunnel server
+      handleTcpData(message, ws, silent);
+    } else if (message.type === 'tcp-end') {
+      // Handle TCP connection close
+      handleTcpEnd(message, silent);
     } 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 {
@@ -117,15 +186,34 @@ async function connectTunnelClient(tunnelId, subdomain, localPort) {
         delete forwardHeaders['connection'];
         delete forwardHeaders['accept-encoding']; // Prevent compression issues
         
+        // Handle body - check if it's base64 encoded (binary/multipart data)
+        let requestBody = message.body;
+        if (message.body && typeof message.body === 'object' && message.body._isBase64) {
+          // Decode base64 body back to Buffer
+          requestBody = Buffer.from(message.body.data, 'base64');
+          if (!silent) {
+            console.log(chalk.gray(`  📎 Decoded ${message.body._isMultipart ? 'multipart' : 'binary'} body: ${requestBody.length} bytes`));
+          }
+          // For multipart, keep the original content-length
+          if (!message.body._isMultipart) {
+            delete forwardHeaders['content-length'];
+          }
+        } else {
+          // For non-binary data, let axios calculate content-length
+          delete forwardHeaders['content-length'];
+        }
+        
         const response = await axios({
           method: message.method.toLowerCase(),
           url: localUrl,
           headers: forwardHeaders,
-          data: message.body,
+          data: requestBody,
           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
+          timeout: 25000, // 25 second timeout
+          maxBodyLength: Infinity, // Allow large file uploads
+          maxContentLength: Infinity // Allow large responses
         });
         
         // Clean up headers to avoid conflicts
@@ -259,6 +347,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();
@@ -433,10 +553,106 @@ async function configureIngress(tunnelId, rules, options) {
   }
 }
 
+// TCP connection handlers for SSH/TCP tunnels
+function handleTcpConnect(message, localPort, ws, silent) {
+  const { connectionId, remoteAddress, remotePort } = message;
+  
+  if (!silent) {
+    const timestamp = new Date().toLocaleTimeString();
+    console.log(chalk.gray(`[${timestamp}]`), chalk.magenta('TCP'), chalk.white(`Connection from ${remoteAddress}:${remotePort}`));
+  }
+  
+  // Create connection to local server (e.g., SSH on port 22)
+  const localSocket = net.createConnection({
+    host: 'localhost',
+    port: localPort
+  });
+  
+  tcpConnections.set(connectionId, localSocket);
+  
+  localSocket.on('connect', () => {
+    if (!silent) {
+      console.log(chalk.green(`  ✓ Connected to local port ${localPort}`));
+    }
+  });
+  
+  localSocket.on('data', (data) => {
+    // Forward data back to tunnel server
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({
+        type: 'tcp-response',
+        connectionId,
+        data: data.toString('base64')
+      }));
+    }
+  });
+  
+  localSocket.on('end', () => {
+    if (!silent) {
+      console.log(chalk.gray(`  TCP connection ended: ${connectionId.substring(0, 8)}...`));
+    }
+    tcpConnections.delete(connectionId);
+    
+    // Notify tunnel server
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({
+        type: 'tcp-close',
+        connectionId
+      }));
+    }
+  });
+  
+  localSocket.on('error', (error) => {
+    console.error(chalk.red(`  TCP error: ${error.message}`));
+    tcpConnections.delete(connectionId);
+    
+    // Notify tunnel server
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({
+        type: 'tcp-close',
+        connectionId
+      }));
+    }
+  });
+}
+
+function handleTcpData(message, ws, silent) {
+  const { connectionId, data } = message;
+  
+  const localSocket = tcpConnections.get(connectionId);
+  if (!localSocket) {
+    if (!silent) {
+      console.warn(chalk.yellow(`  No local socket found for ${connectionId.substring(0, 8)}...`));
+    }
+    return;
+  }
+  
+  try {
+    const buffer = Buffer.from(data, 'base64');
+    localSocket.write(buffer);
+  } catch (error) {
+    console.error(chalk.red(`  Error writing to local socket: ${error.message}`));
+  }
+}
+
+function handleTcpEnd(message, silent) {
+  const { connectionId } = message;
+  
+  const localSocket = tcpConnections.get(connectionId);
+  if (localSocket) {
+    localSocket.end();
+    tcpConnections.delete(connectionId);
+    if (!silent) {
+      console.log(chalk.gray(`  TCP connection closed: ${connectionId.substring(0, 8)}...`));
+    }
+  }
+}
+
 module.exports = {
   start,
   list,
   stop,
+  stopAll,
   logs,
   setDomain,
   uploadSSL,

package/commands/uninstall.js

@@ -0,0 +1,153 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const uninstall = async () => {
+  const platform = os.platform();
+  
+  console.log('');
+  console.log(chalk.cyan('  TunnelAPI CLI Uninstaller'));
+  console.log(chalk.cyan('  ========================='));
+  console.log('');
+
+  try {
+    if (platform === 'win32') {
+      await uninstallWindows();
+    } else if (platform === 'darwin' || platform === 'linux') {
+      await uninstallUnix(platform);
+    } else {
+      console.log(chalk.red(`  Unsupported platform: ${platform}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.log(chalk.red(`  Uninstall failed: ${error.message}`));
+    process.exit(1);
+  }
+};
+
+async function uninstallWindows() {
+  const installDir = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'TunnelAPI');
+  const binaryPath = path.join(installDir, 'arm.exe');
+
+  console.log(chalk.yellow('[1/3] Removing from PATH...'));
+  try {
+    const currentUserPath = execSync('powershell -Command "[Environment]::GetEnvironmentVariable(\'Path\', \'User\')"', { encoding: 'utf8' }).trim();
+    
+    if (currentUserPath.includes(installDir)) {
+      // Remove install dir from PATH
+      const pathParts = currentUserPath.split(';').filter(p => p && !p.includes('TunnelAPI'));
+      const newPath = pathParts.join(';');
+      execSync(`powershell -Command "[Environment]::SetEnvironmentVariable('Path', '${newPath.replace(/'/g, "''")}', 'User')"`, { encoding: 'utf8' });
+      console.log(chalk.green('      Removed from user PATH'));
+    } else {
+      console.log(chalk.gray('      Not in PATH'));
+    }
+  } catch (err) {
+    console.log(chalk.yellow('      Could not update PATH automatically'));
+  }
+
+  console.log(chalk.yellow('[2/3] Removing binary...'));
+  if (fs.existsSync(binaryPath)) {
+    try {
+      fs.unlinkSync(binaryPath);
+      console.log(chalk.green('      Removed ' + binaryPath));
+    } catch (err) {
+      console.log(chalk.yellow('      Could not remove binary (may be in use)'));
+      console.log(chalk.yellow(`      Please manually delete: ${binaryPath}`));
+    }
+  } else {
+    console.log(chalk.gray('      Binary not found at ' + binaryPath));
+  }
+
+  console.log(chalk.yellow('[3/3] Cleaning up install directory...'));
+  if (fs.existsSync(installDir)) {
+    try {
+      const files = fs.readdirSync(installDir);
+      if (files.length === 0) {
+        fs.rmdirSync(installDir);
+        console.log(chalk.green('      Removed install directory'));
+      } else {
+        console.log(chalk.gray('      Directory not empty, keeping it'));
+      }
+    } catch (err) {
+      console.log(chalk.gray('      Could not remove directory'));
+    }
+  }
+
+  printSuccess('Windows');
+}
+
+async function uninstallUnix(platform) {
+  const binaryPath = '/usr/local/bin/arm';
+  const needsSudo = !isWritable('/usr/local/bin');
+
+  console.log(chalk.yellow('[1/2] Checking for binary...'));
+  
+  if (!fs.existsSync(binaryPath)) {
+    console.log(chalk.gray('      Binary not found at ' + binaryPath));
+    console.log(chalk.yellow('      Checking other locations...'));
+    
+    // Check common locations
+    const altPaths = [
+      path.join(os.homedir(), '.local', 'bin', 'arm'),
+      '/usr/bin/arm',
+      '/opt/tunnelapi/arm'
+    ];
+    
+    let found = false;
+    for (const altPath of altPaths) {
+      if (fs.existsSync(altPath)) {
+        console.log(chalk.gray(`      Found at ${altPath}`));
+        found = true;
+      }
+    }
+    
+    if (!found) {
+      console.log(chalk.gray('      No installation found'));
+    }
+    
+    printSuccess(platform === 'darwin' ? 'macOS' : 'Linux');
+    return;
+  }
+
+  console.log(chalk.yellow('[2/2] Removing binary...'));
+  try {
+    if (needsSudo) {
+      console.log(chalk.gray('      (requires sudo)'));
+      execSync(`sudo rm -f "${binaryPath}"`, { stdio: 'inherit' });
+    } else {
+      fs.unlinkSync(binaryPath);
+    }
+    console.log(chalk.green('      Removed ' + binaryPath));
+  } catch (err) {
+    console.log(chalk.red(`      Failed to remove: ${err.message}`));
+    console.log(chalk.yellow(`      Try manually: sudo rm ${binaryPath}`));
+  }
+
+  printSuccess(platform === 'darwin' ? 'macOS' : 'Linux');
+}
+
+function isWritable(dir) {
+  try {
+    fs.accessSync(dir, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function printSuccess(platform) {
+  console.log('');
+  console.log(chalk.green('  ✓ Uninstall complete!'));
+  console.log('');
+  if (platform === 'Windows') {
+    console.log(chalk.cyan('  Note: Open a NEW terminal for PATH changes to take effect.'));
+  }
+  console.log(chalk.gray('  Thank you for using TunnelAPI!'));
+  console.log(chalk.gray('  Feedback: info@tunnelapi.in'));
+  console.log('');
+}
+
+module.exports = uninstall;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-response-manager",
-  "version": "2.5.2",
+  "version": "2.5.4",
   "description": "Command-line interface for API Response Manager",
   "main": "index.js",
   "bin": {
@@ -9,7 +9,30 @@
   "scripts": {
     "test": "jest",
     "link": "npm link",
-    "prepublishOnly": "echo 'Publishing api-response-manager CLI...'"
+    "prepublishOnly": "echo 'Publishing api-response-manager CLI...'",
+    "build": "pkg . --out-path dist",
+    "build:win": "pkg . -t node18-win-x64 --out-path dist",
+    "build:mac": "pkg . -t node18-macos-x64 --out-path dist",
+    "build:mac-arm": "pkg . -t node18-macos-arm64 --out-path dist",
+    "build:linux": "pkg . -t node18-linux-x64 --out-path dist",
+    "build:all": "pkg . -t node18-win-x64,node18-macos-x64,node18-macos-arm64,node18-linux-x64 --out-path dist"
+  },
+  "pkg": {
+    "scripts": [
+      "bin/**/*.js",
+      "commands/**/*.js",
+      "utils/**/*.js"
+    ],
+    "assets": [
+      "node_modules/**/*"
+    ],
+    "targets": [
+      "node18-win-x64",
+      "node18-macos-x64",
+      "node18-macos-arm64",
+      "node18-linux-x64"
+    ],
+    "outputPath": "dist"
   },
   "files": [
     "bin/",
@@ -45,7 +68,9 @@
     "ws": "^8.14.2"
   },
   "devDependencies": {
-    "jest": "^29.7.0"
+    "@yao-pkg/pkg": "^5.11.0",
+    "jest": "^29.7.0",
+    "rcedit": "^5.0.2"
   },
   "engines": {
     "node": ">=14.0.0"

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 });