fastbrowser_cli 1.0.35 → 1.0.39

package/src/contribs/twitter_cli/src/libs/twitter_thread_helper.ts

@@ -0,0 +1,240 @@
+// npm imports
+import { A11yQuery, A11yTree, AxNode } from 'a11y_parse';
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+const TIME_OF_DAY_REGEXP = /^\d{1,2}:\d{2}\s*(AM|PM)$/i;
+const FULL_DATE_REGEXP = /^([A-Za-z]+)\s+(\d{1,2})(?:,\s*(\d{4}))?$/;
+const WEEKDAYS: Record<string, number> = {
+	Sunday: 0, Monday: 1, Tuesday: 2, Wednesday: 3,
+	Thursday: 4, Friday: 5, Saturday: 6,
+};
+const MONTHS: Record<string, number> = {
+	Jan: 0, January: 0,
+	Feb: 1, February: 1,
+	Mar: 2, March: 2,
+	Apr: 3, April: 3,
+	May: 4,
+	Jun: 5, June: 5,
+	Jul: 6, July: 6,
+	Aug: 7, August: 7,
+	Sep: 8, September: 8,
+	Oct: 9, October: 9,
+	Nov: 10, November: 10,
+	Dec: 11, December: 11,
+};
+
+export class TwitterThreadHelper {
+	static async parseMessagesThread(
+		rawOutput: string,
+		otherHandle: string,
+		overrideYear?: number,
+	): Promise<string> {
+		const treeText = TwitterThreadHelper.extractAxTreeText(rawOutput);
+		if (treeText.length === 0) {
+			return '';
+		}
+		const root = A11yTree.parse(treeText);
+		const items = A11yQuery.querySelectorAll(root, 'main listitem');
+		const year = overrideYear !== undefined ? overrideYear : new Date().getFullYear();
+
+		const lines: string[] = [];
+		let currentDate: Date | null = null;
+		const pending: string[] = [];
+
+		for (const item of items) {
+			const valueGenerics = A11yQuery.querySelectorAll(item, 'generic[value]');
+			if (valueGenerics.length === 0) {
+				continue;
+			}
+
+			const dateMarker = TwitterThreadHelper.detectDateMarker(item, valueGenerics, year);
+			if (dateMarker !== null) {
+				currentDate = dateMarker;
+				continue;
+			}
+
+			const timestampNodes = TwitterThreadHelper.findTimestampNodes(valueGenerics);
+			if (timestampNodes.length === 0) {
+				const text = TwitterThreadHelper.collectText(valueGenerics, new Set());
+				if (text.length > 0) {
+					pending.push(text);
+				}
+				continue;
+			}
+
+			const time = TwitterThreadHelper.parseTimeOfDay(timestampNodes[0].attributes['value']);
+			if (time === null) {
+				continue;
+			}
+			if (currentDate === null) {
+				continue;
+			}
+
+			const sender = A11yQuery.querySelector(item, 'img') !== undefined
+				? 'You'
+				: otherHandle;
+
+			const timestampUids = new Set(timestampNodes.map((n) => n.uid));
+			const text = TwitterThreadHelper.collectText(valueGenerics, timestampUids);
+			const iso = TwitterThreadHelper.combineDateTime(currentDate, time);
+
+			for (const pendingText of pending) {
+				lines.push(`${iso}:${sender}:${pendingText}`);
+			}
+			pending.length = 0;
+
+			if (text.length === 0) {
+				continue;
+			}
+			lines.push(`${iso}:${sender}:${text}`);
+		}
+
+		return lines.join('\n');
+	}
+
+	private static collectText(valueGenerics: AxNode[], excludeUids: Set<string>): string {
+		const parts: string[] = [];
+		for (const node of valueGenerics) {
+			if (excludeUids.has(node.uid) === true) {
+				continue;
+			}
+			const value = node.attributes['value'];
+			if (value === undefined) {
+				continue;
+			}
+			const trimmed = value.trim();
+			if (trimmed.length === 0) {
+				continue;
+			}
+			parts.push(trimmed);
+		}
+		return parts.join(' ');
+	}
+
+	///////////////////////////////////////////////////////////////////////////////
+	///////////////////////////////////////////////////////////////////////////////
+	//
+	///////////////////////////////////////////////////////////////////////////////
+	///////////////////////////////////////////////////////////////////////////////
+
+	private static extractAxTreeText(rawOutput: string): string {
+		const lines: string[] = [];
+		for (const line of rawOutput.split('\n')) {
+			if (/^\s*uid=/.test(line) === true) {
+				lines.push(line);
+			}
+		}
+		return lines.join('\n');
+	}
+
+	private static findTimestampNodes(valueGenerics: AxNode[]): AxNode[] {
+		const result: AxNode[] = [];
+		for (const node of valueGenerics) {
+			const value = node.attributes['value'];
+			if (value === undefined) {
+				continue;
+			}
+			if (TIME_OF_DAY_REGEXP.test(value) === true) {
+				result.push(node);
+			}
+		}
+		return result;
+	}
+
+	private static detectDateMarker(
+		item: AxNode,
+		valueGenerics: AxNode[],
+		fallbackYear: number,
+	): Date | null {
+		const hasTimestamp = TwitterThreadHelper.findTimestampNodes(valueGenerics).length > 0;
+		if (hasTimestamp === true) {
+			return null;
+		}
+		if (A11yQuery.querySelector(item, 'img') !== undefined) {
+			return null;
+		}
+		for (const node of valueGenerics) {
+			const raw = node.attributes['value'];
+			if (raw === undefined) {
+				continue;
+			}
+			const value = raw.trim();
+			const parsed = TwitterThreadHelper.parseDateMarker(value, fallbackYear);
+			if (parsed !== null) {
+				return parsed;
+			}
+		}
+		return null;
+	}
+
+	private static parseDateMarker(value: string, fallbackYear: number): Date | null {
+		if (value === 'Today') {
+			const now = new Date();
+			return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+		}
+		if (value === 'Yesterday') {
+			const now = new Date();
+			const d = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+			d.setDate(d.getDate() - 1);
+			return d;
+		}
+		if (WEEKDAYS[value] !== undefined) {
+			const target = WEEKDAYS[value];
+			const now = new Date();
+			const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+			const diff = (today.getDay() - target + 7) % 7;
+			const days = diff === 0 ? 7 : diff;
+			today.setDate(today.getDate() - days);
+			return today;
+		}
+		const match = value.match(FULL_DATE_REGEXP);
+		if (match === null) {
+			return null;
+		}
+		const monthIndex = MONTHS[match[1]];
+		if (monthIndex === undefined) {
+			return null;
+		}
+		const day = parseInt(match[2], 10);
+		const explicitYear = match[3] !== undefined ? parseInt(match[3], 10) : null;
+		const year = explicitYear !== null ? explicitYear : fallbackYear;
+		const candidate = new Date(year, monthIndex, day);
+		if (explicitYear === null && candidate.getTime() > Date.now()) {
+			candidate.setFullYear(year - 1);
+		}
+		return candidate;
+	}
+
+	private static parseTimeOfDay(value: string | undefined): { hours: number; minutes: number } | null {
+		if (value === undefined) {
+			return null;
+		}
+		const match = value.trim().match(/^(\d{1,2}):(\d{2})\s*(AM|PM)$/i);
+		if (match === null) {
+			return null;
+		}
+		let hours = parseInt(match[1], 10);
+		const minutes = parseInt(match[2], 10);
+		const meridiem = match[3].toUpperCase();
+		if (meridiem === 'AM' && hours === 12) {
+			hours = 0;
+		} else if (meridiem === 'PM' && hours !== 12) {
+			hours += 12;
+		}
+		return { hours, minutes };
+	}
+
+	private static combineDateTime(date: Date, time: { hours: number; minutes: number }): string {
+		const yyyy = date.getFullYear().toString().padStart(4, '0');
+		const mm = (date.getMonth() + 1).toString().padStart(2, '0');
+		const dd = date.getDate().toString().padStart(2, '0');
+		const hh = time.hours.toString().padStart(2, '0');
+		const mi = time.minutes.toString().padStart(2, '0');
+		return `${yyyy}-${mm}-${dd}T${hh}:${mi}:00`;
+	}
+}

