api-response-manager 2.5.3 → 2.6.0

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.3 | **Live Service:** https://tunnelapi.in
+**Version:** 2.6.0 | **Live Service:** https://tunnelapi.in
 
 ## Installation
 

package/bin/arm.js

@@ -24,6 +24,9 @@ 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');
+const serveCommand = require('../commands/serve');
 
 // CLI setup
 program
@@ -56,9 +59,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, udp)', 'http')
   .option('--ssl', 'Enable SSL/HTTPS')
   .option('-d, --domain <domain>', 'Custom domain')
+  .option('--e2e', 'Enable end-to-end encryption')
   .option('--json', 'Output in JSON format (for CI/CD automation)')
   .action(tunnelCommand.start);
 
@@ -141,6 +145,15 @@ program
   .option('--tls', 'Enable TLS for ingress')
   .action(tunnelCommand.configureIngress);
 
+// Serve command - file sharing
+program
+  .command('serve')
+  .description('Share a directory over the internet')
+  .argument('[directory]', 'Directory to serve (default: current directory)', '.')
+  .option('-p, --port <port>', 'Local port for file server', '8000')
+  .option('-s, --subdomain <subdomain>', 'Custom subdomain')
+  .action(serveCommand.serve);
+
 // IP Whitelist commands
 program
   .command('tunnel:ip-whitelist:add')
@@ -429,6 +442,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/serve.js

