@wordbricks/playwright-mcp 0.1.22 → 0.1.24

package/lib/tools/networkSearch.js

@@ -1,278 +0,0 @@
-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

@@ -1,41 +0,0 @@
-/**
- * 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];