@mcp-b/chrome-devtools-mcp 1.5.7 → 1.6.0

package/build/src/McpContext.js

@@ -98,6 +98,13 @@ export class McpContext {
     #toolHub;
     /** Tracks pages that have WebMCP auto-detection listeners installed. */
     #pagesWithWebMCPListeners = new WeakSet();
+    /**
+     * The windowId that this MCP session owns.
+     * When set, page operations are scoped to only pages in this window.
+     */
+    #sessionWindowId;
+    /** Cached browser-level CDP session for window operations. */
+    #browserCdpSession;
     constructor(browser, logger, options, locatorClass) {
         this.browser = browser;
         this.logger = logger;
@@ -193,6 +200,41 @@ export class McpContext {
     getToolHub() {
         return this.#toolHub;
     }
+    /**
+     * Get or create a browser-level CDP session for window operations.
+     */
+    async #getBrowserCdpSession() {
+        if (!this.#browserCdpSession) {
+            this.#browserCdpSession = await this.browser.target().createCDPSession();
+        }
+        return this.#browserCdpSession;
+    }
+    /**
+     * Get the windowId for a given page using CDP.
+     */
+    async getWindowIdForPage(page) {
+        const cdpSession = await this.#getBrowserCdpSession();
+        // @ts-expect-error _targetId is internal but stable
+        const targetId = page.target()._targetId;
+        const { windowId } = await cdpSession.send('Browser.getWindowForTarget', {
+            targetId,
+        });
+        return windowId;
+    }
+    /**
+     * Set the window that this session owns.
+     * When set, page operations are scoped to only pages in this window.
+     */
+    setSessionWindowId(windowId) {
+        this.#sessionWindowId = windowId;
+        this.logger(`Session bound to windowId: ${windowId}`);
+    }
+    /**
+     * Get the session's window ID, or undefined if not set.
+     */
+    getSessionWindowId() {
+        return this.#sessionWindowId;
+    }
     /**
      * Set up automatic WebMCP detection for a page.
      * This installs listeners that detect WebMCP after navigation and sync tools.
@@ -361,7 +403,34 @@ export class McpContext {
         return this.#consoleCollector.getById(this.getSelectedPage(), id);
     }
     async newPage() {
+        // If we have a session window, ensure our window is focused first
+        // This increases the chance that Chrome creates the new tab in our window
+        if (this.#sessionWindowId !== undefined && this.#pages.length > 0) {
+            try {
+                const existingPage = this.#pages[0];
+                if (existingPage) {
+                    await existingPage.bringToFront();
+                }
+            }
+            catch {
+                // Best effort - focus might fail if page is closing
+            }
+        }
         const page = await this.browser.newPage();
+        // Verify the new page is in our window (if session scoping is active)
+        if (this.#sessionWindowId !== undefined) {
+            try {
+                const newPageWindowId = await this.getWindowIdForPage(page);
+                if (newPageWindowId !== this.#sessionWindowId) {
+                    // New tab went to wrong window - this is a known Chrome behavior issue
+                    this.logger(`Warning: new_page created tab in window ${newPageWindowId} instead of session window ${this.#sessionWindowId}. ` +
+                        `Tab may not be visible in list_pages.`);
+                }
+            }
+            catch {
+                // Failed to get windowId - page might be in an unexpected state
+            }
+        }
         await this.createPagesSnapshot();
         // Mark as explicitly selected so this session sticks to this page
         this.selectPage(page, true);
@@ -380,7 +449,6 @@ export class McpContext {
             url: 'about:blank',
             newWindow: true,
         });
-        await cdpSession.detach();
         // Wait for the new page to be available
         const target = await this.browser.waitForTarget(target => {
             // @ts-expect-error _targetId is internal but stable
@@ -390,6 +458,30 @@ export class McpContext {
         if (!page) {
             throw new Error('Failed to get page from new window target');
         }
+        // Get window ID for this target (required for session scoping)
+        const { windowId } = await cdpSession.send('Browser.getWindowForTarget', {
+            targetId,
+        });
+        // Set window to nearly full screen (large size that fits most displays)
+        try {
+            // Set to large dimensions (works well on 1920x1080 and larger displays)
+            // This is ~95% of common display sizes without being truly fullscreen
+            await cdpSession.send('Browser.setWindowBounds', {
+                windowId,
+                bounds: {
+                    left: 20,
+                    top: 20,
+                    width: 1800,
+                    height: 1200,
+                    windowState: 'normal',
+                },
+            });
+        }
+        catch (err) {
+            // Non-fatal: window sizing is best-effort
+            this.logger('Failed to resize window:', err);
+        }
+        await cdpSession.detach();
         await this.createPagesSnapshot();
         // Mark as explicitly selected so this session sticks to this window
         this.selectPage(page, true);
@@ -397,7 +489,7 @@ export class McpContext {
         this.#consoleCollector.addPage(page);
         // Set up WebMCP auto-detection for the new page
         this.#setupWebMCPAutoDetection(page);
-        return page;
+        return { page, windowId };
     }
     async closePage(pageIdx) {
         if (this.#pages.length === 1) {
@@ -535,15 +627,40 @@ export class McpContext {
     }
     /**
      * Creates a snapshot of the pages.
+     * If a sessionWindowId is set, only pages from that window are included.
      */
     async createPagesSnapshot() {
         const allPages = await this.browser.pages(this.#options.experimentalIncludeAllPages);
-        this.#pages = allPages.filter(page => {
-            // If we allow debugging DevTools windows, return all pages.
-            // If we are in regular mode, the user should only see non-DevTools page.
+        // First filter: DevTools pages (unless experimental mode is enabled)
+        let filteredPages = allPages.filter(page => {
             return (this.#options.experimentalDevToolsDebugging ||
                 !page.url().startsWith('devtools://'));
         });
+        // Second filter: Session window scoping
+        // If we have a sessionWindowId, only include pages from that window
+        if (this.#sessionWindowId !== undefined) {
+            const windowFilteredPages = [];
+            // Check window IDs in parallel for better performance
+            const windowIdResults = await Promise.allSettled(filteredPages.map(async (page) => {
+                try {
+                    const windowId = await this.getWindowIdForPage(page);
+                    return { page, windowId };
+                }
+                catch {
+                    // Page might be closing, exclude it
+                    return null;
+                }
+            }));
+            for (const result of windowIdResults) {
+                if (result.status === 'fulfilled' &&
+                    result.value &&
+                    result.value.windowId === this.#sessionWindowId) {
+                    windowFilteredPages.push(result.value.page);
+                }
+            }
+            filteredPages = windowFilteredPages;
+        }
+        this.#pages = filteredPages;
         // Only auto-select pages[0] if:
         // 1. No page has been explicitly selected for this session AND
         // 2. Either there's no selected page OR the selected page is no longer valid

package/build/src/McpResponse.js

@@ -310,6 +310,15 @@ Call ${handleDialog.name} to handle it before continuing.`);
             }
             else {
                 response.push('<no console messages found>');
+                // Provide helpful hint about preserved messages if not already enabled
+                if (!this.#consoleDataOptions.includePreservedMessages) {
+                    response.push('');
+                    response.push('Tip: Use includePreservedMessages: true to see messages from previous navigations.');
+                }
+                // Provide hint about type filtering if specified
+                if (this.#consoleDataOptions.types?.length) {
+                    response.push(`(Filtering by types: ${this.#consoleDataOptions.types.join(', ')})`);
+                }
             }
         }
         const text = {

package/build/src/main.js

@@ -127,13 +127,39 @@ async function getContext() {
             // Fresh browser launch - use the existing default page
             // Mark it as explicitly selected so this session stays pinned to it
             context.selectPage(context.getSelectedPage(), true);
-            logger('Using existing window for this MCP session');
+            // Capture windowId for session scoping and resize the window
+            try {
+                const page = context.getSelectedPage();
+                const windowId = await context.getWindowIdForPage(page);
+                context.setSessionWindowId(windowId);
+                logger(`Using existing window for this MCP session, windowId: ${windowId}`);
+                // Resize to nearly full screen
+                const browserTarget = browser.target();
+                const cdpSession = await browserTarget.createCDPSession();
+                await cdpSession.send('Browser.setWindowBounds', {
+                    windowId,
+                    bounds: {
+                        left: 20,
+                        top: 20,
+                        width: 1800,
+                        height: 1200,
+                        windowState: 'normal',
+                    },
+                });
+                await cdpSession.detach();
+                logger('Resized window to nearly full screen');
+            }
+            catch (err) {
+                // Non-fatal: window sizing is best-effort, but windowId capture is important
+                logger('Failed to capture windowId or resize window:', err);
+            }
         }
         else {
             // Connected to existing browser - create new window for isolation
             // This ensures multiple MCP clients don't step on each other's toes
-            await context.newWindow();
-            logger('Created new window for this MCP session');
+            const { windowId } = await context.newWindow();
+            context.setSessionWindowId(windowId);
+            logger(`Created new window for this MCP session, windowId: ${windowId}`);
         }
         // Initialize WebMCP tool hub for dynamic tool registration
         const toolHub = new WebMCPToolHub(server, context);
@@ -179,7 +205,7 @@ function registerTool(tool) {
     }
     server.registerTool(tool.name, {
         description: tool.description,
-        inputSchema: zod.object(tool.schema).passthrough(),
+        inputSchema: zod.object(tool.schema).strict(),
         annotations: tool.annotations,
     }, async (params) => {
         const guard = await toolMutex.acquire();

package/build/src/third_party/index.js

@@ -11,6 +11,6 @@ export { default as debug } from 'debug';
 export { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 export { SetLevelRequestSchema, ToolListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
-export { z as zod } from 'zod';
+export { z as zod } from 'zod/v4';
 export { Locator, PredefinedNetworkConditions, CDPSessionEvent, } from 'puppeteer-core';
 export { default as puppeteer } from 'puppeteer-core';

package/build/src/tools/webmcp.js

@@ -78,40 +78,133 @@ import { defineTool } from './ToolDefinition.js';
 //   response.appendResponseLine('  2. take_snapshot - verify page state');
 // }
 /**
- * List all WebMCP tools registered across all pages with full definitions including schemas.
+ * Convert a glob-style pattern to a RegExp.
+ * Supports * (any chars) and ? (single char).
+ */
+function globToRegex(pattern) {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars except * and ?
+        .replace(/\*/g, '.*') // * -> .*
+        .replace(/\?/g, '.'); // ? -> .
+    return new RegExp(`^${escaped}$`, 'i'); // Case insensitive, full match
+}
+/**
+ * List WebMCP tools registered on browser pages.
+ * By default returns tools from the currently selected page only.
+ * Use all_pages=true to see tools from all tabs.
  */
 export const listWebMCPTools = defineTool({
     name: 'list_webmcp_tools',
-    description: 'List all WebMCP tools registered across all pages. ' +
-        'Returns full tool definitions including input schemas. ' +
-        'To call a tool, use call_webmcp_tool({ name: "tool_name", arguments: {...} }).',
+    description: 'List WebMCP tools registered on browser pages. ' +
+        'By default, returns tools from the currently selected page only. ' +
+        'Use all_pages=true to see tools from all tabs. ' +
+        'Returns tool definitions including name, description, input schema, and page index. ' +
+        'Use call_webmcp_tool to invoke a tool.',
     annotations: {
         title: 'List Website MCP Tools',
         category: ToolCategory.WEBMCP,
         readOnlyHint: true,
     },
-    schema: {},
-    handler: async (_request, response, context) => {
+    schema: {
+        page_index: zod
+            .number()
+            .int()
+            .optional()
+            .describe('Only show tools from this specific page index'),
+        all_pages: zod
+            .boolean()
+            .optional()
+            .describe('If true, return tools from all pages instead of just the selected page (default: false)'),
+        pattern: zod
+            .string()
+            .optional()
+            .describe('Glob pattern to filter tool names (e.g., "skill*", "*_config")'),
+        summary: zod
+            .boolean()
+            .optional()
+            .describe('If true, return only name and first line of description, omitting full schemas (default: false)'),
+    },
+    handler: async (request, response, context) => {
+        const { page_index, all_pages, pattern, summary } = request.params;
         const toolHub = context.getToolHub();
         if (!toolHub) {
             response.appendResponseLine('WebMCPToolHub not initialized.');
             return;
         }
-        const tools = toolHub.getRegisteredTools();
+        let tools = toolHub.getRegisteredTools();
+        // If no tools found, try connecting to WebMCP on the current page
+        // This handles cases where auto-detection is still in progress or timed out
+        if (tools.length === 0) {
+            const page = context.getSelectedPage();
+            const result = await context.getWebMCPClient(page);
+            if (result.connected) {
+                // Re-fetch tools after connection (sync happens in getWebMCPClient)
+                tools = toolHub.getRegisteredTools();
+            }
+        }
+        // Determine which page(s) to show
+        const selectedPageIdx = context.getPages().indexOf(context.getSelectedPage());
+        // Filter by page
+        if (page_index !== undefined) {
+            // Specific page requested
+            tools = tools.filter(t => t.pageIdx === page_index);
+        }
+        else if (!all_pages) {
+            // Default: selected page only
+            tools = tools.filter(t => t.pageIdx === selectedPageIdx);
+        }
+        // else: all_pages=true, show everything
+        // Filter by pattern
+        if (pattern) {
+            const regex = globToRegex(pattern);
+            tools = tools.filter(t => regex.test(t.originalName));
+        }
         if (tools.length === 0) {
-            response.appendResponseLine('No WebMCP tools registered.');
+            const filters = [];
+            if (page_index !== undefined) {
+                filters.push(`page_index=${page_index}`);
+            }
+            else if (!all_pages) {
+                filters.push(`selected page (${selectedPageIdx})`);
+            }
+            if (pattern) {
+                filters.push(`pattern="${pattern}"`);
+            }
+            const filterMsg = filters.length > 0 ? ` (filters: ${filters.join(', ')})` : '';
+            response.appendResponseLine(`No WebMCP tools found${filterMsg}.`);
+            if (!all_pages && page_index === undefined) {
+                response.appendResponseLine('');
+                response.appendResponseLine('Tip: Use all_pages=true to search across all pages.');
+            }
+            response.appendResponseLine('');
             response.appendResponseLine('Navigate to a page with @mcp-b/global loaded to discover tools.');
             return;
         }
-        // Format as JSON for easy parsing by the model
-        const toolDefinitions = tools.map(tool => ({
-            name: tool.originalName,
-            description: tool.description,
-            inputSchema: tool.inputSchema,
-            pageIdx: tool.pageIdx,
-            domain: tool.domain,
-        }));
-        response.appendResponseLine(JSON.stringify({ tools: toolDefinitions }, null, 2));
+        // Format output
+        if (summary) {
+            // Compact output: name + first line of description
+            const toolSummaries = tools.map(tool => {
+                const firstLine = tool.description.split('\n')[0].split('. ')[0];
+                const truncated = firstLine.length > 60 ? firstLine.slice(0, 57) + '...' : firstLine;
+                return {
+                    name: tool.originalName,
+                    description: truncated,
+                    pageIdx: tool.pageIdx,
+                };
+            });
+            response.appendResponseLine(JSON.stringify({ tools: toolSummaries, count: tools.length }, null, 2));
+        }
+        else {
+            // Full output with schemas
+            const toolDefinitions = tools.map(tool => ({
+                name: tool.originalName,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+                pageIdx: tool.pageIdx,
+                domain: tool.domain,
+            }));
+            response.appendResponseLine(JSON.stringify({ tools: toolDefinitions, count: tools.length }, null, 2));
+        }
     },
 });
 /**
@@ -120,10 +213,9 @@ export const listWebMCPTools = defineTool({
  */
 export const callWebMCPTool = defineTool({
     name: 'call_webmcp_tool',
-    description: 'Call a tool registered on a webpage via WebMCP. ' +
-        'Usage: call_webmcp_tool({ name: "tool_name", arguments: { key: "value" } }). ' +
-        'Use list_webmcp_tools to see available tools and their schemas. ' +
-        'Use page_index to target a specific page.',
+    description: 'Call a WebMCP tool registered on a webpage. ' +
+        'Auto-connects to the page if needed. ' +
+        'Use list_webmcp_tools first to see available tools and their input schemas.',
     annotations: {
         title: 'Call Website MCP Tool',
         category: ToolCategory.WEBMCP,
@@ -132,9 +224,31 @@ export const callWebMCPTool = defineTool({
     schema: {
         name: zod.string().describe('The name of the tool to call'),
         arguments: zod
-            .record(zod.any())
+            .union([
+            zod.record(zod.string(), zod.any()),
+            zod.string().transform((str, ctx) => {
+                try {
+                    const parsed = JSON.parse(str);
+                    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                        ctx.addIssue({
+                            code: zod.ZodIssueCode.custom,
+                            message: 'Arguments must be a JSON object, not an array or primitive',
+                        });
+                        return zod.NEVER;
+                    }
+                    return parsed;
+                }
+                catch {
+                    ctx.addIssue({
+                        code: zod.ZodIssueCode.custom,
+                        message: `Invalid JSON string for arguments: ${str.slice(0, 100)}${str.length > 100 ? '...' : ''}`,
+                    });
+                    return zod.NEVER;
+                }
+            }),
+        ])
             .optional()
-            .describe('Arguments to pass to the tool as a JSON object'),
+            .describe('Arguments to pass to the tool as a JSON object (or JSON string that will be parsed)'),
         page_index: zod
             .number()
             .int()
@@ -166,6 +280,30 @@ export const callWebMCPTool = defineTool({
             return;
         }
         const client = result.client;
+        // Check if arguments are empty but the tool expects required fields
+        const toolHub = context.getToolHub();
+        const toolDef = toolHub?.getToolByName(name, page);
+        const argsEmpty = !args || Object.keys(args).length === 0;
+        if (argsEmpty && toolDef?.inputSchema) {
+            const schema = toolDef.inputSchema;
+            const requiredFields = schema.required ?? [];
+            const properties = schema.properties;
+            if (requiredFields.length > 0) {
+                response.appendResponseLine(`⚠️  Warning: Calling "${name}" with empty arguments, but tool expects required fields: ${requiredFields.join(', ')}`);
+                response.appendResponseLine('');
+                // Show the expected schema
+                if (properties) {
+                    response.appendResponseLine('Expected schema:');
+                    for (const field of requiredFields) {
+                        const prop = properties[field];
+                        const typeStr = prop?.type || 'unknown';
+                        const descStr = prop?.description ? ` - ${prop.description}` : '';
+                        response.appendResponseLine(`  • ${field} (${typeStr})${descStr}`);
+                    }
+                    response.appendResponseLine('');
+                }
+            }
+        }
         try {
             const callResult = await client.callTool({
                 name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-b/chrome-devtools-mcp",
-  "version": "1.5.7",
+  "version": "1.6.0",
   "description": "MCP server for Chrome DevTools with WebMCP integration for connecting to website MCP tools",
   "keywords": [
     "mcp",
@@ -56,7 +56,7 @@
     "puppeteer": "24.32.0",
     "puppeteer-core": "24.32.0",
     "yargs": "18.0.0",
-    "zod": "3.25.76"
+    "zod": "4.3.5"
   },
   "devDependencies": {
     "@eslint/js": "^9.35.0",
@@ -89,7 +89,7 @@
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.43.0",
     "yargs": "18.0.0",
-    "zod": "3.25.76"
+    "zod": "4.3.5"
   },
   "engines": {
     "node": "^20.19.0 || ^22.12.0 || >=23"