package/src/fastbrowser_cli/fastbrowser_cli.ts

@@ -252,6 +252,48 @@ async function main(): Promise<void> {
 			await MainHelper.runTool(cmd, 'list_pages', {});
 		});
 
+	program
+		.command('check')
+		.description('Verify the connection with the browser; restart the server once if it looks desynched')
+		.action(async (_opts, cmd: Command) => {
+			const serverUrl = MainHelper.getServerUrlFromCmd(cmd);
+			const mcpTarget = MainHelper.getMcpTargetFromCmd(cmd);
+
+			const hasPages = (response: { content: Array<{ text: string }> }): boolean => {
+				const joined = response.content.map((part) => part.text).join('\n');
+				const lines = joined.split('\n');
+				for (const line of lines) {
+					if (/^\s*\d+:/.test(line) === true) {
+						return true;
+					}
+				}
+				return false;
+			};
+
+			if (MainHelper.getAutostartFromCmd(cmd) === true) {
+				await ServerManager.ensureRunning(serverUrl, mcpTarget);
+			}
+
+			const firstResponse = await HttpClient.postTool(serverUrl, 'list_pages', {});
+			if (hasPages(firstResponse) === true) {
+				console.log('It is properly connected to the browser');
+				return;
+			}
+
+			console.log('Connection with the browser is desynched, relaunching the server');
+			await ServerManager.stop(serverUrl);
+			await ServerManager.start(serverUrl, mcpTarget);
+
+			const secondResponse = await HttpClient.postTool(serverUrl, 'list_pages', {});
+			if (hasPages(secondResponse) === true) {
+				console.log('It is properly connected to the browser');
+				return;
+			}
+
+			console.error('Connection with the browser is still broken after server restart');
+			process.exit(1);
+		});
+
 	program
 		.command('new_page')
 		.description('Open a new browser page')