@@ -0,0 +1,569 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const fs = require('fs');
+const http = require('http');
+const url = require('url');
+const mime = require('mime-types');
+const api = require('../utils/api');
+const config = require('../utils/config');
+
+// File server for serving static files
+class FileServer {
+  constructor(directory, port) {
+    this.directory = path.resolve(directory);
+    this.port = port;
+    this.server = null;
+  }
+
+  start() {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+
+      this.server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+          reject(new Error(`Port ${this.port} is already in use`));
+        } else {
+          reject(err);
+        }
+      });
+
+      this.server.listen(this.port, () => {
+        resolve();
+      });
+    });
+  }
+
+  handleRequest(req, res) {
+    const parsedUrl = url.parse(req.url, true);
+    let pathname = decodeURIComponent(parsedUrl.pathname);
+    
+    // Prevent directory traversal
+    pathname = pathname.replace(/\.\./g, '');
+    
+    let filePath = path.join(this.directory, pathname);
+
+    // Check if path exists
+    fs.stat(filePath, (err, stats) => {
+      if (err) {
+        if (err.code === 'ENOENT') {
+          res.writeHead(404, { 'Content-Type': 'text/html' });
+          res.end(this.generate404Page(pathname));
+        } else {
+          res.writeHead(500, { 'Content-Type': 'text/plain' });
+          res.end('Internal Server Error');
+        }
+        return;
+      }
+
+      if (stats.isDirectory()) {
+        // Check for index.html
+        const indexPath = path.join(filePath, 'index.html');
+        if (fs.existsSync(indexPath)) {
+          this.serveFile(indexPath, res);
+        } else {
+          // Generate directory listing
+          this.serveDirectoryListing(filePath, pathname, res);
+        }
+      } else {
+        this.serveFile(filePath, res);
+      }
+    });
+  }
+
+  serveFile(filePath, res) {
+    const ext = path.extname(filePath).toLowerCase();
+    // Handle JSX/TSX files as JavaScript for development
+    let contentType;
+    if (ext === '.jsx' || ext === '.tsx') {
+      contentType = 'application/javascript';
+    } else if (ext === '.ts') {
+      contentType = 'application/javascript';
+    } else {
+      contentType = mime.lookup(ext) || 'application/octet-stream';
+    }
+
+    fs.readFile(filePath, (err, data) => {
+      if (err) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Error reading file');
+        return;
+      }
+
+      const stats = fs.statSync(filePath);
+      res.writeHead(200, {
+        'Content-Type': contentType,
+        'Content-Length': stats.size,
+        'Cache-Control': 'no-cache',
+        'Access-Control-Allow-Origin': '*'
+      });
+      res.end(data);
+    });
+  }
+
+  serveDirectoryListing(dirPath, urlPath, res) {
+    fs.readdir(dirPath, { withFileTypes: true }, (err, entries) => {
+      if (err) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Error reading directory');
+        return;
+      }
+
+      const html = this.generateDirectoryHTML(entries, urlPath, dirPath);
+      res.writeHead(200, { 
+        'Content-Type': 'text/html',
+        'Cache-Control': 'no-cache'
+      });
+      res.end(html);
+    });
+  }
+
+  generateDirectoryHTML(entries, urlPath, dirPath) {
+    const normalizedPath = urlPath.endsWith('/') ? urlPath : urlPath + '/';
+    
+    let items = entries.map(entry => {
+      const isDir = entry.isDirectory();
+      const name = entry.name;
+      const href = normalizedPath + encodeURIComponent(name) + (isDir ? '/' : '');
+      const icon = isDir ? '📁' : this.getFileIcon(name);
+      const stats = fs.statSync(path.join(dirPath, name));
+      const size = isDir ? '-' : this.formatSize(stats.size);
+      const modified = stats.mtime.toLocaleString();
+      
+      return `
+        <tr>
+          <td class="icon">${icon}</td>
+          <td class="name"><a href="${href}">${name}${isDir ? '/' : ''}</a></td>
+          <td class="size">${size}</td>
+          <td class="modified">${modified}</td>
+        </tr>
+      `;
+    }).join('');
+
+    // Add parent directory link if not at root
+    if (urlPath !== '/' && urlPath !== '') {
+      const parentPath = path.dirname(urlPath) || '/';
+      items = `
+        <tr>
+          <td class="icon">📂</td>
+          <td class="name"><a href="${parentPath}">..</a></td>
+          <td class="size">-</td>
+          <td class="modified">-</td>
+        </tr>
+      ` + items;
+    }
+
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Index of ${urlPath || '/'}</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+      color: #e4e4e7;
+      min-height: 100vh;
+      padding: 2rem;
+    }
+    .container {
+      max-width: 1000px;
+      margin: 0 auto;
+    }
+    h1 {
+      font-size: 1.5rem;
+      margin-bottom: 1.5rem;
+      color: #a78bfa;
+    }
+    .path {
+      color: #94a3b8;
+      font-family: monospace;
+    }
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      background: rgba(255,255,255,0.05);
+      border-radius: 0.5rem;
+      overflow: hidden;
+    }
+    th, td {
+      padding: 0.75rem 1rem;
+      text-align: left;
+      border-bottom: 1px solid rgba(255,255,255,0.1);
+    }
+    th {
+      background: rgba(255,255,255,0.1);
+      font-weight: 600;
+      color: #94a3b8;
+      font-size: 0.875rem;
+    }
+    tr:hover {
+      background: rgba(255,255,255,0.05);
+    }
+    a {
+      color: #60a5fa;
+      text-decoration: none;
+    }
+    a:hover {
+      text-decoration: underline;
+    }
+    .icon { width: 40px; text-align: center; }
+    .size { width: 100px; color: #94a3b8; font-size: 0.875rem; }
+    .modified { color: #94a3b8; font-size: 0.875rem; }
+    .footer {
+      margin-top: 2rem;
+      text-align: center;
+      color: #64748b;
+      font-size: 0.875rem;
+    }
+    .footer a { color: #a78bfa; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>📂 Index of <span class="path">${urlPath || '/'}</span></h1>
+    <table>
+      <thead>
+        <tr>
+          <th></th>
+          <th>Name</th>
+          <th>Size</th>
+          <th>Modified</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${items}
+      </tbody>
+    </table>
+    <div class="footer">
+      Served by <a href="https://tunnelapi.in">TunnelAPI</a> File Server
+    </div>
+  </div>
+</body>
+</html>
+    `;
+  }
+
+  generate404Page(pathname) {
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>404 Not Found</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+      color: #e4e4e7;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      text-align: center;
+    }
+    h1 { font-size: 4rem; color: #ef4444; }
+    p { color: #94a3b8; margin-top: 1rem; }
+    a { color: #60a5fa; }
+  </style>
+</head>
+<body>
+  <div>
+    <h1>404</h1>
+    <p>File not found: ${pathname}</p>
+    <p><a href="/">← Back to root</a></p>
+  </div>
+</body>
+</html>
+    `;
+  }
+
+  getFileIcon(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    const icons = {
+      '.html': '🌐', '.htm': '🌐',
+      '.css': '🎨',
+      '.js': '📜', '.ts': '📜', '.jsx': '📜', '.tsx': '📜',
+      '.json': '📋',
+      '.md': '📝', '.txt': '📝',
+      '.png': '🖼️', '.jpg': '🖼️', '.jpeg': '🖼️', '.gif': '🖼️', '.svg': '🖼️', '.webp': '🖼️',
+      '.pdf': '📕',
+      '.zip': '📦', '.tar': '📦', '.gz': '📦', '.rar': '📦',
+      '.mp3': '🎵', '.wav': '🎵', '.ogg': '🎵',
+      '.mp4': '🎬', '.webm': '🎬', '.avi': '🎬', '.mov': '🎬',
+      '.py': '🐍',
+      '.go': '🐹',
+      '.rs': '🦀',
+      '.java': '☕',
+      '.rb': '💎',
+      '.php': '🐘',
+      '.sh': '🖥️', '.bash': '🖥️',
+      '.yml': '⚙️', '.yaml': '⚙️',
+      '.xml': '📰',
+      '.sql': '🗃️',
+      '.env': '🔐',
+    };
+    return icons[ext] || '📄';
+  }
+
+  formatSize(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+  }
+
+  stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+// Serve command - share a directory over the internet
+async function serve(directory, options) {
+  const dir = directory || '.';
+  const port = parseInt(options.port) || 8000;
+  const subdomain = options.subdomain;
+
+  // Validate directory exists
+  const resolvedDir = path.resolve(dir);
+  if (!fs.existsSync(resolvedDir)) {
+    console.error(chalk.red(`\n✗ Directory not found: ${resolvedDir}\n`));
+    process.exit(1);
+  }
+
+  if (!fs.statSync(resolvedDir).isDirectory()) {
+    console.error(chalk.red(`\n✗ Not a directory: ${resolvedDir}\n`));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue.bold('\n📂 Starting File Server...\n'));
+
+  const spinner = ora('Checking file transfer limits...').start();
+
+  try {
+    // Check file transfer limit before starting
+    const limitCheck = await api.checkFileTransferLimit();
+    if (!limitCheck.allowed) {
+      spinner.fail(chalk.red('File transfer limit reached'));
+      console.error(chalk.red(`\n✗ ${limitCheck.msg}\n`));
+      console.log(chalk.yellow('💡 Upgrade your plan at https://tunnelapi.in/pricing to get more transfer quota.\n'));
+      process.exit(1);
+    }
+
+    // Show remaining quota
+    if (limitCheck.limitMB) {
+      spinner.succeed(chalk.green(`Transfer quota: ${limitCheck.usedMB} MB / ${limitCheck.limitMB} MB used (${limitCheck.remainingMB} MB remaining)`));
+    } else {
+      spinner.succeed(chalk.green('Transfer quota: Unlimited'));
+    }
+
+    spinner.start('Starting local file server...');
+    
+    // Start local file server
+    const fileServer = new FileServer(resolvedDir, port);
+    await fileServer.start();
+    spinner.succeed(chalk.green(`Local file server running on port ${port}`));
+
+    // Create tunnel
+    spinner.start('Creating tunnel...');
+    
+    const tunnelData = {
+      name: subdomain || `file-server-${Date.now()}`,
+      subdomain: subdomain,
+      localPort: port,
+      protocol: 'http'
+    };
+
+    const response = await api.createTunnel(tunnelData);
+    const tunnel = response.tunnel;
+
+    spinner.succeed(chalk.green('Tunnel created successfully!'));
+
+    // Display info
+    console.log(chalk.gray('\n┌─────────────────────────────────────────────────────────┐'));
+    console.log(chalk.gray('│') + chalk.white.bold('  File Server Information                                ') + chalk.gray('│'));
+    console.log(chalk.gray('├─────────────────────────────────────────────────────────┤'));
+    console.log(chalk.gray('│') + chalk.gray('  Directory:   ') + chalk.white(resolvedDir.substring(0, 40).padEnd(40)) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.gray('  Local Port:  ') + chalk.white(String(port).padEnd(40)) + chalk.gray('│'));
+    console.log(chalk.gray('│') + chalk.gray('  Public URL:  ') + chalk.cyan(tunnel.publicUrl.padEnd(40)) + chalk.gray('│'));
+    console.log(chalk.gray('└─────────────────────────────────────────────────────────┘\n'));
+
+    // Display QR code
+    const qrcode = require('qrcode-terminal');
+    console.log(chalk.yellow.bold('📱 Scan QR Code to access on mobile:\n'));
+    qrcode.generate(tunnel.publicUrl, { small: true }, (qr) => {
+      console.log(qr);
+    });
+
+    console.log(chalk.gray('\nPress Ctrl+C to stop serving files\n'));
+
+    // Connect tunnel client
+    const tunnelCommand = require('./tunnel');
+    // We need to connect the tunnel client to forward requests
+    await connectFileTunnel(tunnel.id || tunnel._id, tunnel.subdomain, port);
+
+    // Handle shutdown
+    process.on('SIGINT', async () => {
+      console.log(chalk.yellow('\n\n🛑 Stopping file server...'));
+      await fileServer.stop();
+      try {
+        await api.deleteTunnel(tunnel.id || tunnel._id);
+      } catch (e) {
+        // Ignore errors on cleanup
+      }
+      console.log(chalk.green('File server stopped.\n'));
+      process.exit(0);
+    });
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to start file server'));
+    console.error(chalk.red(`\n✗ ${error.response?.data?.msg || error.message}\n`));
+    process.exit(1);
+  }
+}
+
+// Connect tunnel client for file serving
+async function connectFileTunnel(tunnelId, subdomain, localPort) {
+  const WebSocket = require('ws');
+  const axios = require('axios');
+  
+  const tunnelServerUrl = config.get('tunnelServerUrl') || 'wss://tunnel.tunnelapi.in';
+  const token = api.getToken();
+  const userId = config.get('userId');
+
+  const ws = new WebSocket(tunnelServerUrl);
+
+  ws.on('open', () => {
+    console.log(chalk.green('✓ Connected to tunnel server'));
+    
+    ws.send(JSON.stringify({
+      type: 'register',
+      tunnelId,
+      subdomain,
+      localPort,
+      protocol: 'http',
+      authToken: token,
+      userId
+    }));
+
+    // Heartbeat
+    setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'heartbeat', tunnelId, subdomain }));
+      }
+    }, 30000);
+  });
+
+  // Track total bytes transferred
+  let totalBytesTransferred = 0;
+  let limitReached = false;
+
+  ws.on('message', async (data) => {
+    const message = JSON.parse(data.toString());
+
+    if (message.type === 'registered') {
+      console.log(chalk.green.bold('\n🎉 File Server is now publicly accessible!\n'));
+      console.log(chalk.white('Share this URL:'));
+      console.log(chalk.cyan.bold(`   ${message.publicUrl}\n`));
+    } else if (message.type === 'request') {
+      const timestamp = new Date().toLocaleTimeString();
+      
+      // Check if limit was reached
+      if (limitReached) {
+        console.log(chalk.red(`[${timestamp}]`), chalk.red('BLOCKED'), chalk.white(message.path), chalk.red('- Transfer limit reached'));
+        ws.send(JSON.stringify({
+          type: 'response',
+          requestId: message.requestId,
+          statusCode: 429,
+          headers: { 'content-type': 'application/json' },
+          body: Buffer.from(JSON.stringify({ 
+            error: 'Monthly file transfer limit reached',
+            message: 'Upgrade your plan at https://tunnelapi.in/pricing for more transfer quota.'
+          })).toString('base64'),
+          encoding: 'base64'
+        }));
+        return;
+      }
+
+      console.log(chalk.gray(`[${timestamp}]`), chalk.blue(message.method), chalk.white(message.path));
+      
+      try {
+        const localUrl = `http://localhost:${localPort}${message.path}`;
+        
+        const response = await axios({
+          method: message.method.toLowerCase(),
+          url: localUrl,
+          headers: { ...message.headers, host: `localhost:${localPort}` },
+          data: message.body,
+          validateStatus: () => true,
+          responseType: 'arraybuffer',
+          maxRedirects: 0,
+          timeout: 30000
+        });
+
+        const cleanHeaders = { ...response.headers };
+        delete cleanHeaders['transfer-encoding'];
+        delete cleanHeaders['connection'];
+
+        const responseData = Buffer.from(response.data);
+        const bodyBase64 = responseData.toString('base64');
+        const bytesTransferred = responseData.length;
+
+        // Track file transfer usage
+        try {
+          await api.trackFileTransfer(userId, bytesTransferred);
+          totalBytesTransferred += bytesTransferred;
+        } catch (trackError) {
+          if (trackError.response?.data?.limitReached) {
+            limitReached = true;
+            console.log(chalk.red.bold('\n⚠️  Monthly file transfer limit reached!'));
+            console.log(chalk.yellow('💡 Upgrade your plan at https://tunnelapi.in/pricing for more transfer quota.\n'));
+          }
+        }
+
+        ws.send(JSON.stringify({
+          type: 'response',
+          requestId: message.requestId,
+          statusCode: response.status,
+          headers: cleanHeaders,
+          body: bodyBase64,
+          encoding: 'base64'
+        }));
+      } catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        ws.send(JSON.stringify({
+          type: 'response',
+          requestId: message.requestId,
+          statusCode: 502,
+          headers: { 'content-type': 'application/json' },
+          body: Buffer.from(JSON.stringify({ error: 'File server error' })).toString('base64'),
+          encoding: 'base64'
+        }));
+      }
+    }
+  });
+
+  ws.on('error', (error) => {
+    console.error(chalk.red(`WebSocket error: ${error.message}`));
+  });
+
+  ws.on('close', () => {
+    console.log(chalk.yellow('Tunnel connection closed'));
+  });
+}
+
+module.exports = {
+  serve
+};

