feat: support filePath for network request and response bodies

OrKoN · OrKoN · commit c8f515714098 · 2026-01-19T12:28:17.000+01:00
diff --git a/docs/tool-reference.md b/docs/tool-reference.md
@@ -258,6 +258,8 @@
 **Parameters:**
 
 - **reqid** (number) _(optional)_: The reqid of the network request. If omitted returns the currently selected request in the DevTools Network panel.
+- **requestFilePath** (string) _(optional)_: The absolute path to save the request body to. If omitted, the body is returned inline.
+- **responseFilePath** (string) _(optional)_: The absolute path to save the response body to. If omitted, the body is returned inline.
 
 ---
 
diff --git a/src/McpResponse.ts b/src/McpResponse.ts
@@ -34,6 +34,10 @@ export class McpResponse implements Response {
   #includePages = false;
   #snapshotParams?: SnapshotParams;
   #attachedNetworkRequestId?: number;
+  #attachedNetworkRequestOptions?: {
+    requestFilePath?: string;
+    responseFilePath?: string;
+  };
   #attachedConsoleMessageId?: number;
   #textResponseLines: string[] = [];
   #images: ImageContentData[] = [];
@@ -125,8 +129,12 @@ export class McpResponse implements Response {
     };
   }
 
-  attachNetworkRequest(reqid: number): void {
+  attachNetworkRequest(
+    reqid: number,
+    options?: {requestFilePath?: string; responseFilePath?: string},
+  ): void {
     this.#attachedNetworkRequestId = reqid;
+    this.#attachedNetworkRequestOptions = options;
   }
 
   attachConsoleMessage(msgid: number): void {
@@ -218,6 +226,8 @@ export class McpResponse implements Response {
         requestId: this.#attachedNetworkRequestId,
         requestIdResolver: req => context.getNetworkRequestStableId(req),
         fetchData: true,
+        requestFilePath: this.#attachedNetworkRequestOptions?.requestFilePath,
+        responseFilePath: this.#attachedNetworkRequestOptions?.responseFilePath,
       });
       detailedNetworkRequest = formatter;
     }
diff --git a/src/formatters/NetworkFormatter.ts b/src/formatters/NetworkFormatter.ts
@@ -5,6 +5,7 @@
  * */
 
 import {isUtf8} from 'node:buffer';
+import {writeFile} from 'node:fs/promises';
 
 import type {HTTPRequest, HTTPResponse} from '../third_party/index.js';
 
@@ -15,6 +16,8 @@ export interface NetworkFormatterOptions {
   selectedInDevToolsUI?: boolean;
   requestIdResolver?: (request: HTTPRequest) => number | string;
   fetchData?: boolean;
+  requestFilePath?: string;
+  responseFilePath?: string;
 }
 
 export class NetworkFormatter {
@@ -47,15 +50,28 @@ export class NetworkFormatter {
     if (this.#request.hasPostData()) {
       const data = this.#request.postData();
       if (data) {
-        this.#requestBody = getSizeLimitedString(data, BODY_CONTEXT_SIZE_LIMIT);
+        if (this.#options.requestFilePath) {
+          await writeFile(this.#options.requestFilePath, data);
+          this.#requestBody = this.#options.requestFilePath;
+        } else {
+          this.#requestBody = getSizeLimitedString(
+            data,
+            BODY_CONTEXT_SIZE_LIMIT,
+          );
+        }
       } else {
         try {
           const fetchData = await this.#request.fetchPostData();
           if (fetchData) {
-            this.#requestBody = getSizeLimitedString(
-              fetchData,
-              BODY_CONTEXT_SIZE_LIMIT,
-            );
+            if (this.#options.requestFilePath) {
+              await writeFile(this.#options.requestFilePath, fetchData);
+              this.#requestBody = this.#options.requestFilePath;
+            } else {
+              this.#requestBody = getSizeLimitedString(
+                fetchData,
+                BODY_CONTEXT_SIZE_LIMIT,
+              );
+            }
           }
         } catch {
           this.#requestBody = '<not available anymore>';
@@ -66,10 +82,17 @@ export class NetworkFormatter {
     // Load Response Body
     const response = this.#request.response();
     if (response) {
-      this.#responseBody = await this.#getFormattedResponseBody(
-        response,
-        BODY_CONTEXT_SIZE_LIMIT,
-      );
+      if (this.#options.responseFilePath) {
+        this.#responseBody = await this.#saveResponseBodyToFile(
+          response,
+          this.#options.responseFilePath,
+        );
+      } else {
+        this.#responseBody = await this.#getFormattedResponseBody(
+          response,
+          BODY_CONTEXT_SIZE_LIMIT,
+        );
+      }
     }
   }
 
@@ -215,6 +238,19 @@ export class NetworkFormatter {
       return '<not available anymore>';
     }
   }