@@ -343,6 +385,15 @@ async function main(): Promise<void> {
 			await MainHelper.runTool(cmd, 'press_keys', { keys: opts.keys });
 		});
 
+	program
+		.command('evaluate_script [file]')
+		.description('Evaluate a JavaScript function in the page context. Provide the function text inline via --script, as a [file] path, or piped on stdin. The function should return JSON-able data.')
+		.option('--script <script>', 'Inline JS function text (overrides [file] and stdin)')
+		.action(async (file: string | undefined, opts: { script?: string }, cmd: Command) => {
+			const functionTxt = await MainHelper.readBatchSource(file, opts.script);
+			await MainHelper.runTool(cmd, 'evaluate_script', { functionTxt });
+		});
+
 	program
 		.command('install [skill-folder]')
 		.description('Install all bundled skills into <skill-folder>/skills/ (default: .)')

package/src/fastbrowser_httpd/libs/tool-schemas.ts

@@ -61,6 +61,11 @@ export type PressKeysRequest = z.infer<typeof PressKeysRequestSchema>;
 export const TakeSnapshotRequestSchema = z.object({}).strict();
 export type TakeSnapshotRequest = z.infer<typeof TakeSnapshotRequestSchema>;
 
+export const EvaluateScriptRequestSchema = z.object({
+	functionTxt: z.string().describe('JS function text to evaluate in the page context. Should return JSON-able data.'),
+});
+export type EvaluateScriptRequest = z.infer<typeof EvaluateScriptRequestSchema>;
+
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 //	Uniform response — narrowed mirror of MCP's CallToolResult
@@ -104,4 +109,5 @@ export const TOOL_SCHEMAS: ToolSchemaEntry[] = [
 	{ routeName: 'query_selectors', mcpToolName: 'querySelectors', requestSchema: QuerySelectorRequestSchema },
 	{ routeName: 'press_keys', mcpToolName: 'pressKeys', requestSchema: PressKeysRequestSchema },
 	{ routeName: 'take_snapshot', mcpToolName: 'take_snapshot', requestSchema: TakeSnapshotRequestSchema },
+	{ routeName: 'evaluate_script', mcpToolName: 'evaluate_script', requestSchema: EvaluateScriptRequestSchema },
 ];

package/src/fastbrowser_mcp/fastbrowser_mcp.ts

