api-response-manager 2.5.3 → 2.5.4

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
@@ -56,7 +58,7 @@ 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)')
@@ -429,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/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/tunnel.js

@@ -3,9 +3,13 @@ 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) {
   const jsonOutput = options.json || false;
@@ -77,7 +81,7 @@ 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, false);
+    await connectTunnelClient(tunnel.id || tunnel._id, tunnel.subdomain, tunnel.localPort, options.protocol || 'http', false);
 
   } catch (error) {
     if (spinner) spinner.fail(chalk.red('Failed to create tunnel'));
@@ -100,7 +104,7 @@ async function start(port, options) {
 }
 
 // Connect tunnel client
-async function connectTunnelClient(tunnelId, subdomain, localPort, silent = false) {
+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');
@@ -108,6 +112,7 @@ async function connectTunnelClient(tunnelId, subdomain, localPort, silent = fals
   const ws = new WebSocket(tunnelServerUrl);
 
   let heartbeatInterval;
+  const isTcpTunnel = protocol === 'tcp' || protocol === 'ssh';
 
   ws.on('open', () => {
     if (!silent) console.log(chalk.green('✓ Connected to tunnel server'));
@@ -117,6 +122,7 @@ async function connectTunnelClient(tunnelId, subdomain, localPort, silent = fals
       tunnelId,
       subdomain,
       localPort,
+      protocol,
       authToken: token,
       userId
     }));
@@ -137,8 +143,33 @@ async function connectTunnelClient(tunnelId, subdomain, localPort, silent = fals
         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') {
       if (!silent) {
         const timestamp = new Date().toLocaleTimeString();
@@ -155,15 +186,34 @@ async function connectTunnelClient(tunnelId, subdomain, localPort, silent = fals
         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
@@ -503,6 +553,101 @@ 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,

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.3",
+  "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"