client-proxy.js

/**
 * Client-Side Proxy - Runs on the weak 2G device with Firefox
 * 
 * This proxy runs on localhost and Firefox connects to it.
 * It intercepts requests, compresses them, sends to backend server over 2G,
 * receives compressed responses, decompresses them, and sends to Firefox.
 * 
 * Firefox Proxy Settings:
 *   HTTP Proxy: localhost:8080
 *   HTTPS Proxy: localhost:8080
 */

const http = require('http');
const net = require('net');
const path = require('path');
const fs = require('fs');

// Load config from .env (manual parser - no dotenv dependency)
const loadEnv = () => {
  try {
    const envFilePath = path.join(__dirname, '.env');
    if (fs.existsSync(envFilePath)) {
      const envContent = fs.readFileSync(envFilePath, 'utf8');
      const env = {};
      envContent.split('\n').forEach(line => {
        const trimmed = line.trim();
        if (trimmed && !trimmed.startsWith('#')) {
          const [key, ...val] = trimmed.split('=');
          if (key) env[key.trim()] = val.join('=').trim();
        }
      });
      return env;
    }
  } catch (err) {
    console.error('Failed to load .env:', err.message);
  }
  return {};
};

const envConfig = loadEnv();
const CLIENT_PORT = process.env.CLIENT_PORT || envConfig.CLIENT_PORT || 8080;
const CLIENT_HOST = process.env.CLIENT_HOST || envConfig.CLIENT_HOST || '127.0.0.1';
const BACKEND_SERVER = process.env.BACKEND_SERVER || envConfig.BACKEND_SERVER || 'localhost:9000';
const LOG_VERBOSE = (process.env.LOG_VERBOSE || envConfig.LOG_VERBOSE) === 'true';
const LOG_TRAFFIC = (process.env.LOG_TRAFFIC || envConfig.LOG_TRAFFIC) === 'true';
const BACKEND_REQUEST_TIMEOUT_MS = Number(process.env.BACKEND_REQUEST_TIMEOUT_MS || envConfig.BACKEND_REQUEST_TIMEOUT_MS || 60000);
const CONNECT_HANDSHAKE_TIMEOUT_MS = Number(process.env.CONNECT_HANDSHAKE_TIMEOUT_MS || envConfig.CONNECT_HANDSHAKE_TIMEOUT_MS || 60000);
const SHUTDOWN_GRACE_MS = Number(process.env.SHUTDOWN_GRACE_MS || envConfig.SHUTDOWN_GRACE_MS || 5000);

// Parse backend server
const [backendHost, backendPort] = BACKEND_SERVER.split(':');

function log(level, message, data = null) {
  const timestamp = new Date().toISOString();
  const logMsg = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
  
  if (data) {
    console.log(logMsg);
    console.log(JSON.stringify(data, null, 2));
  } else {
    console.log(logMsg);
  }
}

