WebScout MCP

Instructions

Implementation Reference

• src/tools/networkCapture.js:19-192 (handler)

  Core handler function that initializes network capture session, sets up CDP event listeners for HTTP requests, responses, WebSocket frames, applies filters, stores data in session object, and returns capture status.
  export async function startNetworkCapture(sessionId, options = {}) { const session = global.activeSessions?.get(sessionId); if (!session) { throw new Error( `Session ${sessionId} not found. Call initializeSession first.` ); } const { capturePostOnly = false, captureStreaming = false, urlFilters = [], maxCaptures = 100, } = options; // Initialize capture storage const captureData = { sessionId, startTime: Date.now(), requests: [], responses: [], wsFrames: [], streamingResponses: [], options: { capturePostOnly, captureStreaming, urlFilters, maxCaptures }, }; // Store capture data in session session.networkCapture = captureData; // Set up CDP session for network monitoring const client = await session.context.newCDPSession(session.page); await client.send("Network.enable"); await client.send("Fetch.enable", { patterns: [{ requestStage: "Response" }], }); // Store client reference for cleanup captureData.cdpClient = client; // Network request capture client.on("Network.requestWillBeSent", (params) => { try { const { requestId, request, timestamp } = params; // Apply filters if (capturePostOnly && request.method !== "POST") return; if ( urlFilters.length > 0 && !urlFilters.some((pattern) => request.url.includes(pattern)) ) return; const requestData = { requestId, url: request.url, method: request.method, timestamp, headers: request.headers, postData: request.postData || null, }; captureData.requests.push(requestData); // Limit storage if (captureData.requests.length > maxCaptures) { captureData.requests.shift(); } } catch (e) { // Ignore capture errors } }); // Network response capture client.on("Network.responseReceived", async (params) => { try { const { requestId, response } = params; const matchingRequest = captureData.requests.find( (r) => r.requestId === requestId ); if (!matchingRequest) return; // Apply streaming filter if enabled if (captureStreaming) { const isStreaming = NetworkUtilities.isStreamingHeaders(response.headers) || response.mimeType?.includes("stream") || response.headers["transfer-encoding"] === "chunked"; if (!isStreaming) return; } const responseData = { requestId, url: response.url, status: response.status, statusText: response.statusText, headers: response.headers, mimeType: response.mimeType, timestamp: Date.now(), }; // Try to capture response body for small responses if ( response.headers["content-length"] && parseInt(response.headers["content-length"]) < 10000 ) { try { const body = await client.send("Network.getResponseBody", { requestId, }); responseData.body = body.body; responseData.base64Encoded = body.base64Encoded; } catch (e) { // Body capture failed, continue without it } } captureData.responses.push(responseData); // Limit storage if (captureData.responses.length > maxCaptures) { captureData.responses.shift(); } } catch (e) { // Ignore capture errors } }); // WebSocket frame capture client.on("Network.webSocketFrameReceived", (params) => { try { const frameData = { timestamp: Date.now(), type: "received", opcode: params.response.opcode, payload: params.response.payloadData, }; captureData.wsFrames.push(frameData); if (captureData.wsFrames.length > maxCaptures) { captureData.wsFrames.shift(); } } catch (e) { // Ignore capture errors } }); client.on("Network.webSocketFrameSent", (params) => { try { const frameData = { timestamp: Date.now(), type: "sent", opcode: params.response.opcode, payload: params.response.payloadData, }; captureData.wsFrames.push(frameData); if (captureData.wsFrames.length > maxCaptures) { captureData.wsFrames.shift(); } } catch (e) { // Ignore capture errors } }); return { sessionId, captureId: `capture_${Date.now()}`, status: "active", options: captureData.options, message: "Network capture started successfully", }; }
• src/index.js:304-348 (schema)

  MCP tool schema definition including name, description, and inputSchema with parameters for sessionId and optional capture options.
  { name: "start_network_capture", description: "Start capturing network traffic on the current browser session. Monitors all HTTP requests and responses, WebSocket frames, and streaming data. Can filter by POST requests only, streaming responses only, or specific URL patterns. Essential for analyzing API calls, debugging network issues, or monitoring real-time data flows.", inputSchema: { type: "object", properties: { sessionId: { type: "string", description: "Session ID obtained from initialize_session", }, options: { type: "object", description: "Optional capture configuration", properties: { capturePostOnly: { type: "boolean", description: "Only capture POST requests (default: false)", default: false, }, captureStreaming: { type: "boolean", description: "Only capture streaming responses (default: false)", default: false, }, urlFilters: { type: "array", items: { type: "string" }, description: "Array of URL patterns to filter captures (default: [])", default: [], }, maxCaptures: { type: "number", description: "Maximum number of captures to store (default: 100)", default: 100, }, }, }, }, required: ["sessionId"], }, },
• src/index.js:555-565 (registration)

  Tool dispatch registration in the CallToolRequestSchema switch statement that validates parameters and invokes the startNetworkCapture handler.
  case "start_network_capture": { const { sessionId, options = {} } = args; if (!sessionId) { throw new McpError( ErrorCode.InvalidParams, "sessionId parameter is required" ); } result = await startNetworkCapture(sessionId, options); break; }
• src/tools/reverseEngineer.js:22-27 (registration)

  Re-export of network capture tools from networkCapture.js, enabling import in src/index.js.
  export { startNetworkCapture, stopNetworkCapture, getNetworkCaptureStatus, clearNetworkCapture, } from "./networkCapture.js";