interceptor.js

const puppeteer = require("puppeteer");
const fs = require("fs");
const path = require("path");

class RequestInterceptor {
  constructor() {
    this.requests = [];
    this.responses = [];
    this.outputFile = "intercepted_requests.json";
    this.logFile = "intercepted_requests.log";
    this.browser = null;
    this.page = null;
  }

  async init() {
    console.log("🚀 Starting Puppeteer Request Interceptor...");

    // Initialize log file
    this.initLogFile();

    // Launch browser with GUI (non-headless)
    this.browser = await puppeteer.launch({
      headless: false,
      defaultViewport: null,
      args: [
        "--start-maximized",
        "--disable-web-security",
        "--disable-features=VizDisplayCompositor",
      ],
    });

    this.page = await this.browser.newPage();

    // Set up request/response interceptors
    await this.setupInterceptors();

    console.log("✅ Browser launched and interceptors set up!");
    console.log("📝 All HTTP requests will be logged to:", this.outputFile);
    console.log("📄 Real-time logs will be written to:", this.logFile);
    console.log("🌐 Navigate to any website and interact with it...");
    console.log("⏹️  Press Ctrl+C to stop and save the logs");
  }

  initLogFile() {
    const logHeader = `[${new Date().toISOString()}] ===== Puppeteer Request Interceptor Started =====\n`;
    fs.writeFileSync(this.logFile, logHeader);
  }

  writeToLog(message) {
    const timestamp = new Date().toISOString();
    const logEntry = `[${timestamp}] ${message}\n`;
    fs.appendFileSync(this.logFile, logEntry);
  }

  async setupInterceptors() {
    // Intercept requests
    await this.page.setRequestInterception(true);

    this.page.on("request", (request) => {
      const requestData = {
        timestamp: new Date().toISOString(),
        type: "REQUEST",
        method: request.method(),
        url: request.url(),
        headers: request.headers(),
        postData: request.postData(),
        resourceType: request.resourceType(),
      };

      this.requests.push(requestData);

      // Log to console for real-time monitoring
      console.log(`📤 ${request.method()} ${request.url()}`);
      if (request.postData()) {
        console.log(`   📝 POST Data: ${request.postData()}`);
      }

      // Write to log file
      this.writeToLog(`REQUEST ${request.method()} ${request.url()}`);
      if (request.postData()) {
        this.writeToLog(`POST_DATA ${request.postData()}`);
      }

      // Continue with the request
      request.continue();
    });

    // Intercept responses
    this.page.on("response", async (response) => {
      const request = response.request();

      let responseBody = null;
      try {
        // Only capture response body for certain content types
        const contentType = response.headers()["content-type"] || "";
        if (
          contentType.includes("application/json") ||
          contentType.includes("text/") ||
          contentType.includes("application/x-www-form-urlencoded")
        ) {
          responseBody = await response.text();
        }
      } catch (error) {
        responseBody = `Error reading response: ${error.message}`;
      }

      const responseData = {
        timestamp: new Date().toISOString(),
        type: "RESPONSE",
        method: request.method(),
        url: response.url(),
        status: response.status(),
        statusText: response.statusText(),
        headers: response.headers(),
        body: responseBody,
        fromCache: response.fromCache(),
      };

      this.responses.push(responseData);

      // Log to console for real-time monitoring
      console.log(
        `📥 ${response.status()} ${request.method()} ${response.url()}`,
      );

      // Write to log file
      this.writeToLog(
        `RESPONSE ${response.status()} ${request.method()} ${response.url()}`,
      );
      if (responseBody && responseBody.length < 500) {
        this.writeToLog(`RESPONSE_BODY ${responseBody}`);
      }
    });
  }

  async navigateTo(url) {
    if (!url.startsWith("http")) {
      url = "https://" + url;
    }

    console.log(`🔗 Navigating to: ${url}`);
    await this.page.goto(url, { waitUntil: "networkidle2" });
  }

  async saveInterceptedData() {
    const allData = {
      session: {
        startTime: new Date().toISOString(),
        totalRequests: this.requests.length,
        totalResponses: this.responses.length,
      },
      requests: this.requests,
      responses: this.responses,
      combined: this.combineRequestsAndResponses(),
    };

    // Save to JSON file
    fs.writeFileSync(this.outputFile, JSON.stringify(allData, null, 2));

    // Also create a simplified curl commands file
    this.generateCurlCommands();

    // Write session end to log file
    this.writeToLog(
      `===== Session Ended - ${this.requests.length} requests, ${this.responses.length} responses =====`,
    );

    console.log(
      `\n💾 Saved ${this.requests.length} requests and ${this.responses.length} responses to ${this.outputFile}`,
    );
    console.log(`📄 Real-time log saved to ${this.logFile}`);
    console.log(`📋 Curl commands saved to curl_commands.sh`);
  }

  combineRequestsAndResponses() {
    const combined = [];

    this.requests.forEach((req) => {
      const matchingResponse = this.responses.find(
        (res) =>
          res.url === req.url &&
          res.method === req.method &&
          new Date(res.timestamp) >= new Date(req.timestamp),
      );

      combined.push({
        request: req,
        response: matchingResponse || null,
      });
    });

    return combined;
  }

  generateCurlCommands() {
    const curlCommands = [];

    this.requests.forEach((req) => {
      if (
        req.resourceType === "document" ||
        req.resourceType === "xhr" ||
        req.resourceType === "fetch"
      ) {
        let curl = `curl -X ${req.method} '${req.url}'`;

        // Add headers
        Object.entries(req.headers).forEach(([key, value]) => {
          if (!["host", "content-length"].includes(key.toLowerCase())) {
            curl += ` \\\n  -H '${key}: ${value}'`;
          }
        });

        // Add POST data
        if (req.postData) {
          curl += ` \\\n  -d '${req.postData}'`;
        }

        curlCommands.push(curl);
      }
    });

    fs.writeFileSync("curl_commands.sh", curlCommands.join("\n\n") + "\n");
  }

  async close() {
    if (this.browser) {
      await this.browser.close();
    }
  }
}

// Main execution
async function main() {
  const interceptor = new RequestInterceptor();

  // Handle graceful shutdown
  process.on("SIGINT", async () => {
    console.log("\n🛑 Stopping interceptor...");
    await interceptor.saveInterceptedData();
    await interceptor.close();
    console.log("👋 Goodbye!");
    process.exit(0);
  });

  try {
    await interceptor.init();

    // Optional: Navigate to a starting URL
    const startUrl = process.argv[2];
    if (startUrl) {
      await interceptor.navigateTo(startUrl);
    } else {
      // Navigate to a blank page to start
      await interceptor.page.goto("about:blank");
      console.log(
        "💡 Tip: You can also run with a URL: node interceptor.js example.com",
      );
    }

    // Keep the script running until user stops it
    console.log(
      "🔄 Script is running... Interact with the browser and press Ctrl+C when done.",
    );

    // Prevent the script from exiting
    await new Promise(() => {});
  } catch (error) {
    console.error("❌ Error:", error);
    await interceptor.close();
    process.exit(1);
  }
}

main();