@wordbricks/playwright-mcp 0.1.25 → 0.1.26

package/lib/tools/networkSearch.js

@@ -0,0 +1,278 @@
+import { z } from "zod";
+import { normalizeUrlForGrouping } from "../hooks/networkFilters.js";
+import { getNetworkEventEntry } from "../hooks/networkSetup.js";
+import { listNetworkEvents } from "../hooks/networkTrackingHook.js";
+import { formatNetworkSummaryLine } from "../utils/networkFormat.js";
+import { toJsonPathNormalized, truncateStringTo } from "../utils/truncate.js";
+import { searchInRequestBody, searchInResponseBody, } from "./networkSearch/bodySearch.js";
+import { getDepth, mergeGroupedMatches, normalizePath, } from "./networkSearch/grouping.js";
+import { highlightMatch, parseKeywordParams } from "./networkSearch/helpers.js";
+import { searchInUrls } from "./networkSearch/urlSearch.js";
+import { defineTool } from "./tool.js";
+const MAX_SEARCH_RESULTS = 10;
+const MAX_GROUPS_TO_SHOW = 3;
+const networkSearchSchema = z.object({
+    keyword: z
+        .string()
+        .describe("Keyword or phrase; avoid generic words—specific terms reduce noise and improve precision."),
+});
+const createSourceCounts = () => ({
+    requestUrl: 0,
+    requestBody: 0,
+    responseUrl: 0,
+    responseBody: 0,
+    responseHeaders: 0,
+});
+const accumulateSourceCounts = (records) => {
+    const counts = createSourceCounts();
+    for (const record of records)
+        counts[record.source] += 1;
+    return counts;
+};
+const cloneSourceCounts = (counts) => ({
+    requestUrl: counts.requestUrl,
+    requestBody: counts.requestBody,
+    responseUrl: counts.responseUrl,
+    responseBody: counts.responseBody,
+    responseHeaders: counts.responseHeaders,
+});
+const computeEventScore = (match) => {
+    const ageMs = Math.max(0, Date.now() - match.timestamp);
+    const recencyWindowMs = 10 * 60 * 1000;
+    const recencyBoost = 1 - Math.min(ageMs / recencyWindowMs, 1);
+    const base = match.totalMatches;
+    const responseBonus = match.sourceCounts.responseBody * 2;
+    const requestBonus = match.sourceCounts.requestBody;
+    const urlBonus = (match.sourceCounts.requestUrl + match.sourceCounts.responseUrl) * 0.25;
+    const headerBonus = match.sourceCounts.responseHeaders;
+    return (base + responseBonus + requestBonus + urlBonus + headerBonus + recencyBoost);
+};
+const formatGroupPath = (group) => {
+    const normalized = group.normalized;
+    const jsonPath = toJsonPathNormalized(normalized);
+    if (jsonPath)
+        return `json: ${jsonPath.jsonPath}`;
+    if (!normalized.includes(" > "))
+        return normalized;
+    const withoutWildcard = normalized.replace(/:nth-child\(\*\)/g, "");
+    const trimmedPrefix = withoutWildcard.startsWith("response.body")
+        ? withoutWildcard.slice("response.body".length).trim()
+        : withoutWildcard.startsWith("request.body")
+            ? withoutWildcard.slice("request.body".length).trim()
+            : withoutWildcard;
+    const noLeadingArrow = trimmedPrefix.startsWith(">")
+        ? trimmedPrefix.slice(1).trim()
+        : trimmedPrefix;
+    return `css: ${noLeadingArrow}`;
+};
+const extractExamples = (group) => {
+    const items = [];
+    for (const example of group.examples) {
+        const raw = example.value ?? example.context;
+        if (!raw)
+            continue;
+        const trimmed = raw.trim();
+        const base = trimmed.length > 0 ? trimmed : raw;
+        const { text } = truncateStringTo(base, 160);
+        if (!items.includes(text))
+            items.push(text);
+    }
+    return items;
+};
+const searchInResponseSetCookies = async (response, keyword, matches) => {
+    const cookies = await response.headerValues("set-cookie").catch(() => []);
+    if (!cookies.length)
+        return;
+    for (const [index, cookie] of cookies.entries()) {
+        if (!cookie.toLowerCase().includes(keyword))
+            continue;
+        matches.push({
+            path: `response.headers.set-cookie[${index}]`,
+            value: cookie,
+            context: highlightMatch(cookie, keyword, 120),
+            source: "responseHeaders",
+        });
+    }
+};
+const networkSearch = defineTool({
+    capability: "core",
+    schema: {
+        name: "browser_network_search",
+        title: "Search network requests",
+        description: "Search for keywords in network request/response bodies and URLs",
+        inputSchema: networkSearchSchema,
+        type: "readOnly",
+    },
+    handle: async (context, params, response) => {
+        await context.ensureTab();
+        try {
+            const keyword = params.keyword?.toLowerCase();
+            if (!keyword) {
+                response.addResult("keyword parameter is required");
+                return;
+            }
+            const events = listNetworkEvents(context);
+            const keywordParams = parseKeywordParams(params.keyword);
+            const searchMatches = [];
+            for (const ev of events) {
+                const entry = getNetworkEventEntry(context, ev.id);
+                if (!entry)
+                    continue;
+                const request = entry.request;
+                const resp = entry.response ?? null;
+                const matches = [];
+                searchInUrls(request, resp, keyword, keywordParams, matches);
+                searchInRequestBody(request, keyword, matches);
+                if (resp) {
+                    await searchInResponseBody(resp, keyword, matches);
+                    await searchInResponseSetCookies(resp, keyword, matches);
+                }
+                if (matches.length > 0) {
+                    const groupMap = new Map();
+                    for (const m of matches) {
+                        const normalized = normalizePath(m.path);
+                        let group = groupMap.get(normalized);
+                        if (!group) {
+                            group = { normalized, count: 0, examples: [] };
+                            groupMap.set(normalized, group);
+                        }
+                        group.count++;
+                        if (group.examples.length < 3) {
+                            const example = {
+                                context: m.context,
+                                value: m.value,
+                                originalPath: m.path !== normalized ? m.path : undefined,
+                            };
+                            if (!group.examples.some((e) => e.context === example.context))
+                                group.examples.push(example);
+                        }
+                    }
+                    const groups = Array.from(groupMap.values()).sort((a, b) => b.count - a.count ||
+                        getDepth(b.normalized) - getDepth(a.normalized));
+                    const totalMatches = matches.length;
+                    const sourceCounts = accumulateSourceCounts(matches);
+                    searchMatches.push({
+                        requestId: ev.id,
+                        timestamp: ev.timestamp,
+                        count: 1,
+                        groups,
+                        totalMatches,
+                        sourceCounts,
+                        request,
+                        response: resp,
+                    });
+                }
+            }
+            if (searchMatches.length === 0) {
+                response.addResult(`No network requests found containing keyword: "${params.keyword}"`);
+                return;
+            }
+            const aggMap = new Map();
+            for (const m of searchMatches) {
+                const key = `${m.request.method().toUpperCase()} ${normalizeUrlForGrouping(m.request.url())}`;
+                const existing = aggMap.get(key);
+                const eventScore = computeEventScore(m);
+                if (!existing) {
+                    aggMap.set(key, {
+                        key,
+                        request: m.request,
+                        response: m.response,
+                        ids: [m.requestId],
+                        count: m.count,
+                        totalMatches: m.totalMatches,
+                        groups: [...m.groups],
+                        primaryGroups: m.groups,
+                        primaryEventId: m.requestId,
+                        primaryTimestamp: m.timestamp,
+                        primarySourceCounts: cloneSourceCounts(m.sourceCounts),
+                        primaryMatches: m.totalMatches,
+                        primaryScore: eventScore,
+                    });
+                    continue;
+                }
+                existing.ids.push(m.requestId);
+                existing.count += m.count;
+                existing.totalMatches += m.totalMatches;
+                existing.groups = mergeGroupedMatches(existing.groups, m.groups);
+                if (!existing.response && m.response)
+                    existing.response = m.response;
+                const replacePrimary = eventScore > existing.primaryScore ||
+                    (eventScore === existing.primaryScore &&
+                        m.timestamp > existing.primaryTimestamp);
+                if (!replacePrimary)
+                    continue;
+                existing.request = m.request;
+                existing.response = m.response;
+                existing.primaryGroups = m.groups;
+                existing.primaryEventId = m.requestId;
+                existing.primaryTimestamp = m.timestamp;
+                existing.primarySourceCounts = cloneSourceCounts(m.sourceCounts);
+                existing.primaryMatches = m.totalMatches;
+                existing.primaryScore = eventScore;
+            }
+            const aggregatedMatches = Array.from(aggMap.values()).sort((a, b) => {
+                if (a.primaryScore !== b.primaryScore)
+                    return b.primaryScore - a.primaryScore;
+                if (a.primaryMatches !== b.primaryMatches)
+                    return b.primaryMatches - a.primaryMatches;
+                return b.primaryTimestamp - a.primaryTimestamp;
+            });
+            const topMatches = aggregatedMatches.slice(0, MAX_SEARCH_RESULTS);
+            const structured = {
+                keyword: params.keyword,
+                requests: topMatches.map((m) => {
+                    const method = m.request.method().toUpperCase();
+                    const url = m.request.url();
+                    // Normalize URL for grouping only; not returned in output
+                    const status = m.response ? m.response.status() : undefined;
+                    const queryKeys = (() => {
+                        try {
+                            const u = new URL(url);
+                            const keys = new Set();
+                            u.searchParams.forEach((_, k) => {
+                                if (k)
+                                    keys.add(k);
+                            });
+                            return Array.from(keys);
+                        }
+                        catch {
+                            return [];
+                        }
+                    })();
+                    const primaryGroups = m.primaryGroups
+                        .slice()
+                        .sort((a, b) => b.count - a.count ||
+                        getDepth(b.normalized) - getDepth(a.normalized))
+                        .slice(0, MAX_GROUPS_TO_SHOW);
+                    const paths = primaryGroups.map((group) => ({
+                        path: formatGroupPath(group),
+                        examples: extractExamples(group),
+                    }));
+                    const sourceCounts = cloneSourceCounts(m.primarySourceCounts);
+                    const score = Number(m.primaryScore.toFixed(2));
+                    return {
+                        summary: formatNetworkSummaryLine({
+                            method,
+                            url,
+                            status: status || 0,
+                            statusText: m.response?.statusText(),
+                            postData: m.request.postData(),
+                            headers: {},
+                        }),
+                        primaryEventId: m.primaryEventId,
+                        eventIds: m.ids.slice(0, 5),
+                        score,
+                        sourceCounts,
+                        params: queryKeys.slice(0, 6),
+                        paths,
+                    };
+                }),
+            };
+            response.addResult(JSON.stringify(structured));
+        }
+        catch (error) {
+            response.addResult(`Failed to search network requests: ${error.message}`);
+        }
+    },
+});
+export default [networkSearch];

package/lib/tools/pdf.js

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from "zod";
+import * as javascript from "../utils/codegen.js";
+import { defineTabTool } from "./tool.js";
+const pdfSchema = z.object({
+    filename: z
+        .string()
+        .optional()
+        .describe("File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified."),
+});
+const pdf = defineTabTool({
+    capability: "pdf",
+    schema: {
+        name: "browser_pdf_save",
+        title: "Save as PDF",
+        description: "Save page as PDF",
+        inputSchema: pdfSchema,
+        type: "readOnly",
+    },
+    handle: async (tab, params, response) => {
+        const fileName = await tab.context.outputFile(params.filename ?? `page-${new Date().toISOString()}.pdf`);
+        response.addCode(`await page.pdf(${javascript.formatObject({ path: fileName })});`);
+        response.addResult(`Saved page as ${fileName}`);
+        await tab.page.pdf({ path: fileName });
+    },
+});
+export default [pdf];