fastbrowser_cli 1.0.31 → 1.0.35

package/src/fastbrowser_mcp/fastbrowser_mcp.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 // node imports
-import * as Assert from 'node:assert/strict';
 import Fs from 'node:fs';
 import Path from 'node:path';
 
@@ -11,6 +10,7 @@ import { z } from "zod";
 import * as A11yParse from "a11y_parse";
 
 // local imports
+import { Logger } from "../shared/logger.js"
 import { McpMyClient } from "./libs/mcp_my_client.js";
 import { McpProxy } from "./libs/mcp_proxy.js";
 import { ResponseFormatter } from "./libs/response_formatter.js";
@@ -40,6 +40,10 @@ export {
 	type QuerySelectorsFirstInput,
 };
 
+const logger = Logger.fromMetaUrl(import.meta.url, {
+	allToStderr: true,
+});
+
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 //	
@@ -47,21 +51,62 @@ export {
 ///////////////////////////////////////////////////////////////////////////////
 
 class MainHelper {
+	/**
+	 * Multiple retry... not sure it is actually useful - https://github.com/jeromeetienne/skillmd_collection/issues/47
+	 * 
+	 * @param mcpClient 
+	 * @returns 
+	 */
 	private static async _getA11yText(mcpClient: McpMyClient): Promise<string> {
 		const mcpTarget = await mcpClient.getMcpTarget();
 		const toolConfig = await McpTargetHelper.targetToolTakeSnapshot(mcpTarget);
 
-		// FIXME: the first take_snapshot call after connecting to the MCP target often returns an empty snapshot for unknown reasons 
-		// — working around this by calling it once and discarding the result before calling it again to get the actual snapshot text
-		await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
+		// `take_snapshot` is racy — for reasons we haven't traced (could be playwright's a11y serializer, the
+		// `@playwright/mcp` extension transport, or the chrome extension itself), back-to-back calls on an unchanged
+		// page sometimes return incomplete or empty trees. Stabilize by taking snapshots in pairs and only returning
+		// once two consecutive ones agree on node count within STABLE_TOLERANCE. On exhaustion, return best-effort
+		// rather than throw, so legitimately tiny pages don't break workflows.
+		const MAX_ATTEMPTS = 6;
+		const RETRY_DELAY_MS = 250;
+		const STABLE_TOLERANCE = 2;
+
+		let prev: { text: string; nodeCount: number } | undefined = undefined;
+		let last: { text: string; nodeCount: number } = { text: '', nodeCount: 0 };
+
+		for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+			const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
+			const text = await ResponseFormatter.formatTakeSnapshot(mcpTarget, callToolResult);
+			const nodeCount = MainHelper._countSnapshotNodes(text);
+			last = { text, nodeCount };
+
+			if (prev !== undefined && Math.abs(nodeCount - prev.nodeCount) <= STABLE_TOLERANCE) {
+				if (nodeCount === 0) {
+					logger.warn(`${mcpTarget}:take_snapshot: settled at empty after ${attempt} attempt(s) — returning empty snapshot`);
+				}
+				return text;
+			}
 
-		const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
-		const snapshotText = await ResponseFormatter.formatTakeSnapshot(mcpTarget, callToolResult);
-		// sanity check
-		Assert.ok(snapshotText !== undefined, "Snapshot text is empty");
+			logger.warn(`${mcpTarget}:take_snapshot: attempt ${attempt}/${MAX_ATTEMPTS}: nodeCount=${nodeCount}, prev=${prev === undefined ? 'n/a' : prev.nodeCount} — not stable, retrying`);
 
-		// return the snapshot text
-		return snapshotText;
+			prev = last;
+			if (attempt < MAX_ATTEMPTS) {
+				await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+			}
+		}
+
+		logger.warn(`${mcpTarget}:take_snapshot: exhausted ${MAX_ATTEMPTS} attempts without stabilizing — returning best-effort (nodeCount=${last.nodeCount})`);
+		return last.text;
+	}
+
+	private static _countSnapshotNodes(snapshotText: string): number {
+		if (snapshotText.trim().length === 0) return 0;
+		let count = 0;
+		for (const line of snapshotText.split('\n')) {
+			if (line.trim().startsWith('uid=')) {
+				count += 1;
+			}
+		}
+		return count;
 	}
 
 	/**
@@ -106,18 +151,32 @@ class MainHelper {
 		selector: string,
 		selectedNodes: A11yParse.AxNode[],
 		withAncestors: boolean,
+		withChildren: boolean,
 	): string {
-		let text: string = `## Node found for selector '${selector}' (${selectedNodes.length} node${selectedNodes.length > 1 ? 's' : ''}${withAncestors ? ', with ancestors' : ''}):\n`;
-		if (withAncestors) {
-			if (selectedNodes.length === 0) {
-				text += "No node found";
-			} else {
-				const ancestorTree = A11yParse.A11yTree.buildAncestorTree(selectedNodes);
-				text += A11yParse.A11yTree.stringify(ancestorTree);
+		const nodeCount = selectedNodes.length;
+		const pluralS = nodeCount > 1 ? 's' : '';
+		const ancestorsText = withAncestors ? ', with ancestors' : '';
+		const childrenText = withChildren ? ', with children' : '';
+		let text: string = `## Node${pluralS} found for selector '${selector}' (${nodeCount} node${pluralS}${ancestorsText}${childrenText}):`;
+		if (selectedNodes.length === 0) {
+			if (text.length > 0) text += '\n';
+			text += "No node found";
+		} else if (withAncestors === true) {
+			const subsetTree = A11yParse.A11yTree.buildSubsetTree(selectedNodes, {
+				withAncestors: true,
+				withChildren,
+			});
+			if (text.length > 0) text += '\n';
+			text += A11yParse.A11yDisplay.stringifyTree(subsetTree);
+		} else if (withChildren === true) {
+			for (const selectedNode of selectedNodes) {
+				if (text.length > 0) text += '\n';
+				text += A11yParse.A11yDisplay.stringifyTree(selectedNode);
 			}
 		} else {
 			for (const selectedNode of selectedNodes) {
-				text += A11yParse.A11yTree.stringify(selectedNode) + '\n';
+				if (text.length > 0) text += '\n';
+				text += A11yParse.A11yDisplay.stringifyNode(selectedNode);
 			}
 		}
 		text += '\n';
@@ -144,7 +203,7 @@ class MainHelper {
 				selectedNodes.splice(querySelector.limit);
 			}
 
-			responseTexts.push(this._formatSelectedNodes(querySelector.selector, selectedNodes, querySelector.withAncestors));
+			responseTexts.push(this._formatSelectedNodes(querySelector.selector, selectedNodes, querySelector.withAncestors, querySelector.withChildren));
 		}
 
 		// join the response texts for all selectors and return
@@ -167,7 +226,7 @@ class MainHelper {
 		for (const querySelector of querySelectors.selectors) {
 			const selectedNodes = A11yParse.A11yQuery.querySelectorAll(a11yTree, querySelector.selector);
 			const firstNode = selectedNodes.length > 0 ? [selectedNodes[0]] : [];
-			responseTexts.push(this._formatSelectedNodes(querySelector.selector, firstNode, querySelector.withAncestors));
+			responseTexts.push(this._formatSelectedNodes(querySelector.selector, firstNode, querySelector.withAncestors, querySelector.withChildren));
 		}
 
 		return responseTexts.join('\n');
@@ -195,10 +254,16 @@ class MainHelper {
 				inputSchema: z.object({}),
 			},
 			async () => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.listPages}: listing pages`);
+
 				const toolConfig = await McpTargetHelper.targetToolListPages(mcpTarget);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputStr = await ResponseFormatter.formatListPages(mcpTarget, callToolResult);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.listPages}: output:`)
+				logger.warn(`${outputStr}`);
 				return {
 					content: [{ type: "text", text: outputStr }],
 				};
@@ -228,11 +293,18 @@ class MainHelper {
 				// const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				// let outputStr = await ResponseFormatter.formatNewPage(mcpTarget, callToolResult, url);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.newPage}: url=${url}`);
+
+
 				// so working around this by calling the navigate_page tool instead of new_page when the target is playwright
 				const toolConfig = await McpTargetHelper.targetToolNavigatePage(mcpTarget, url);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputStr = await ResponseFormatter.formatNavigatePage(mcpTarget, callToolResult);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.newPage}: output:`)
+				logger.warn(`${outputStr}`);
 
 				return {
 					content: [{ type: "text", text: outputStr }],
@@ -255,10 +327,17 @@ class MainHelper {
 				}),
 			},
 			async ({ pageId }: { pageId: number }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.closePage}: pageId=${pageId}`);
+
 				const toolConfig = await McpTargetHelper.targetToolClosePage(mcpTarget, pageId);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputStr = await ResponseFormatter.formatClosePage(mcpTarget, callToolResult, pageId);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.closePage}: output:`)
+				logger.warn(`${outputStr}`);
+
 				return {
 					content: [{ type: "text", text: outputStr }],
 				};
@@ -280,10 +359,17 @@ class MainHelper {
 				}),
 			},
 			async ({ url }: { url: string }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.navigatePage}: url=${url}`);
+
 				const toolConfig = await McpTargetHelper.targetToolNavigatePage(mcpTarget, url);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputStr = await ResponseFormatter.formatNavigatePage(mcpTarget, callToolResult);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.navigatePage}: output:`)
+				logger.warn(`${outputStr}`);
+
 				return {
 					content: [{ type: "text", text: outputStr }],
 				};
@@ -303,9 +389,16 @@ class MainHelper {
 				inputSchema: z.object({}),
 			},
 			async () => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.takeSnapshot}: taking snapshot`);
+
 				const a11yText: string = await MainHelper._getA11yText(mcpClient);
 				let outputStr = a11yText
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.takeSnapshot}: output:`);
+				logger.warn(`${outputStr}`);
+
 				return {
 					content: [{ type: "text", text: outputStr }],
 				};
@@ -342,9 +435,16 @@ class MainHelper {
 				inputSchema: QuerySelectorsInputSchema,
 			},
 			async (querySelectorsInput: QuerySelectorsInput) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.querySelectorsAll}: querying selectors: ${JSON.stringify(querySelectorsInput)}`);
+
 				// query the accessibility tree with the provided selector
 				const outputText: string = await MainHelper.querySelectorsAll(mcpClient, querySelectorsInput);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.querySelectorsAll}: output:`);
+				logger.warn(`${outputText}`);
+
 				return {
 					content: [{ type: "text", text: outputText }],
 				};
@@ -367,7 +467,15 @@ class MainHelper {
 				inputSchema: QuerySelectorsFirstInputSchema,
 			},
 			async (querySelectorsInput: QuerySelectorsFirstInput) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.querySelectors}: querying selectors: ${JSON.stringify(querySelectorsInput)}`);
+
 				const outputText: string = await MainHelper.querySelectors(mcpClient, querySelectorsInput);
+
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.querySelectors}: output:`);
+				logger.warn(`${outputText}`);
+
 				return {
 					content: [{ type: "text", text: outputText }],
 				};
@@ -389,6 +497,9 @@ class MainHelper {
 				}),
 			},
 			async ({ keys }: { keys: string }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.pressKeys}: pressing keys: ${keys}`);
+
 				// Build the list of keys to send, splitting regular characters into individual key presses, but keeping special keys as-is
 				const keysToSend: string[] = [];
 				const keysSplit = keys.split(',').map((key) => key.trim());
@@ -419,6 +530,10 @@ class MainHelper {
 
 				let outputText = await ResponseFormatter.formatPressKeys(mcpTarget, keysToSend);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.pressKeys}: output:`);
+				logger.warn(`${outputText}`);
+
 				// return a response indicating which keys were pressed
 				return {
 					content: [{ type: "text", text: outputText }],
@@ -444,12 +559,17 @@ class MainHelper {
 				},
 			},
 			async ({ selector }: { selector: string }) => {
-				const uid = await MainHelper._resolveSelectorToUid(mcpClient, selector);
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.click}: clicking selector: ${selector}`);
 
+				const uid = await MainHelper._resolveSelectorToUid(mcpClient, selector);
 				const toolConfig = await McpTargetHelper.targetToolClick(mcpTarget, uid);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputText = await ResponseFormatter.formatClick(mcpTarget, callToolResult);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.click}: output:`);
+
 				return {
 					content: [{ type: "text", text: outputText }],
 				};
@@ -477,6 +597,9 @@ class MainHelper {
 				},
 			},
 			async ({ elements }: { elements: { selector: string; value: string }[] }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.fillForm}: filling form with elements: ${JSON.stringify(elements)}`);
+
 				const resolved = [];
 				for (const element of elements) {
 					const uid = await MainHelper._resolveSelectorToUid(mcpClient, element.selector);
@@ -485,32 +608,36 @@ class MainHelper {
 						value: element.value,
 					});
 				}
+				let callToolResult: CallToolResult;
 				if (mcpTarget === 'chrome_devtools') {
 					const toolConfig = await McpTargetHelper.targetToolFillForm(mcpTarget, resolved);
-					const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
-					// const callToolResult = await mcpClient.callTool('fill_form', { elements: resolved });
-					return callToolResult
+					callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				} else if (mcpTarget === 'playwright') {
 					type Field = {
 						name: string; // Human readable name for the field, e.g. "Email address"
 						// type can be textbox, checkbox, radio, combobox, or slider
 						type: 'textbox' | 'checkbox' | 'radio' | 'combobox' | 'slider';
 						// the uid of the field's corresponding node in the accessibility tree
-						ref: string;
+						target: string;
 						// the value to fill into the field - for checkboxes this can be "checked" or "unchecked", for radio buttons this can be "selected", for comboboxes this can be the option to select, and for sliders this can be the value to set the slider to
 						value: string
 					};
 					const fields: Field[] = resolved.map((element, index) => ({
 						name: `Field ${index + 1}`,
 						type: 'textbox', // for simplicity, we assume all fields are textboxes in this example
-						ref: element.uid,
+						target: element.uid,
 						value: element.value,
 					}));
-					const callToolResult = await mcpClient.callTool('browser_fill_form', { fields: fields });
-					return callToolResult
+					callToolResult = await mcpClient.callTool('browser_fill_form', { fields: fields });
 				} else {
 					throw new Error(`Unsupported MCP target: ${mcpTarget}`);
 				}
+
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.fillForm}: output:`);
+				logger.warn(`${JSON.stringify(callToolResult)}`);
+
+				return callToolResult
 			}
 		);
 
@@ -530,6 +657,10 @@ class MainHelper {
 				inputSchema: timezoneSchema,
 			},
 			async ({ timezone }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.getCurrentDateTime}: getting current date and time with timezone: ${timezone ?? 'local system timezone'}`);
+
+
 				const date = new Date();
 				const options: Intl.DateTimeFormatOptions = {
 					timeZone: timezone,
@@ -542,6 +673,10 @@ class MainHelper {
 					timeZoneName: "short",
 				};
 				const formatted = new Intl.DateTimeFormat("en-US", options).format(date);
+
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.getCurrentDateTime}: output: ${formatted}`);
+
 				return {
 					content: [{ type: "text", text: formatted }],
 				};
@@ -564,6 +699,11 @@ class MainHelper {
 		mcpTarget: FastBrowserMcpTarget,
 		verbose?: boolean
 	}): Promise<void> {
+		// Redirect process.stderr to a log file, so that the MCP communication is not polluted by logs.
+		const logFile = Path.resolve(import.meta.dirname, `../../outputs/fastbrowser_mcp_${new Date().toISOString()}.log`);
+		const logStream = Fs.createWriteStream(logFile, { flags: 'a' });
+		process.stderr.write = logStream.write.bind(logStream);
+
 		///////////////////////////////////////////////////////////////////////////////
 		///////////////////////////////////////////////////////////////////////////////
 		//	mcp client
@@ -616,11 +756,13 @@ class MainHelper {
 					{
 						selector: "link, button",
 						withAncestors: true,
+						withChildren: false,
 						limit: 0,
 					},
 					{
 						selector: 'heading[level="1"]',
 						withAncestors: false,
+						withChildren: false,
 						limit: 0,
 					},
 				],
@@ -646,19 +788,64 @@ class MainHelper {
 		for (const toolName of toolsToProxys) {
 			await mcpProxy.proxyToolCall(mcpClient, toolName)
 		}
+
 		///////////////////////////////////////////////////////////////////////////////
 		///////////////////////////////////////////////////////////////////////////////
 		//	.querySelectorsAll tool implementation
 		///////////////////////////////////////////////////////////////////////////////
 		///////////////////////////////////////////////////////////////////////////////
-		const mcpServer = await mcpProxy.getMcpServer();
 
+		const mcpServer = await mcpProxy.getMcpServer();
 		await MainHelper.initExternalTools(mcpServer, mcpClient);
 
-
 		// Connect the MCP proxy server to start accepting connections from MCP clients (e.g. LLM agents).
 		await mcpProxy.connect();
 	}
+
+	///////////////////////////////////////////////////////////////////////////////
+	///////////////////////////////////////////////////////////////////////////////
+	//	.commandTargetTools: connect to the target MCP and print each tool's name, description, and input schema.
+	///////////////////////////////////////////////////////////////////////////////
+	///////////////////////////////////////////////////////////////////////////////
+
+	static async commandTargetTools({
+		mcpTarget,
+	}: {
+		mcpTarget: FastBrowserMcpTarget,
+	}): Promise<void> {
+		const { command: mcpCommand, args: mcpArgs } = McpTargetHelper.mcpArgs(mcpTarget);
+
+		const mcpClient = new McpMyClient({
+			name: 'fastbrowser_target_tools_client',
+			version: '1.0.0',
+			mcpTarget,
+			transport: {
+				type: 'stdio',
+				command: mcpCommand,
+				args: mcpArgs,
+			},
+		});
+
+		await mcpClient.connect();
+		try {
+			const tools = await mcpClient.listTools();
+			console.log(`# Tools available on MCP target '${mcpTarget}' (${tools.length})\n`);
+			for (const tool of tools) {
+				console.log(`## ${tool.name}`);
+				console.log('');
+				console.log(`### Description`)
+				console.log(`${tool.description ?? '(no description)'}`);
+				console.log('');
+				console.log(`### Input schema`);
+				console.log("```");
+				console.log(JSON.stringify(tool.inputSchema, null, 2));
+				console.log("```");
+				console.log('');
+			}
+		} finally {
+			await mcpClient.close();
+		}
+	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -668,12 +855,6 @@ class MainHelper {
 ///////////////////////////////////////////////////////////////////////////////
 
 async function main() {
-	// Redirect process.stderr to a log file, so that the MCP communication is not polluted by logs.
-	const logFile = Path.resolve(import.meta.dirname, `../../outputs/fastbrowser_mcp_${new Date().toISOString()}.log`);
-	const logStream = Fs.createWriteStream(logFile, { flags: 'a' });
-	process.stderr.write = logStream.write.bind(logStream);
-
-
 	// throw Error("This entry point is not meant to be run directly. Please run one of the npm scripts defined in package.json, e.g. 'npm run start:fastbrowser_mcp' or 'npm run inspect:fastbrowser_mcp:chrome_devtools'");
 
 	const program = new Command();
@@ -693,6 +874,20 @@ async function main() {
 			});
 		});
 
+	program
+		.command('target_tools')
+		.description('List the tools exposed by the target MCP (name, description, input schema)')
+		.addOption(
+			new Option('-b, --mcp_target <mcpTarget>', 'the MCP target to introspect')
+				.choices(['chrome_devtools', 'playwright'])
+				.default('playwright')
+		)
+		.action(async (options: { mcp_target: FastBrowserMcpTarget }) => {
+			await MainHelper.commandTargetTools({
+				mcpTarget: options.mcp_target,
+			});
+		});
+
 	// display help if no command is provided
 	if (process.argv.length < 3) {
 		program.help();

package/src/fastbrowser_mcp/libs/mcp_my_client.ts

@@ -1,4 +1,7 @@
+
+
 // node import
+import { Logger } from "../../shared/logger.js"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -6,6 +9,12 @@ import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { CallToolResult, Prompt, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
 import { FastBrowserMcpTarget } from "../fastbrowser_types.js";
 
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+//	
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
 export type StdioConfig = {
 	type: "stdio";
 	command: string;
@@ -34,6 +43,10 @@ export interface McpClientOptions {
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
+const logger = Logger.fromMetaUrl(import.meta.url, {
+	allToStderr: true,
+});
+
 // TODO remove this function - it seems to do vastly nothing - more confusing that helpful
 // - i use the McpServer directly, and i got a wrapper for the client... discrepancy is confusing
 export class McpMyClient {
@@ -57,9 +70,11 @@ export class McpMyClient {
 
 	async connect(): Promise<void> {
 		if (this.connected) return;
+		logger.warn(`McpMyClient:connect: Connecting to MCP with target ${this.mcpTarget}`);
 
 		this.transport = this.createTransport(this.options.transport);
 		await this.client.connect(this.transport);
+		logger.warn(`McpMyClient:connect: Connected to MCP with target ${this.mcpTarget}`);
 		this.connected = true;
 	}
 
@@ -72,6 +87,7 @@ export class McpMyClient {
 	async listTools(): Promise<Tool[]> {
 		this.assertConnected();
 		const { tools } = await this.client.listTools();
+		logger.warn(`McpMyClient:listTools: ${JSON.stringify(tools, null, 2)}`);
 		return tools;
 	}
 
@@ -80,6 +96,7 @@ export class McpMyClient {
 		args: Record<string, unknown> = {},
 	): Promise<CallToolResult> {
 		this.assertConnected();
+		logger.warn(`McpMyClient:callTool: name: ${name} args: ${JSON.stringify(args, null, 2)}`);
 		return this.client.callTool({ name, arguments: args }) as Promise<CallToolResult>;
 	}
 

package/src/fastbrowser_mcp/libs/mcp_target_helper.ts

@@ -182,9 +182,21 @@ export class McpTargetHelper {
 
 	static async targetToolClick(mcpTarget: FastBrowserMcpTarget, uid: string): Promise<TargetToolConfig> {
 		if (mcpTarget === 'chrome_devtools') {
-			return { toolName: 'click', toolArgs: { uid } };
+			const toolConfig: TargetToolConfig = {
+				toolName: 'click',
+				toolArgs: {
+					uid
+				}
+			};
+			return toolConfig;
 		} else if (mcpTarget === 'playwright') {
-			return { toolName: 'browser_click', toolArgs: { ref: uid } };
+			const toolConfig: TargetToolConfig = {
+				toolName: 'browser_click',
+				toolArgs: {
+					target: uid
+				}
+			};
+			return toolConfig;
 		} else {
 			throw new Error(`Unsupported MCP target: ${mcpTarget}`);
 		}
@@ -194,6 +206,7 @@ export class McpTargetHelper {
 		if (mcpTarget === 'chrome_devtools') {
 			return { toolName: 'fill_form', toolArgs: { elements } };
 		} else if (mcpTarget === 'playwright') {
+			// FIXME browser_fill_form tool exist in playwright MCP... implement it later
 			throw new Error(`Fill form tool is not supported for Playwright MCP target yet`);
 		} else {
 			throw new Error(`Unsupported MCP target: ${mcpTarget}`);

package/src/fastbrowser_mcp/libs/playwright_a11y_helper.ts

@@ -115,7 +115,39 @@ export class PlaywrightA11yConverter {
 			stack.push(node);
 		}
 
-		return allNodes.map((node) => PlaywrightA11yConverter._stringifyNode(node)).join('\n');
+		// Playwright's `browser_snapshot` response often interleaves the a11y tree with preamble lines like
+		// `- Page URL: ...`, `- Page Title: ...`, `- Console: 193 errors, 0 warnings`, plus trailing entries
+		// like `- New`. Each of those parses as a spurious top-level (indent=0) node. Downstream,
+		// `A11yParse.A11yTree.parse` silently overwrites `root` for every indent-0 line and returns only the
+		// LAST top-level subtree — so the real a11y page tree (usually a large `generic [active]` subtree
+		// in the middle) gets discarded and queries return zero hits even though the data is in the text.
+		// Pick the largest top-level subtree, which is reliably the actual page tree since the metadata
+		// subtrees are tiny (0–1 nodes).
+		const primary = PlaywrightA11yConverter._pickPrimarySubtree(allNodes);
+		return primary.map((node) => PlaywrightA11yConverter._stringifyNode(node)).join('\n');
+	}
+
+	private static _pickPrimarySubtree(allNodes: EmittedNode[]): EmittedNode[] {
+		if (allNodes.length === 0) return allNodes;
+
+		const topLevelIndices: number[] = [];
+		for (let i = 0; i < allNodes.length; i++) {
+			if (allNodes[i].indent === 0) topLevelIndices.push(i);
+		}
+		if (topLevelIndices.length <= 1) return allNodes;
+
+		let bestStart = topLevelIndices[0];
+		let bestSize = 0;
+		for (let k = 0; k < topLevelIndices.length; k++) {
+			const start = topLevelIndices[k];
+			const end = k + 1 < topLevelIndices.length ? topLevelIndices[k + 1] : allNodes.length;
+			const size = end - start;
+			if (size > bestSize) {
+				bestSize = size;
+				bestStart = start;
+			}
+		}
+		return allNodes.slice(bestStart, bestStart + bestSize);
 	}
 
 	///////////////////////////////////////////////////////////////////////////////