Fix

Author: Lightning00Blade

src/McpContext.ts

@@ -157,7 +157,7 @@ export class McpContext implements Context {
       }
       void this.#createMcpPage(page);
     } catch (err) {
-      this.logger?.('Error handling targetcreated', err);
+      this.logger()?.('Error handling targetcreated', err);
     }
   };
 
@@ -179,7 +179,7 @@ export class McpContext implements Context {
         this.#mcpPages.delete(foundPage);
       }
     } catch (err) {
-      this.logger?.('Error handling targetdestroyed', err);
+      this.logger()?.('Error handling targetdestroyed', err);
     }
   };
 
@@ -554,7 +554,7 @@ export class McpContext implements Context {
             allPages.push(page);
           }
         } catch (e) {
-          this.logger?.('Failed to get page for extension target', e);
+          this.logger()?.('Failed to get page for extension target', e);
         }
       }),
     );
@@ -600,7 +600,7 @@ export class McpContext implements Context {
       await fs.writeFile(filePath, data);
       return {filename: filePath};
     } catch (err) {
-      this.logger?.(err);
+      this.logger()?.(err);
       throw new Error('Could not save a file', {cause: err});
     }
   }

src/McpPage.ts

@@ -183,7 +183,7 @@ export class McpPage implements ContextPage {
   async #initFocusEmulationNoThrow(): Promise<void> {
     // We emulate a focused page for all pages to support multi-agent workflows.
     void this.pptrPage.emulateFocusedPage(true).catch(error => {
-      logger?.('Error turning on focused page emulation', error);
+      logger()?.('Error turning on focused page emulation', error);
     });
   }
 
@@ -195,7 +195,7 @@ export class McpPage implements ContextPage {
       const session = await this.pptrPage.createCDPSession();
       this.#devtoolsUniverse = await createTargetUniverse(session);
     } catch (e) {
-      logger?.('Failed to initialize DevTools universe', e);
+      logger()?.('Failed to initialize DevTools universe', e);
     }
   }
 