@@ -504,7 +504,20 @@ class MainHelper {
 				const keysToSend: string[] = [];
 				const keysSplit = keys.split(',').map((key) => key.trim());
 				for (const key of keysSplit) {
-					const specialKeys = ['Tab', 'Enter', 'ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', 'Escape', 'Backspace', 'Delete'];
+					// from chatgpt
+					const specialKeys = [
+						// Control / navigation
+						'Enter', 'Tab', 'Escape', 'Backspace', 'Delete', 'Insert',
+
+						// Arrows
+						'ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight',
+
+						// Navigation keys
+						'Home', 'End', 'PageUp', 'PageDown',
+
+						// Function keys
+						'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10', 'F11', 'F12',
+					];
 					if (specialKeys.includes(key)) {
 						keysToSend.push(key);
 					} else {
@@ -514,7 +527,7 @@ class MainHelper {
 						}
 					}
 				}
-				console.error("Keys to send:", keysToSend);
+				// console.error("Keys to send:", keysToSend);
 				// chrome-devtools-mcp's 'press_key' tool accepts a single 'key' per call — loop through the sequence
 				for (const key of keysToSend) {
 					const toolConfig = await McpTargetHelper.targetToolPressKey(mcpTarget, key);
@@ -569,7 +582,7 @@ class MainHelper {
 
 				// log the events
 				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.click}: output:`);
-
+				logger.warn(`${outputText}`);
 				return {
 					content: [{ type: "text", text: outputText }],
 				};
@@ -641,6 +654,36 @@ class MainHelper {
 			}
 		);
 
+		///////////////////////////////////////////////////////////////////////////////
+		///////////////////////////////////////////////////////////////////////////////
+		//	
+		///////////////////////////////////////////////////////////////////////////////
+		///////////////////////////////////////////////////////////////////////////////
+
+		mcpServer.registerTool(
+			McpTargetHelper.EXTERNAL_TOOL_NAME.evaluateScript,
+			{
+				description: "Evaluate a JavaScript function in the context of the current page. The function should return JSON-able data.",
+				inputSchema: z.object({
+					functionTxt: z.string().describe("The JavaScript function to evaluate in the page context. Should return JSON-able data."),
+				}),
+			},
+			async ({ functionTxt }: { functionTxt: string }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.evaluateScript}: evaluating function: ${functionTxt}`);
+
+				const toolConfig = await McpTargetHelper.targetToolEvaluateScript(mcpTarget, functionTxt);
+				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
+				let outputText = await ResponseFormatter.formatEvaluateScript(mcpTarget, callToolResult);
+
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.evaluateScript}: output:`);
+				logger.warn(`${outputText}`);
+				return {
+					content: [{ type: "text", text: outputText }],
+				};
+			}
+		)
 		///////////////////////////////////////////////////////////////////////////////
 		///////////////////////////////////////////////////////////////////////////////
 		//	.get_current_datetime tool implementation

package/src/fastbrowser_mcp/libs/mcp_target_helper.ts

@@ -18,6 +18,7 @@ export class McpTargetHelper {
 		pressKeys: "pressKeys",
 		click: "click",
 		fillForm: "fill_form",
+		evaluateScript: "evaluate_script",
 		getCurrentDateTime: "get_current_datetime",
 	}
 
@@ -212,4 +213,14 @@ export class McpTargetHelper {
 			throw new Error(`Unsupported MCP target: ${mcpTarget}`);
 		}
 	}
+
+	static async targetToolEvaluateScript(mcpTarget: FastBrowserMcpTarget, functionText: string): Promise<TargetToolConfig> {
+		if (mcpTarget === 'chrome_devtools') {
+			return { toolName: 'evaluate_script', toolArgs: { function: functionText } };
+		} else if (mcpTarget === 'playwright') {
+			return { toolName: 'browser_evaluate', toolArgs: { function: functionText } };
+		} else {
+			throw new Error(`Unsupported MCP target: ${mcpTarget}`);
+		}
+	}
 }

package/src/fastbrowser_mcp/libs/response_formatter.ts

@@ -211,4 +211,33 @@ export class ResponseFormatter {
 			throw new Error(`Unsupported MCP target: ${mcpTarget}`);
 		}
 	}
+
+	static async formatEvaluateScript(mcpTarget: FastBrowserMcpTarget, callToolResult: CallToolResult): Promise<string> {
+		const resultContent = callToolResult.content[0]
+		if (resultContent.type !== "text") throw new Error("Unexpected content type");
+		const resultText: string = resultContent.text
+
+		// ### Result
+		// undefined
+		// ### Ran Playwright code
+		// ```js
+		// await page.evaluate('() => {\n    const workspace = document.querySelector(\'main#workspace\');\n    if (workspace === null) {\n        throw new Error(\'Workspace element not found\');\n    }\n    const tryCount = 6;\n    const delayMs = 500;\n    (async () => {\n        for (let i = 0; i < tryCount; i++) {\n            workspace.scrollBy({\n                top: 600000,\n                behavior: \'smooth\'\n            });\n            await new Promise(resolve => setTimeout(resolve, delayMs));\n        }\n    })();\n}');
+		// ```
+		// ### Events
+		// - New console entries: .playwright-mcp/console-2026-05-04T05-43-55-775Z.log#L3959-L4058
+
+		// Target format example:
+		// Successfully clicked on the element
+
+		if (mcpTarget === 'chrome_devtools') {
+			// EXAMPLE:
+			// Successfully clicked on the element
+
+			return resultText
+		} else if (mcpTarget === 'playwright') {
+			return resultText
+		} else {
+			throw new Error(`Unsupported MCP target: ${mcpTarget}`);
+		}
+	}
 }

package/src/shared/fastbrowser_helper.ts

