Merge branch 'main' into screenshot-tool-enhancement

Author: absarasw

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 or relative path to save the request body to. If omitted, the body is returned inline.
+- **responseFilePath** (string) _(optional)_: The absolute or relative path to save the response body to. If omitted, the body is returned inline.
 
 ---
 

scripts/test.mjs

@@ -53,7 +53,7 @@ const nodeArgs = [
   'spec',
   '--test-force-exit',
   '--test',
-  '--test-timeout=30000',
+  '--test-timeout=60000',
   ...flags,
   ...files,
 ];

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,9 @@ export class McpResponse implements Response {
         requestId: this.#attachedNetworkRequestId,
         requestIdResolver: req => context.getNetworkRequestStableId(req),
         fetchData: true,
+        requestFilePath: this.#attachedNetworkRequestOptions?.requestFilePath,
+        responseFilePath: this.#attachedNetworkRequestOptions?.responseFilePath,
+        saveFile: (data, filename) => context.saveFile(data, filename),
       });
       detailedNetworkRequest = formatter;
     }
@@ -361,6 +372,7 @@ export class McpResponse implements Response {
                 context.getNetworkRequestStableId(request) ===
                 this.#networkRequestsOptions?.networkRequestIdInDevToolsUI,
               fetchData: false,
+              saveFile: (data, filename) => context.saveFile(data, filename),
             }),
           ),
         );

src/formatters/NetworkFormatter.ts

@@ -15,25 +15,30 @@ export interface NetworkFormatterOptions {
   selectedInDevToolsUI?: boolean;
   requestIdResolver?: (request: HTTPRequest) => number | string;
   fetchData?: boolean;
+  requestFilePath?: string;
+  responseFilePath?: string;
+  saveFile?: (
+    data: Uint8Array<ArrayBufferLike>,
+    filename: string,
+  ) => Promise<{filename: string}>;
 }
 
 export class NetworkFormatter {
   #request: HTTPRequest;
   #options: NetworkFormatterOptions;
   #requestBody?: string;
   #responseBody?: string;
+  #requestBodyFilePath?: string;
+  #responseBodyFilePath?: string;
 
-  private constructor(
-    request: HTTPRequest,
-    options: NetworkFormatterOptions = {},
-  ) {
+  private constructor(request: HTTPRequest, options: NetworkFormatterOptions) {
     this.#request = request;
     this.#options = options;
   }
 
   static async from(
     request: HTTPRequest,
-    options: NetworkFormatterOptions = {},
+    options: NetworkFormatterOptions,
   ): Promise<NetworkFormatter> {
     const instance = new NetworkFormatter(request, options);
     if (options.fetchData) {
@@ -47,15 +52,40 @@ 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) {
+          if (!this.#options.saveFile) {
+            throw new Error('saveFile is not provided');
+          }
+          await this.#options.saveFile(
+            Buffer.from(data),
+            this.#options.requestFilePath,
+          );
+          this.#requestBodyFilePath = 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) {
+              if (!this.#options.saveFile) {
+                throw new Error('saveFile is not provided');
+              }
+              await this.#options.saveFile(
+                Buffer.from(fetchData),
+                this.#options.requestFilePath,
+              );
+              this.#requestBodyFilePath = this.#options.requestFilePath;
+            } else {
+              this.#requestBody = getSizeLimitedString(
+                fetchData,
+                BODY_CONTEXT_SIZE_LIMIT,
+              );
+            }
           }
         } catch {
           this.#requestBody = '<not available anymore>';
@@ -66,10 +96,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.#responseBodyFilePath = await this.#saveResponseBodyToFile(
+          response,
+          this.#options.responseFilePath,
+        );
+      } else {
+        this.#responseBody = await this.#getFormattedResponseBody(
+          response,
+          BODY_CONTEXT_SIZE_LIMIT,
+        );
+      }
     }
   }
 