@@ -327,15 +327,15 @@ export class McpPage implements ContextPage {
 
   resolveCdpRequestId(cdpRequestId: string): number | undefined {
     if (!cdpRequestId) {
-      logger?.('no network request');
+      logger()?.('no network request');
       return;
     }
     const request = this.networkCollector.find(request => {
       // @ts-expect-error id is internal.
       return request.id === cdpRequestId;
     });
     if (!request) {
-      logger?.('no network request for ' + cdpRequestId);
+      logger()?.('no network request for ' + cdpRequestId);
       return;
     }
     return this.networkCollector.getIdForResource(request);
@@ -566,23 +566,23 @@ export class McpPage implements ContextPage {
       for (const handle of oldHandles) {
         await handle
           .dispose()
-          .catch(e => logger?.('Failed to dispose old handle', e));
+          .catch(e => logger()?.('Failed to dispose old handle', e));
       }
     }
 
     const cdpElementIds = await Promise.all(
       elementHandles.map(async (elementHandle, index) => {
         const backendNodeId = await elementHandle.backendNodeId();
         if (!backendNodeId) {
-          logger?.(
+          logger()?.(
             `No backendNodeId for stashed DOM element with index ${index}`,
           );
           return `stashed-${index}`;
         }
         const cdpElementId =
           this.textSnapshot?.resolveCdpElementId(backendNodeId);
         if (!cdpElementId) {
-          logger?.(
+          logger()?.(
             `Could not get cdpElementId for backend node ${backendNodeId}`,
           );
           return `stashed-${index}`;
@@ -655,10 +655,10 @@ export class McpPage implements ContextPage {
 
   async getDevToolsData(): Promise<DevToolsData> {
     try {
-      logger?.('Getting DevTools UI data');
+      logger()?.('Getting DevTools UI data');
       const devtoolsPage = await this.getDevToolsPage();
       if (!devtoolsPage) {
-        logger?.('No DevTools page detected');
+        logger()?.('No DevTools page detected');
         return {};
       }
       const {cdpRequestId, cdpBackendNodeId} = await devtoolsPage.evaluate(
@@ -681,7 +681,7 @@ export class McpPage implements ContextPage {
       );
       return {cdpBackendNodeId, cdpRequestId};
     } catch (err) {
-      logger?.('error getting devtools data', err);
+      logger()?.('error getting devtools data', err);
     }
     return {};
   }

src/PageCollector.ts

@@ -259,7 +259,7 @@ class PageEventSubscriber {
         inspectorIssue,
       )[0];
       if (!issue) {
-        logger?.('No issue mapping for for the issue: ', inspectorIssue.code);
+        logger()?.('No issue mapping for for the issue: ', inspectorIssue.code);
         return;
       }
 
@@ -277,7 +277,7 @@ class PageEventSubscriber {
         },
       );
     } catch (error) {
-      logger?.('Error creating a new issue', error);
+      logger()?.('Error creating a new issue', error);
     }
   };
 }

src/TextSnapshot.ts

@@ -150,7 +150,7 @@ export class TextSnapshot {
 
   resolveCdpElementId(cdpBackendNodeId: number): string | undefined {
     if (!cdpBackendNodeId) {
-      logger?.('no cdpBackendNodeId');
+      logger()?.('no cdpBackendNodeId');
       return;
     }
     // TODO: index by backendNodeId instead.
@@ -281,7 +281,7 @@ export class TextSnapshot {
           collect(node);
         }
       } catch (e) {
-        logger?.(
+        logger()?.(
           `Failed to collect descendants for backend node ${backendNodeId}`,
           e,
         );

src/ToolHandler.ts

@@ -209,11 +209,11 @@ export class ToolHandler {
     const startTime = Date.now();
     let success = false;
     try {
-      logger?.(
+      logger()?.(
         `${this.tool.name} request: ${JSON.stringify(params, null, '  ')}`,
       );
       const context = await this.getContext();
-      logger?.(`${this.tool.name} context: resolved`);
+      logger()?.(`${this.tool.name} context: resolved`);
       const response = this.serverArgs.slim
         ? new SlimMcpResponse(this.serverArgs)
         : new McpResponse(this.serverArgs);
@@ -289,7 +289,7 @@ export class ToolHandler {
       }
       return result;
     } catch (err) {
-      logger?.(`${this.tool.name} error:`, err, err?.stack);
+      logger()?.(`${this.tool.name} error:`, err, err?.stack);
       let errorText = err && 'message' in err ? err.message : String(err);
       if ('cause' in err && err.cause) {
         errorText += `\nCause: ${err.cause.message}`;

src/WaitForHelper.ts

@@ -180,7 +180,7 @@ export class WaitForHelper {
         }
         return;
       })
-      .catch(error => logger?.(error));
+      .catch(error => logger()?.(error));
 
     try {
       await action();
@@ -201,7 +201,7 @@ export class WaitForHelper {
       // the correct context
       await this.waitForStableDom();
     } catch (error) {
-      logger?.(error);
+      logger()?.(error);
     } finally {
       this.#abortController.abort();
     }

src/bin/chrome-devtools-mcp-main.ts

@@ -29,7 +29,7 @@ const logFile = args.logFile ? saveLogsToFile(args.logFile) : undefined;
 
 if (process.env['CHROME_DEVTOOLS_MCP_CRASH_ON_UNCAUGHT'] !== 'true') {
   process.on('unhandledRejection', (reason, promise) => {
-    logger?.('Unhandled promise rejection', promise, reason);
+    logger()?.('Unhandled promise rejection', promise, reason);
   });
 }
 
@@ -43,13 +43,13 @@ async function shutdown(reason: string): Promise<void> {
     return;
   }
   shuttingDown = true;
-  logger?.(`Shutting down (${reason})`);
+  logger()?.(`Shutting down (${reason})`);
   // Backstop in case browser teardown hangs (e.g. unresponsive Chrome,
   // slow beforeunload handlers, many tabs). Exits 0 because we still
   // honored the shutdown request; the log line preserves observability.
   // Unref'd so it doesn't keep the loop alive on the clean path.
   setTimeout(() => {
-    logger?.('Shutdown timeout exceeded, forcing exit');
+    logger()?.('Shutdown timeout exceeded, forcing exit');
     process.exit(0);
   }, 10000).unref();
   await closeBrowser();
@@ -71,13 +71,13 @@ process.on('SIGHUP', () => {
   void shutdown('SIGHUP');
 });
 
-logger?.(`Starting Chrome DevTools MCP Server v${VERSION}`);
+logger()?.(`Starting Chrome DevTools MCP Server v${VERSION}`);
 const {server} = await createMcpServer(args, {
   logFile,
 });
 const transport = new StdioServerTransport();
 await server.connect(transport);
-logger?.('Chrome DevTools MCP Server connected');
+logger()?.('Chrome DevTools MCP Server connected');
 logDisclaimers(args);
 void ClearcutLogger.get()?.logDailyActiveIfNeeded();
 void ClearcutLogger.get()?.logServerStart(computeFlagUsage(args, cliOptions));

src/browser.ts

@@ -123,7 +123,7 @@ export async function ensureBrowserConnected(options: {
     );
   }
 
-  logger?.('Connecting Puppeteer to ', JSON.stringify(connectOptions));
+  logger()?.('Connecting Puppeteer to ', JSON.stringify(connectOptions));
   try {
     // Assign mode before browser so a concurrent closeBrowser() never sees
     // `browser` set with `browserMode` still undefined (would fall through
@@ -139,7 +139,7 @@ export async function ensureBrowserConnected(options: {
       },
     );
   }
-  logger?.('Connected Puppeteer');
+  logger()?.('Connected Puppeteer');
   return browser;
 }
 
@@ -304,12 +304,12 @@ export async function closeBrowser(): Promise<void> {
   }
   if (mode === 'launched') {
     await b.close().catch(err => {
-      logger?.('Failed to close browser', err);
+      logger()?.('Failed to close browser', err);
     });
     return;
   }
   await b.disconnect().catch(err => {
-    logger?.('Failed to disconnect from browser', err);
+    logger()?.('Failed to disconnect from browser', err);
   });
 }
 

src/daemon/client.ts

@@ -108,7 +108,7 @@ async function waitForDaemonReady(sessionId: string) {
 
 export async function startDaemon(mcpArgs: string[] = [], sessionId: string) {
   if (isDaemonRunning(sessionId)) {
-    logger?.('Daemon is already running');
+    logger()?.('Daemon is already running');
     await waitForDaemonReady(sessionId);
     return;
   }
@@ -119,7 +119,7 @@ export async function startDaemon(mcpArgs: string[] = [], sessionId: string) {
     fs.unlinkSync(pidFilePath);
   }
 
-  logger?.('Starting daemon...', ...mcpArgs);
+  logger()?.('Starting daemon...', ...mcpArgs);
   const child = spawn(process.execPath, [DAEMON_SCRIPT_PATH, ...mcpArgs], {
     detached: true,
     stdio: 'ignore',
@@ -163,27 +163,27 @@ export async function sendCommand(
     const transport = new PipeTransport(socket, socket);
     transport.onmessage = async (message: string) => {
       clearTimeout(timer);
-      logger?.('onmessage', message);
+      logger()?.('onmessage', message);
       resolve(JSON.parse(message));
     };
     socket.on('error', error => {
       clearTimeout(timer);
-      logger?.('Socket error:', error);
+      logger()?.('Socket error:', error);
       reject(error);
     });
     socket.on('close', () => {
       clearTimeout(timer);
-      logger?.('Socket closed:');
+      logger()?.('Socket closed:');
       reject(new Error('Socket closed'));
     });
-    logger?.('Sending message', command);
+    logger()?.('Sending message', command);
     transport.send(JSON.stringify(command));
   });
 }
 
 export async function stopDaemon(sessionId: string) {
   if (!isDaemonRunning(sessionId)) {
-    logger?.('Daemon is not running');
+    logger()?.('Daemon is not running');
     return;
   }