@@ -0,0 +1,49 @@
+import { execSync } from 'node:child_process';
+
+const __dirname = new URL('.', import.meta.url).pathname;
+
+export class FastBrowserHelper {
+	static async run(command: string): Promise<string> {
+		// const fullCommand = `npx fastbrowser_cli ${command}`;
+		const fullCommand = `npx tsx ${__dirname}../../src/fastbrowser_cli/fastbrowser_cli.ts  ${command}`;
+		console.error(`Running command: ${fullCommand}`);
+		return execSync(fullCommand, { encoding: 'utf8' });
+	}
+
+	static async navigatePage(url: string): Promise<void> {
+		await FastBrowserHelper.run(`navigate_page --url '${url}'`);
+	}
+
+	static async fillForm(selector: string, value: string): Promise<void> {
+		await FastBrowserHelper.run(`fill_form --selector '${selector}' --value '${value}'`);
+	}
+
+	static async pressKeys(keys: string): Promise<void> {
+		await FastBrowserHelper.run(`press_keys --keys '${keys}'`);
+	}
+
+	static async click(selector: string): Promise<void> {
+		await FastBrowserHelper.run(`click -s '${selector}'`);
+	}
+
+	static async querySelectorsAll(selector: string, limit: number): Promise<string> {
+		return await FastBrowserHelper.run(`query_selectors --all --selector '${selector}' --limit ${limit}`);
+	}
+
+	static async querySelectorsAllWithChildren(selector: string, limit: number): Promise<string> {
+		return await FastBrowserHelper.run(`query_selectors --all --selector '${selector}' --limit ${limit} --with-ancestors --with-children`);
+	}
+
+	static async takeSnapshot(): Promise<string> {
+		return await FastBrowserHelper.run('take_snapshot');
+	}
+
+	static async querySelectors(selector: string, withAncestors = true): Promise<string> {
+		const flag = withAncestors === false ? ' --no-with-ancestors' : '';
+		return await FastBrowserHelper.run(`query_selectors --selector '${selector}'${flag}`);
+	}
+
+	static async evaluateScript(functionText: string): Promise<string> {
+		return await FastBrowserHelper.run(`evaluate_script --script "${functionText}"`);
+	}
+}

package/tsconfig.json

@@ -19,7 +19,7 @@
     "include": [
         "src/**/*",
         "tests/**/*",
-        "examples/**/*",
+        "examples/**/*"
     ],
     "exclude": [
         "node_modules",

package/examples/linkedin_cli/linked_dm.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-
-# Restart the server to clear any previous state
-NODE_OPTIONS='' NPM_CONFIG_LOGLEVEL=silent npm run dev:cli -- server restart  
-
-# Goto linkedin messaging page using the CLI commands below:
-NODE_OPTIONS='' NPM_CONFIG_LOGLEVEL=silent npm run dev:cli -- navigate_page --url https://www.linkedin.com/messaging/
-
-# list all the threads conversations in the left sidebar
-NODE_OPTIONS='' NPM_CONFIG_LOGLEVEL=silent npm run dev:cli -- query_selectors -s 'list[name="Conversation List"] > listitem heading' -a
-
-# Select the conversation with Eric Defiez
-NODE_OPTIONS='' NPM_CONFIG_LOGLEVEL=silent npm run dev:cli -- click -s 'list[name="Conversation List"] > listitem heading[name^="Eric Defiez"]' 
-
-# Fill the message content
-NODE_OPTIONS='' NPM_CONFIG_LOGLEVEL=silent npm run dev:cli -- fill_form -s 'textbox[name^="Write"]' -v "Hello"
-
-# Click the "Send" button to send the message
-NODE_OPTIONS='' NPM_CONFIG_LOGLEVEL=silent npm run dev:cli -- click -s 'button[name^="Send"]'

package/examples/mcp_client_playwright.ts

@@ -1,34 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-
-async function main() {
-	// Note: the PLAYWRIGHT_MCP_EXTENSION_TOKEN environment variable is required to authenticate with the Playwright MCP extension.
-	const client = new Client({
-		name: 'foobar',
-		version: '0.1.0',
-	});
-
-	const transport = new StdioClientTransport({
-		command: 'npx',
-		args: ["@playwright/mcp", "--extension"],
-		env: {
-			PLAYWRIGHT_MCP_EXTENSION_TOKEN: 'd-dwfALmOesZLoS7i-ia8Wf7TWrHtlRMHuVCqAUuiKU' 
-		},
-	});
-	console.log("Connecting to MCP server...");
-	await client.connect(transport);
-	console.log("Connected!");
-
-
-	const listToolsResult = await client.listTools()
-	console.log("Available tools:", listToolsResult.tools.map(tool => tool.name));
-
-	// const toolResult = await client.callTool({
-	// 	name: '', 
-	// 	arguments: args 
-	// })
-
-	await client.close();
-}
-
-void main();