package/commands/tunnel.js

@@ -3,9 +3,22 @@ const ora = require('ora');
 const WebSocket = require('ws');
 const Table = require('cli-table3');
 const axios = require('axios');
+const net = require('net');
+const qrcode = require('qrcode-terminal');
 const api = require('../utils/api');
 const config = require('../utils/config');
 
+// Track TCP connections for SSH/TCP tunnels
+const tcpConnections = new Map();
+
+// Generate and display QR code for URL
+function displayQRCode(url, small = true) {
+  console.log(chalk.yellow.bold('\n📱 Scan QR Code to access on mobile:\n'));
+  qrcode.generate(url, { small }, (qr) => {
+    console.log(qr);
+  });
+}
+
 // Start tunnel
 async function start(port, options) {
   const jsonOutput = options.json || false;
@@ -77,7 +90,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 +113,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 +121,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 +131,7 @@ async function connectTunnelClient(tunnelId, subdomain, localPort, silent = fals
       tunnelId,
       subdomain,
       localPort,
+      protocol,
       authToken: token,
       userId
     }));
@@ -137,8 +152,36 @@ 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`));
+          }
+        } else {
+          // Display QR code for HTTP/HTTPS tunnels (not for TCP/SSH)
+          displayQRCode(message.publicUrl);
+        }
+        
         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 +198,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 +565,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.6.0",
   "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/",
@@ -39,13 +62,17 @@
     "conf": "^10.2.0",
     "dotenv": "^16.3.1",
     "inquirer": "^8.2.5",
+    "mime-types": "^3.0.2",
     "open": "^8.4.0",
     "ora": "^5.4.1",
+    "qrcode-terminal": "^0.12.0",
     "update-notifier": "^6.0.2",
     "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

@@ -109,6 +109,17 @@ class APIClient {
     return response.data;
   }
 
+  // File Transfer
+  async checkFileTransferLimit() {
+    const response = await this.client.get('/tunnels/file-transfer/check');
+    return response.data;
+  }
+
+  async trackFileTransfer(userId, bytes) {
+    const response = await this.client.post('/tunnels/file-transfer/track', { userId, bytes });
+    return response.data;
+  }
+
   // Webhooks
   async createWebhook(data) {
     const response = await this.client.post('/webhooks', data);

package/utils/e2eEncryption.js

@@ -0,0 +1,162 @@
+const crypto = require('crypto');
+
+class E2EEncryptionClient {
+  constructor() {
+    this.algorithm = 'aes-256-gcm';
+    this.keyLength = 32;
+    this.ivLength = 16;
+    this.authTagLength = 16;
+    this.ecdh = null;
+    this.publicKey = null;
+    this.privateKey = null;
+    this.sharedSecret = null;
+    this.serverPublicKey = null;
+  }
+
+  // Initialize client-side encryption
+  initialize() {
+    this.ecdh = crypto.createECDH('secp256k1');
+    this.ecdh.generateKeys();
+    this.publicKey = this.ecdh.getPublicKey('base64');
+    this.privateKey = this.ecdh.getPrivateKey('base64');
+    return this.publicKey;
+  }
+
+  // Set server public key and compute shared secret
+  setServerPublicKey(serverPublicKey) {
+    this.serverPublicKey = serverPublicKey;
+    const publicKeyBuffer = Buffer.from(serverPublicKey, 'base64');
+    const sharedSecret = this.ecdh.computeSecret(publicKeyBuffer);
+    this.sharedSecret = crypto.createHash('sha256').update(sharedSecret).digest();
+    return true;
+  }
+
+  // Check if E2E is ready
+  isReady() {
+    return this.sharedSecret !== null;
+  }
+
+  // Get client public key
+  getPublicKey() {
+    return this.publicKey;
+  }
+
+  // Encrypt data
+  encrypt(plaintext) {
+    if (!this.sharedSecret) {
+      throw new Error('E2E encryption not initialized');
+    }
+
+    const iv = crypto.randomBytes(this.ivLength);
+    const cipher = crypto.createCipheriv(this.algorithm, this.sharedSecret, iv, {
+      authTagLength: this.authTagLength
+    });
+
+    let encrypted = cipher.update(plaintext, 'utf8', 'base64');
+    encrypted += cipher.final('base64');
+    const authTag = cipher.getAuthTag();
+
+    return {
+      encrypted,
+      iv: iv.toString('base64'),
+      authTag: authTag.toString('base64')
+    };
+  }
+
+  // Decrypt data
+  decrypt(encryptedData) {
+    if (!this.sharedSecret) {
+      throw new Error('E2E encryption not initialized');
+    }
+
+    const { encrypted, iv, authTag } = encryptedData;
+    const ivBuffer = Buffer.from(iv, 'base64');
+    const authTagBuffer = Buffer.from(authTag, 'base64');
+
+    const decipher = crypto.createDecipheriv(this.algorithm, this.sharedSecret, ivBuffer, {
+      authTagLength: this.authTagLength
+    });
+    decipher.setAuthTag(authTagBuffer);
+
+    let decrypted = decipher.update(encrypted, 'base64', 'utf8');
+    decrypted += decipher.final('utf8');
+
+    return decrypted;
+  }
+
+  // Encrypt binary data
+  encryptBinary(buffer) {
+    if (!this.sharedSecret) {
+      throw new Error('E2E encryption not initialized');
+    }
+
+    const iv = crypto.randomBytes(this.ivLength);
+    const cipher = crypto.createCipheriv(this.algorithm, this.sharedSecret, iv, {
+      authTagLength: this.authTagLength
+    });
+
+    const encrypted = Buffer.concat([cipher.update(buffer), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+
+    return {
+      encrypted: encrypted.toString('base64'),
+      iv: iv.toString('base64'),
+      authTag: authTag.toString('base64')
+    };
+  }
+
+  // Decrypt binary data
+  decryptBinary(encryptedData) {
+    if (!this.sharedSecret) {
+      throw new Error('E2E encryption not initialized');
+    }
+
+    const { encrypted, iv, authTag } = encryptedData;
+    const encryptedBuffer = Buffer.from(encrypted, 'base64');
+    const ivBuffer = Buffer.from(iv, 'base64');
+    const authTagBuffer = Buffer.from(authTag, 'base64');
+
+    const decipher = crypto.createDecipheriv(this.algorithm, this.sharedSecret, ivBuffer, {
+      authTagLength: this.authTagLength
+    });
+    decipher.setAuthTag(authTagBuffer);
+
+    return Buffer.concat([decipher.update(encryptedBuffer), decipher.final()]);
+  }
+
+  // Encrypt a message object
+  encryptMessage(message) {
+    if (!this.isReady()) {
+      return message;
+    }
+
+    const plaintext = JSON.stringify(message);
+    const encrypted = this.encrypt(plaintext);
+
+    return {
+      type: 'e2e-encrypted',
+      payload: encrypted
+    };
+  }
+
+  // Decrypt a message object
+  decryptMessage(encryptedMessage) {
+    if (encryptedMessage.type !== 'e2e-encrypted') {
+      return encryptedMessage;
+    }
+
+    const decrypted = this.decrypt(encryptedMessage.payload);
+    return JSON.parse(decrypted);
+  }
+
+  // Reset encryption state
+  reset() {
+    this.ecdh = null;
+    this.publicKey = null;
+    this.privateKey = null;
+    this.sharedSecret = null;
+    this.serverPublicKey = null;
+  }
+}
+
+module.exports = E2EEncryptionClient;