feat: Enable dynamic tool definition based on CLI arguments

Author: nroscino

src/cli.ts

@@ -243,6 +243,8 @@ export const cliOptions = {
   },
 } satisfies Record<string, YargsOptions>;
 
+export type ParsedArguments = ReturnType<typeof parseArguments>;
+
 export function parseArguments(version: string, argv = process.argv) {
   const yargsInstance = yargs(hideBin(argv))
     .scriptName('npx chrome-devtools-mcp@latest')

src/main.ts

@@ -29,7 +29,7 @@ import {
 import {ToolCategory} from './tools/categories.js';
 import {tools as slimTools} from './tools/slim/tools.js';
 import type {ToolDefinition} from './tools/ToolDefinition.js';
-import {tools} from './tools/tools.js';
+import {createTools} from './tools/tools.js';
 
 // If moved update release-please config
 // x-release-please-start-version
@@ -260,6 +260,7 @@ function registerTool(tool: ToolDefinition): void {
   );
 }
 
+const tools = createTools(args);
 for (const tool of args.slim ? slimTools : tools) {
   registerTool(tool);
 }

src/tools/ToolDefinition.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type {ParsedArguments} from '../cli.js';
 import type {TextSnapshotNode, GeolocationOptions} from '../McpContext.js';
 import {zod} from '../third_party/index.js';
 import type {
@@ -166,6 +167,20 @@ export type Context = Readonly<{
 
 export function defineTool<Schema extends zod.ZodRawShape>(
   definition: ToolDefinition<Schema>,
+): ToolDefinition<Schema>;
+
+export function defineTool<
+  Schema extends zod.ZodRawShape,
+  Args extends ParsedArguments = ParsedArguments,
+>(
+  definition: (args: Args) => ToolDefinition<Schema>,
+): (args: Args) => ToolDefinition<Schema>;
+
+export function defineTool<
+  Schema extends zod.ZodRawShape,
+  Args extends ParsedArguments = ParsedArguments,
+>(
+  definition: ToolDefinition<Schema> | ((args: Args) => ToolDefinition<Schema>),
 ) {
   return definition;
 }

src/tools/tools.ts

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type {ParsedArguments} from '../cli.js';
+
 import * as consoleTools from './console.js';
 import * as emulationTools from './emulation.js';
 import * as extensionTools from './extensions.js';
@@ -18,23 +20,36 @@ import * as scriptTools from './script.js';
 import * as snapshotTools from './snapshot.js';
 import type {ToolDefinition} from './ToolDefinition.js';
 
-const tools = [
-  ...Object.values(consoleTools),
-  ...Object.values(emulationTools),
-  ...Object.values(extensionTools),
-  ...Object.values(inputTools),
-  ...Object.values(memoryTools),
-  ...Object.values(networkTools),
-  ...Object.values(pagesTools),
-  ...Object.values(performanceTools),
-  ...Object.values(screencastTools),
-  ...Object.values(screenshotTools),
-  ...Object.values(scriptTools),
-  ...Object.values(snapshotTools),
-] as ToolDefinition[];
+export const createTools = (args: ParsedArguments) => {
+  
+  const rawTools = [
+    ...Object.values(consoleTools),
+    ...Object.values(emulationTools),
+    ...Object.values(extensionTools),
+    ...Object.values(inputTools),
+    ...Object.values(memoryTools),
+    ...Object.values(networkTools),
+    ...Object.values(pagesTools),
+    ...Object.values(performanceTools),
+    ...Object.values(screencastTools),
+    ...Object.values(screenshotTools),
+    ...Object.values(scriptTools),
+    ...Object.values(snapshotTools),
+  ];
+
+  const tools: ToolDefinition[] = [];
+  for (const tool of rawTools) {
+    if (typeof tool === 'function') {
+      // @ts-expect-error none of the tools for now implement the function type tool has type "never"
+      tools.push(tool(args) as ToolDefinition);
+    } else {
+      tools.push(tool as ToolDefinition);
+    }
+  }
 
-tools.sort((a, b) => {
-  return a.name.localeCompare(b.name);
-});
+  tools.sort((a, b) => {
+    return a.name.localeCompare(b.name);
+  });
 
-export {tools};
+  return tools;
+};

tests/index.test.ts

@@ -92,16 +92,35 @@ describe('e2e', () => {
       const files = fs.readdirSync('build/src/tools');
       const definedNames = [];
       for (const file of files) {
-        if (file === 'ToolDefinition.js' || file === 'slim') {
+        if (
+          file === 'ToolDefinition.js' ||
+          file === 'tools.js' ||
+          file === 'slim'
+        ) {
           continue;
         }
         const fileTools = await import(`../src/tools/${file}`);
-        for (const maybeTool of Object.values<ToolDefinition>(fileTools)) {
-          if ('name' in maybeTool) {
-            if (maybeTool.annotations?.conditions) {
+        for (const maybeTool of Object.values<unknown>(fileTools)) {
+          if (typeof maybeTool === 'function') {
+            const tool = (maybeTool as (val: boolean) => ToolDefinition)(false);
+            if (tool && typeof tool === 'object' && 'name' in tool) {
+              if (tool.annotations?.conditions) {
+                continue;
+              }
+              definedNames.push(tool.name);
+            }
+            continue;
+          }
+          if (
+            typeof maybeTool === 'object' &&
+            maybeTool !== null &&
+            'name' in maybeTool
+          ) {
+            const tool = maybeTool as ToolDefinition;
+            if (tool.annotations?.conditions) {
               continue;
             }
-            definedNames.push(maybeTool.name);
+            definedNames.push(tool.name);
           }
         }
       }