format

Author: wolfib

src/McpResponse.ts

@@ -41,7 +41,9 @@ interface TraceInsightData {
   insightName: InsightName;
 }
 
-async function getToolGroup(page: McpPage): Promise<ToolGroup<ToolDefinition> | undefined> {
+async function getToolGroup(
+  page: McpPage,
+): Promise<ToolGroup<ToolDefinition> | undefined> {
   // Check if there is a `devtoolstooldiscovery` event listener
   const windowHandle = await page.pptrPage.evaluateHandle(() => window);
   // @ts-expect-error internal API

src/tools/inPage.ts

@@ -24,7 +24,9 @@ export interface ToolGroup<T extends ToolDefinition> {
 declare global {
   interface Window {
     __dtmcp?: {
-      toolGroup?: ToolGroup<ToolDefinition & {execute: (args: Record<string, unknown>) => unknown}>;
+      toolGroup?: ToolGroup<
+        ToolDefinition & {execute: (args: Record<string, unknown>) => unknown}
+      >;
       executeTool?: (
         toolName: string,
         args: Record<string, unknown>,

tests/index.test.ts

@@ -72,58 +72,56 @@ describe('e2e', () => {
   });
 
   it('has all tools', async () => {
-    await withClient(
-      async client => {
-        const {tools} = await client.listTools();
-        const exposedNames = tools.map(t => t.name).sort();
-        const files = fs.readdirSync('build/src/tools');
-        const definedNames = [];
-        for (const file of files) {
-          if (
-            file === 'ToolDefinition.js' ||
-            file === 'tools.js' ||
-            file === 'slim'
-          ) {
-            continue;
-          }
-          const fileTools = await import(`../src/tools/${file}`);
-          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;
+    await withClient(async client => {
+      const {tools} = await client.listTools();
+      const exposedNames = tools.map(t => t.name).sort();
+      const files = fs.readdirSync('build/src/tools');
+      const definedNames = [];
+      for (const file of files) {
+        if (
+          file === 'ToolDefinition.js' ||
+          file === 'tools.js' ||
+          file === 'slim'
+        ) {
+          continue;
+        }
+        const fileTools = await import(`../src/tools/${file}`);
+        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(tool.name);
           }
         }
-        definedNames.sort();
-        assert.deepStrictEqual(exposedNames, definedNames);
-      },
-    );
+      }
+      definedNames.sort();
+      assert.deepStrictEqual(exposedNames, definedNames);
+    });
   });
 
   it('has experimental in-Page tools', async () => {
     await withClient(
       async client => {
         const {tools} = await client.listTools();
-        const listInPageTools = tools.find(t => t.name === 'list_in_page_tools');
+        const listInPageTools = tools.find(
+          t => t.name === 'list_in_page_tools',
+        );
         assert.ok(listInPageTools);
       },
       ['--category-in-page-tools'],
@@ -134,7 +132,9 @@ describe('e2e', () => {
     await withClient(
       async client => {
         const {tools} = await client.listTools();
-        const installExtension = tools.find(t => t.name === 'install_extension');
+        const installExtension = tools.find(
+          t => t.name === 'install_extension',
+        );
         assert.ok(installExtension);
       },
       ['--category-extensions'],

tests/tools/inPage.test.ts

@@ -53,16 +53,16 @@ describe('inPage', () => {
           assert.strictEqual(actualGroup.description, 'test description');
           assert.strictEqual(actualGroup.tools.length, 1);
           assert.strictEqual(actualGroup.tools[0].name, 'test-tool');
-            assert.strictEqual(
-              actualGroup.tools[0].description,
-              'test tool description',
-            );
-            assert.deepEqual(actualGroup.tools[0].inputSchema, {
-              type: 'object',
-              properties: {
-                arg: {type: 'string'},
-              },
-            });
+          assert.strictEqual(
+            actualGroup.tools[0].description,
+            'test tool description',
+          );
+          assert.deepEqual(actualGroup.tools[0].inputSchema, {
+            type: 'object',
+            properties: {
+              arg: {type: 'string'},
+            },
+          });
         },
         undefined,
         {categoryInPageTools: true} as ParsedArguments,