@@ -90,6 +127,9 @@ export class NetworkFormatter {
     if (this.#requestBody) {
       response.push(`### Request Body`);
       response.push(this.#requestBody);
+    } else if (this.#requestBodyFilePath) {
+      response.push(`### Request Body`);
+      response.push(`Saved to ${this.#requestBodyFilePath}.`);
     }
 
     const httpResponse = this.#request.response();
@@ -105,6 +145,9 @@ export class NetworkFormatter {
     if (this.#responseBody) {
       response.push(`### Response Body`);
       response.push(this.#responseBody);
+    } else if (this.#responseBodyFilePath) {
+      response.push(`### Response Body`);
+      response.push(`Saved to ${this.#responseBodyFilePath}.`);
     }
 
     const httpFailure = this.#request.failure();
@@ -124,6 +167,7 @@ export class NetworkFormatter {
         // We create a temporary synchronous instance just for toString
         const formatter = new NetworkFormatter(request, {
           requestId: id,
+          saveFile: this.#options.saveFile,
         });
         response.push(`${'  '.repeat(indent)}${formatter.toString()}`);
         indent++;
@@ -150,6 +194,7 @@ export class NetworkFormatter {
         : undefined;
       const formatter = new NetworkFormatter(request, {
         requestId: id,
+        saveFile: this.#options.saveFile,
       });
       return formatter.toJSON();
     });
@@ -158,8 +203,10 @@ export class NetworkFormatter {
       ...this.toJSON(),
       requestHeaders: this.#request.headers(),
       requestBody: this.#requestBody,
+      requestBodyFilePath: this.#requestBodyFilePath,
       responseHeaders: this.#request.response()?.headers(),
       responseBody: this.#responseBody,
+      responseBodyFilePath: this.#responseBodyFilePath,
       failure: this.#request.failure()?.errorText,
       redirectChain: formattedRedirectChain.length
         ? formattedRedirectChain
@@ -215,6 +262,22 @@ export class NetworkFormatter {
       return '<not available anymore>';
     }
   }
+
+  async #saveResponseBodyToFile(
+    httpResponse: HTTPResponse,
+    filePath: string,
+  ): Promise<string> {
+    try {
+      const responseBuffer = await httpResponse.buffer();
+      if (!this.#options.saveFile) {
+        throw new Error('saveFile is not provided');
+      }
+      await this.#options.saveFile(responseBuffer, filePath);
+      return filePath;
+    } catch {
+      return '<not available anymore>';
+    }
+  }
 }
 
 function getSizeLimitedString(text: string, sizeLimit: number) {

src/logger.ts

@@ -31,4 +31,17 @@ export function saveLogsToFile(fileName: string): fs.WriteStream {
   return logFile;
 }
 
+export function flushLogs(
+  logFile: fs.WriteStream,
+  timeoutMs = 2000,
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(reject, timeoutMs);
+    logFile.end(() => {
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+}
+
 export const logger = debug(mcpDebugNamespace);

src/main.ts

@@ -38,7 +38,10 @@ export const args = parseArguments(VERSION);
 const logFile = args.logFile ? saveLogsToFile(args.logFile) : undefined;
 let clearcutLogger: ClearcutLogger | undefined;
 if (args.usageStatistics) {
-  clearcutLogger = new ClearcutLogger();
+  clearcutLogger = new ClearcutLogger({
+    logFile: args.logFile,
+    appVersion: VERSION,
+  });
 }
 
 process.on('unhandledRejection', (reason, promise) => {

src/telemetry/clearcut-logger.ts

@@ -4,42 +4,75 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import process from 'node:process';
+
 import {logger} from '../logger.js';
 
-import {ClearcutSender} from './clearcut-sender.js';
 import type {LocalState, Persistence} from './persistence.js';
 import {FilePersistence} from './persistence.js';
-import type {FlagUsage} from './types.js';
+import {type FlagUsage, WatchdogMessageType, OsType} from './types.js';
+import {WatchdogClient} from './watchdog-client.js';
 
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 
+function detectOsType(): OsType {
+  switch (process.platform) {
+    case 'win32':
+      return OsType.OS_TYPE_WINDOWS;
+    case 'darwin':
+      return OsType.OS_TYPE_MACOS;
+    case 'linux':
+      return OsType.OS_TYPE_LINUX;
+    default:
+      return OsType.OS_TYPE_UNSPECIFIED;
+  }
+}
+
 export class ClearcutLogger {
   #persistence: Persistence;
-  #sender: ClearcutSender;
+  #watchdog: WatchdogClient;
 
-  constructor(options?: {persistence?: Persistence; sender?: ClearcutSender}) {
-    this.#persistence = options?.persistence ?? new FilePersistence();
-    this.#sender = options?.sender ?? new ClearcutSender();
+  constructor(options: {
+    appVersion: string;
+    logFile?: string;
+    persistence?: Persistence;
+    watchdogClient?: WatchdogClient;
+  }) {
+    this.#persistence = options.persistence ?? new FilePersistence();
+    this.#watchdog =
+      options.watchdogClient ??
+      new WatchdogClient({
+        parentPid: process.pid,
+        appVersion: options.appVersion,
+        osType: detectOsType(),
+        logFile: options.logFile,
+      });
   }
 
   async logToolInvocation(args: {
     toolName: string;
     success: boolean;
     latencyMs: number;
   }): Promise<void> {
-    await this.#sender.send({
-      tool_invocation: {
-        tool_name: args.toolName,
-        success: args.success,
-        latency_ms: args.latencyMs,
+    this.#watchdog.send({
+      type: WatchdogMessageType.LOG_EVENT,
+      payload: {
+        tool_invocation: {
+          tool_name: args.toolName,
+          success: args.success,
+          latency_ms: args.latencyMs,
+        },
       },
     });
   }
 
   async logServerStart(flagUsage: FlagUsage): Promise<void> {
-    await this.#sender.send({
-      server_start: {
-        flag_usage: flagUsage,
+    this.#watchdog.send({
+      type: WatchdogMessageType.LOG_EVENT,
+      payload: {
+        server_start: {
+          flag_usage: flagUsage,
+        },
       },
     });
   }
@@ -57,13 +90,15 @@ export class ClearcutLogger {
           daysSince = Math.ceil(diffTime / MS_PER_DAY);
         }
 
-        await this.#sender.send({
-          daily_active: {
-            days_since_last_active: daysSince,
+        this.#watchdog.send({
+          type: WatchdogMessageType.LOG_EVENT,
+          payload: {
+            daily_active: {
+              days_since_last_active: daysSince,
+            },
           },
         });
 
-        // Update persistence
         state.lastActive = new Date().toISOString();
         await this.#persistence.saveState(state);
       }