+
+  async #saveResponseBodyToFile(
+    httpResponse: HTTPResponse,
+    filePath: string,
+  ): Promise<string> {
+    try {
+      const responseBuffer = await httpResponse.buffer();
+      await writeFile(filePath, responseBuffer);
+      return filePath;
+    } catch {
+      return '<not available anymore>';
+    }
+  }
 }
 
 function getSizeLimitedString(text: string, sizeLimit: number) {
diff --git a/src/tools/ToolDefinition.ts b/src/tools/ToolDefinition.ts
@@ -73,7 +73,10 @@ export interface Response {
   ): void;
   includeSnapshot(params?: SnapshotParams): void;
   attachImage(value: ImageContentData): void;
-  attachNetworkRequest(reqid: number): void;
+  attachNetworkRequest(
+    reqid: number,
+    options?: {requestFilePath?: string; responseFilePath?: string},
+  ): void;
   attachConsoleMessage(msgid: number): void;
   // Allows re-using DevTools data queried by some tools.
   attachDevToolsData(data: DevToolsData): void;
diff --git a/src/tools/network.ts b/src/tools/network.ts
@@ -91,7 +91,7 @@ export const getNetworkRequest = defineTool({
   description: `Gets a network request by an optional reqid, if omitted returns the currently selected request in the DevTools Network panel.`,
   annotations: {
     category: ToolCategory.NETWORK,
-    readOnlyHint: true,
+    readOnlyHint: false,
   },
   schema: {
     reqid: zod
@@ -100,18 +100,36 @@ export const getNetworkRequest = defineTool({
       .describe(
         'The reqid of the network request. If omitted returns the currently selected request in the DevTools Network panel.',
       ),
+    requestFilePath: zod
+      .string()
+      .optional()
+      .describe(
+        'The absolute path to save the request body to. If omitted, the body is returned inline.',
+      ),
+    responseFilePath: zod
+      .string()
+      .optional()
+      .describe(
+        'The absolute path to save the response body to. If omitted, the body is returned inline.',
+      ),
   },
   handler: async (request, response, context) => {
     if (request.params.reqid) {
-      response.attachNetworkRequest(request.params.reqid);
+      response.attachNetworkRequest(request.params.reqid, {
+        requestFilePath: request.params.requestFilePath,
+        responseFilePath: request.params.responseFilePath,
+      });
     } else {
       const data = await context.getDevToolsData();
       response.attachDevToolsData(data);
       const reqid = data?.cdpRequestId
         ? context.resolveCdpRequestId(data.cdpRequestId)
         : undefined;
       if (reqid) {
-        response.attachNetworkRequest(reqid);
+        response.attachNetworkRequest(reqid, {
+          requestFilePath: request.params.requestFilePath,
+          responseFilePath: request.params.responseFilePath,
+        });
       } else {
         response.appendResponseLine(
           `Nothing is currently selected in the DevTools Network panel.`,
diff --git a/tests/McpContext.test.js.snapshot b/tests/McpContext.test.js.snapshot
@@ -12,6 +12,15 @@ exports[`McpContext > should include detailed network request in structured cont
 }
 `;
 
+exports[`McpContext > should include file paths in structured content when saving to file 1`] = `
+{
+  "networkRequest": {
+    "requestBody": "/tmp/req.txt",
+    "responseBody": "/tmp/res.txt"
+  }
+}
+`;
+
 exports[`McpContext > should include network requests in structured content 1`] = `
 {
   "networkRequests": [
diff --git a/tests/McpContext.test.ts b/tests/McpContext.test.ts
@@ -9,6 +9,8 @@ import {describe, it} from 'node:test';
 
 import sinon from 'sinon';
 
+import {NetworkFormatter} from '../src/formatters/NetworkFormatter.js';
+import type {HTTPResponse} from '../src/third_party/index.js';
 import type {TraceResult} from '../src/trace-processing/parse.js';
 
 import {getMockRequest, html, withMcpContext} from './utils.js';
@@ -134,4 +136,53 @@ describe('McpContext', () => {
       t.assert.snapshot?.(JSON.stringify(result.structuredContent, null, 2));
     });
   });
+
+  it('should include file paths in structured content when saving to file', async t => {
+    await withMcpContext(async (response, context) => {
+      const mockRequest = getMockRequest({
+        url: 'http://example.com/file-save',
+        stableId: 789,
+        hasPostData: true,
+        postData: 'some detailed data',
+        response: {
+          status: () => 200,
+          headers: () => ({'content-type': 'text/plain'}),
+          buffer: async () => Buffer.from('some response data'),
+        } as unknown as HTTPResponse,
+      });
+
+      sinon.stub(context, 'getNetworkRequestById').returns(mockRequest);
+      sinon.stub(context, 'getNetworkRequestStableId').returns(789);
+
+      // We stub NetworkFormatter.from to avoid actual file system writes and verify arguments
+      const fromStub = sinon
+        .stub(NetworkFormatter, 'from')
+        .callsFake(async (_req, opts) => {
+          // Verify we received the file paths
+          assert.strictEqual(opts?.requestFilePath, '/tmp/req.txt');
+          assert.strictEqual(opts?.responseFilePath, '/tmp/res.txt');
+          // Return a dummy formatter that behaves as if it saved files
+          // We need to create a real instance or mock one.
+          // Since constructor is private, we can't easily new it up.
+          // But we can return a mock object.
+          return {
+            toStringDetailed: () => 'Detailed string',
+            toJSONDetailed: () => ({
+              requestBody: '/tmp/req.txt',
+              responseBody: '/tmp/res.txt',
+            }),
+          } as unknown as NetworkFormatter;
+        });
+
+      response.attachNetworkRequest(789, {
+        requestFilePath: '/tmp/req.txt',
+        responseFilePath: '/tmp/res.txt',
+      });
+      const result = await response.handle('test', context);
+
+      t.assert.snapshot?.(JSON.stringify(result.structuredContent, null, 2));
+
+      fromStub.restore();
+    });
+  });
 });
diff --git a/tests/formatters/NetworkFormatter.test.ts b/tests/formatters/NetworkFormatter.test.ts
@@ -8,6 +8,7 @@ import assert from 'node:assert';
 import {describe, it} from 'node:test';
 
 import {NetworkFormatter} from '../../src/formatters/NetworkFormatter.js';
+import type {HTTPRequest} from '../../src/third_party/index.js';
 import {getMockRequest, getMockResponse} from '../utils.js';
 
 describe('NetworkFormatter', () => {
@@ -145,6 +146,83 @@ describe('NetworkFormatter', () => {
       assert.match(result, /some text/);
     });
 
+    it('should save bodies to file when file paths are provided', async () => {
+      const request = {
+        method: () => 'POST',
+        url: () => 'http://example.com',
+        headers: () => ({}),
+        hasPostData: () => true,
+        postData: () => 'request body',
+        response: () => ({
+          status: () => 200,
+          headers: () => ({}),
+          buffer: async () => Buffer.from('response body'),
+        }),
+        failure: () => null,
+        redirectChain: () => [],
+        fetchPostData: async () => undefined,
+      } as unknown as HTTPRequest;
+
+      // Let's create a temporary file path
+      // We are just verifying logic flow here, actual FS write might fail if we don't have permissions or path is weird,
+      // but /tmp should be fine on the system.
+      // However, to be safe and avoid flakiness, we might want to mock writeFile.
+      // But since we can't easily mock it, we try to use real files.
+      const reqPath = '/tmp/test_req_' + Date.now();
+      const resPath = '/tmp/test_res_' + Date.now();
+
+      const formatter = await NetworkFormatter.from(request, {
+        fetchData: true,
+        requestFilePath: reqPath,
+        responseFilePath: resPath,
+      });
+
+      const json = formatter.toJSONDetailed() as {
+        requestBody: string;
+        responseBody: string;
+      };
+      assert.strictEqual(json.requestBody, reqPath);
+      assert.strictEqual(json.responseBody, resPath);
+    });
+
+    it('should not truncate large bodies when saving to file', async () => {
+      const largeBody = 'a'.repeat(10005);
+      const request = {
+        method: () => 'POST',
+        url: () => 'http://example.com',
+        headers: () => ({}),
+        hasPostData: () => true,
+        postData: () => largeBody,
+        response: () => ({
+          status: () => 200,
+          headers: () => ({}),
+          buffer: async () => Buffer.from(largeBody),
+        }),
+        failure: () => null,
+        redirectChain: () => [],
+        fetchPostData: async () => undefined,
+      } as unknown as HTTPRequest;
+
+      const reqPath = '/tmp/test_req_large_' + Date.now();
+      const resPath = '/tmp/test_res_large_' + Date.now();
+
+      await NetworkFormatter.from(request, {
+        fetchData: true,
+        requestFilePath: reqPath,
+        responseFilePath: resPath,
+      });
+
+      // We need to verify the file content.
+      // Since we import fs/promises in the source, we can try to use node:fs/promises here too.
+      // Dynamic import to avoid top-level import issues if any (though we stick to standard imports).
+      const {readFile} = await import('node:fs/promises');
+      const reqContent = await readFile(reqPath, 'utf8');
+      const resContent = await readFile(resPath, 'utf8');
+
+      assert.strictEqual(reqContent, largeBody);
+      assert.strictEqual(resContent, largeBody);
+    });
+
     it('handles response body', async () => {
       const response = getMockResponse();
       response.buffer = () => {