function createClientProxy() {
  const activeSockets = new Set();
  const activeTunnelSockets = new Set();
  let isShuttingDown = false;

  const trackSocket = (socket, collection) => {
    collection.add(socket);
    socket.on('close', () => collection.delete(socket));
  };

  const server = http.createServer(async (clientReq, clientRes) => {
    const startTime = Date.now();
    
    try {
      // Get the full URL that Firefox wants
      const targetUrl = clientReq.url;
      
      log('info', `🔗 CLIENT REQUEST FROM FIREFOX`, {
        method: clientReq.method,
        url: targetUrl,
        headers: LOG_VERBOSE ? clientReq.headers : '(hidden)',
      });

      // Create request to backend server
      const backendReq = http.request(
        {
          hostname: backendHost,
          port: backendPort || 9000,
          path: targetUrl,
          method: clientReq.method,
          headers: {
            ...clientReq.headers,
            'X-Forwarded-For': '127.0.0.1',
          },
        },
        (backendRes) => {
          const duration = Date.now() - startTime;
          
          log('info', `📦 CLIENT GOT RESPONSE FROM BACKEND`, {
            status: backendRes.statusCode,
            duration_ms: duration,
            contentType: backendRes.headers['content-type'],
          });
          
          // Forward response headers to Firefox
          const headers = { ...backendRes.headers };
          
          // Log size info if available
          if (headers['x-original-size'] && headers['x-compressed-size']) {
            const original = parseInt(headers['x-original-size']);
            const compressed = parseInt(headers['x-compressed-size']);
            const ratio = Math.round((1 - compressed / original) * 100);
            log('info', `📊 COMPRESSION RATIO`, {
              original_bytes: original,
              compressed_bytes: compressed,
              savings_percent: `${ratio}%`,
            });
          }

          if (LOG_VERBOSE) {
            log('debug', `Response headers from backend:`, headers);
          }

          // Remove backend-specific headers
          delete headers['x-original-size'];
          delete headers['x-compressed-size'];
          delete headers['x-forwarded-for'];

          clientRes.writeHead(backendRes.statusCode, headers);
          
          let sentBytes = 0;
          backendRes.on('data', (chunk) => {
            sentBytes += chunk.length;
            if (LOG_TRAFFIC) {
              log('debug', `📤 Sent ${chunk.length} bytes to Firefox`);
            }
          });

          backendRes.on('end', () => {
            log('debug', `✓ Response piped to Firefox (${sentBytes} bytes sent)`);
          });

          backendRes.pipe(clientRes);
        }
      );

      backendReq.on('error', (err) => {
        log('error', `❌ BACKEND CONNECTION ERROR`, {
          error: err.message,
          code: err.code,
          hostname: backendHost,
          port: backendPort,
          stack: LOG_VERBOSE ? err.stack : undefined,
        });

        if (clientRes.writableEnded || clientRes.destroyed) return;

        if (!clientRes.headersSent) {
          clientRes.writeHead(502, { 'content-type': 'application/json' });
          clientRes.end(JSON.stringify({
            error: 'Bad Gateway',
            message: err.message,
            backend: `${backendHost}:${backendPort}`,
          }, null, 2));
        } else {
          clientRes.destroy();
        }
      });

      backendReq.on('timeout', () => {
        log('error', `⏱️  BACKEND TIMEOUT`, {
          url: targetUrl,
          timeout_ms: BACKEND_REQUEST_TIMEOUT_MS,
        });

        backendReq.destroy(new Error('Backend request timeout'));

        if (clientRes.writableEnded || clientRes.destroyed) return;

        if (!clientRes.headersSent) {
          clientRes.writeHead(504, { 'content-type': 'text/plain' });
          clientRes.end('Gateway Timeout');
        } else {
          clientRes.destroy();
        }
      });

      backendReq.setTimeout(BACKEND_REQUEST_TIMEOUT_MS);

      // Forward request body
      clientReq.pipe(backendReq);

    } catch (err) {
      log('error', `❌ CLIENT HANDLER EXCEPTION`, {
        error: err.message,
        url: targetUrl,
        stack: LOG_VERBOSE ? err.stack : undefined,
      });
      clientRes.writeHead(500);
      clientRes.end(JSON.stringify({
        error: 'Internal Server Error',
        message: err.message,
      }, null, 2));
    }
  });

  // Handle CONNECT for HTTPS tunneling
  server.on('connect', (clientReq, clientSocket, head) => {
    const startTime = Date.now();
    const parts = clientReq.url.split(':');
    const hostname = parts[0];
    const targetPort = parseInt(parts[1]) || 443;

    log('info', `🔐 CLIENT HTTPS CONNECT`, {
      hostname,
      port: targetPort,
      backend_target: `${backendHost}:${backendPort}`,
    });

    try {
      // Create HTTP CONNECT request to backend (NOT raw socket!)
      const backendReq = http.request({
        hostname: backendHost,
        port: backendPort || 9000,
        method: 'CONNECT',
        path: `${hostname}:${targetPort}`,
        headers: {
          'Host': `${hostname}:${targetPort}`,
        },
      });

      backendReq.on('connect', (backendRes, backendSocket, backendHead) => {
        const duration = Date.now() - startTime;
        trackSocket(clientSocket, activeTunnelSockets);
        trackSocket(backendSocket, activeTunnelSockets);

        log('debug', `✓ Backend responded to CONNECT`, {
          statusCode: backendRes.statusCode,
          duration_ms: duration,
        });

        if (backendRes.statusCode !== 200) {
          log('error', `❌ Backend rejected CONNECT`, {
            statusCode: backendRes.statusCode,
            hostname,
            port: targetPort,
          });

          if (!clientSocket.destroyed) {
            clientSocket.write(`HTTP/1.1 ${backendRes.statusCode} Bad Gateway\r\n\r\n`);
            clientSocket.end();
          }
          backendSocket.destroy();
          return;
        }

        // For CONNECT, send 200 to browser and then switch to raw tunnel mode.
        clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n', () => {
          log('debug', `✓ Sent 200 to Firefox - starting tunnel`);

          clientSocket.setKeepAlive(true, 30000);
          backendSocket.setKeepAlive(true, 30000);
          clientSocket.setTimeout(0);
          backendSocket.setTimeout(0);

          clientSocket.on('error', (err) => {
            log('error', `❌ CLIENT SOCKET ERROR in tunnel`, {
              hostname,
              port: targetPort,
              error: err.message,
            });
            backendSocket.destroy();
          });

          backendSocket.on('error', (err) => {
            log('error', `❌ BACKEND SOCKET ERROR in tunnel`, {
              hostname,
              port: targetPort,
              error: err.message,
            });
            clientSocket.destroy();
          });

          clientSocket.pipe(backendSocket);
          backendSocket.pipe(clientSocket);

          if (head && head.length > 0) {
            backendSocket.write(head);
          }

          if (backendHead && backendHead.length > 0) {
            clientSocket.write(backendHead);
          }
        });
      });

      backendReq.on('error', (err) => {
        const duration = Date.now() - startTime;
        log('error', `❌ BACKEND CONNECT ERROR`, {
          hostname,
          port: targetPort,
          error: err.message,
          code: err.code,
          duration_ms: duration,
          stack: LOG_VERBOSE ? err.stack : undefined,
        });
        clientSocket.write('HTTP/1.1 502 Bad Gateway\r\n\r\n');
        clientSocket.end();
      });

      clientSocket.on('error', (err) => {
        log('error', `❌ CLIENT CONNECT ERROR`, {
          hostname,
          port: targetPort,
          error: err.message,
          stack: LOG_VERBOSE ? err.stack : undefined,
        });
        backendReq.destroy();
      });

      backendReq.on('timeout', () => {
        log('error', `⏱️  CONNECT TIMEOUT`, {
          hostname,
          port: targetPort,
          timeout_ms: CONNECT_HANDSHAKE_TIMEOUT_MS,
        });
        backendReq.destroy(new Error('CONNECT timeout'));
        if (!clientSocket.destroyed) {
          clientSocket.write('HTTP/1.1 504 Gateway Timeout\r\n\r\n');
          clientSocket.end();
        }
      });

      backendReq.setTimeout(CONNECT_HANDSHAKE_TIMEOUT_MS);

      // Send the CONNECT request (this is what triggers backend's server.on('connect'))
      backendReq.end();

    } catch (err) {
      log('error', `❌ HTTPS CONNECT EXCEPTION`, {
        hostname,
        port: targetPort,
        error: err.message,
        stack: LOG_VERBOSE ? err.stack : undefined,
      });
      clientSocket.write('HTTP/1.1 500 Internal Server Error\r\n\r\n');
      clientSocket.end();
    }
  });

  server.listen(CLIENT_PORT, CLIENT_HOST, () => {
    log('info', `🔗 CLIENT PROXY STARTED`, {
      host: CLIENT_HOST,
      port: CLIENT_PORT,
      verbose_logging: LOG_VERBOSE,
      traffic_logging: LOG_TRAFFIC,
      backend_request_timeout_ms: BACKEND_REQUEST_TIMEOUT_MS,
      connect_handshake_timeout_ms: CONNECT_HANDSHAKE_TIMEOUT_MS,
      shutdown_grace_ms: SHUTDOWN_GRACE_MS,
    });
    
    log('info', `📱 Firefox Proxy Configuration`, {
      http_proxy: `${CLIENT_HOST}:${CLIENT_PORT}`,
      https_proxy: `${CLIENT_HOST}:${CLIENT_PORT}`,
      backend_server: BACKEND_SERVER,
    });
  });

  server.on('connection', (socket) => {
    trackSocket(socket, activeSockets);
    if (isShuttingDown) {
      socket.destroy();
    }
  });

  server.on('error', (err) => {
    log('error', `❌ SERVER ERROR`, {
      error: err.message,
      code: err.code,
      stack: LOG_VERBOSE ? err.stack : undefined,
    });
  });

  const shutdown = (signal) => {
    if (isShuttingDown) {
      log('info', `⏹️  Shutdown already in progress`, { signal });
      return;
    }

    isShuttingDown = true;
    log('info', `⏹️  Shutting down client proxy...`, { signal });

    server.close(() => {
      log('info', `✓ Client proxy closed`);
      process.exit(0);
    });

    for (const socket of activeTunnelSockets) {
      socket.end();
    }
    for (const socket of activeSockets) {
      socket.end();
    }

    const forceCloseTimer = setTimeout(() => {
      log('warn', `⚠️  Force closing remaining sockets`, {
        active_connections: activeSockets.size,
        active_tunnels: activeTunnelSockets.size,
      });

      for (const socket of activeTunnelSockets) {
        socket.destroy();
      }
      for (const socket of activeSockets) {
        socket.destroy();
      }

      process.exit(0);
    }, SHUTDOWN_GRACE_MS);
    forceCloseTimer.unref();
  };

  process.once('SIGINT', () => shutdown('SIGINT'));
  process.once('SIGTERM', () => shutdown('SIGTERM'));

  process.on('uncaughtException', (err) => {
    log('error', `❌ UNCAUGHT EXCEPTION`, {
      error: err.message,
      stack: err.stack,
    });
    process.exit(1);
  });

  return server;
}

if (require.main === module) {
  createClientProxy();
}

module.exports = { createClientProxy };