@wordbricks/playwright-mcp 0.1.25 → 0.1.27

package/lib/tools/networkSearch/bodySearch.js

@@ -0,0 +1,161 @@
+import { withTimeout } from "../../utils/withTimeout.js";
+import { highlightMatch } from "./helpers.js";
+import { searchInHtml } from "./searchHtml.js";
+const CONTEXT_LENGTH_BODY = 400;
+const CONTEXT_LENGTH_DEFAULT = 300;
+const MAX_SEARCH_DEPTH = 20;
+export const searchInObject = (obj, keyword, path, matches, source, depth = 0) => {
+    if (depth > MAX_SEARCH_DEPTH || !obj || typeof obj !== "object")
+        return;
+    for (const key in obj) {
+        const newPath = path ? `${path}.${key}` : key;
+        const value = obj[key];
+        if (key.toLowerCase().includes(keyword)) {
+            const highlightedKey = highlightMatch(key, keyword, CONTEXT_LENGTH_DEFAULT);
+            const valueContext = typeof value === "object" && value !== null
+                ? truncateJsonPreview(value)
+                : truncateStringPreview(String(value));
+            matches.push({
+                path: newPath,
+                value: typeof value === "object" && value !== null
+                    ? JSON.stringify(value)
+                    : String(value),
+                context: `${highlightedKey}: ${valueContext}`,
+                source,
+            });
+        }
+        if (typeof value === "string" && value.toLowerCase().includes(keyword)) {
+            matches.push({
+                path: newPath,
+                value: value,
+                context: `${key}: ${highlightMatch(value, keyword, CONTEXT_LENGTH_DEFAULT)}`,
+                source,
+            });
+        }
+        else if (typeof value === "number" && String(value).includes(keyword)) {
+            const valueStr = String(value);
+            matches.push({
+                path: newPath,
+                value: valueStr,
+                context: `${key}: ${highlightMatch(valueStr, keyword, CONTEXT_LENGTH_DEFAULT)}`,
+                source,
+            });
+        }
+        if (typeof value === "object" && value !== null)
+            searchInObject(value, keyword, newPath, matches, source, depth + 1);
+    }
+};
+const truncateStringPreview = (text) => text.length > CONTEXT_LENGTH_DEFAULT
+    ? text.slice(0, CONTEXT_LENGTH_DEFAULT) + "..."
+    : text;
+const truncateJsonPreview = (obj) => {
+    try {
+        return JSON.stringify(obj).slice(0, CONTEXT_LENGTH_BODY) + "...";
+    }
+    catch {
+        return "[Object]";
+    }
+};
+export const searchInRequestBody = (request, keyword, matches) => {
+    const body = request.postData();
+    if (!body || !body.toLowerCase().includes(keyword))
+        return;
+    const requestContentType = request.headers()["content-type"] || "";
+    let handled = false;
+    if (requestContentType.includes("application/json") ||
+        body.trim().startsWith("{") ||
+        body.trim().startsWith("[")) {
+        try {
+            const parsed = JSON.parse(body);
+            searchInObject(parsed, keyword, "request.body", matches, "requestBody");
+            handled = true;
+        }
+        catch { }
+    }
+    if (!handled &&
+        (requestContentType.includes("text/html") || body.trim().startsWith("<"))) {
+        searchInHtml(body, keyword, "request.body", matches, "requestBody");
+        handled = true;
+    }
+    if (!handled &&
+        requestContentType.includes("application/x-www-form-urlencoded")) {
+        try {
+            const sp = new URLSearchParams(body);
+            for (const [k, v] of sp.entries()) {
+                const vStr = v || "";
+                if (!vStr.toLowerCase().includes(keyword))
+                    continue;
+                const trimmed = vStr.trim();
+                let parsedOk = false;
+                if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        searchInObject(parsed, keyword, `request.body.form.${k}`, matches, "requestBody");
+                        parsedOk = true;
+                    }
+                    catch { }
+                }
+                if (!parsedOk) {
+                    matches.push({
+                        path: `request.body.form.${k}`,
+                        value: vStr,
+                        context: `${k}=${highlightMatch(vStr, keyword, CONTEXT_LENGTH_DEFAULT)}`,
+                        source: "requestBody",
+                    });
+                }
+            }
+            handled = true;
+        }
+        catch { }
+    }
+    if (!handled) {
+        matches.push({
+            path: "request.body",
+            value: body,
+            context: highlightMatch(body, keyword, CONTEXT_LENGTH_BODY),
+            source: "requestBody",
+        });
+    }
+};
+export const searchInResponseBody = async (response, keyword, matches) => {
+    const contentTypeHeader = response.headers()["content-type"] || "";
+    if (!(contentTypeHeader.startsWith("text/") ||
+        contentTypeHeader.includes("application/json") ||
+        contentTypeHeader.includes("application/xml")))
+        return;
+    try {
+        const responseBody = await withTimeout(response.text(), 2000);
+        if (!responseBody || !responseBody.toLowerCase().includes(keyword))
+            return;
+        let handled = false;
+        const trimmed = responseBody.trimStart();
+        const xssiPrefix = ")]}'";
+        const hasXssi = trimmed.startsWith(xssiPrefix);
+        const jsonCandidate = hasXssi ? trimmed.slice(xssiPrefix.length) : trimmed;
+        if (contentTypeHeader.includes("application/json") ||
+            jsonCandidate.startsWith("{") ||
+            jsonCandidate.startsWith("[")) {
+            try {
+                const parsed = JSON.parse(jsonCandidate);
+                searchInObject(parsed, keyword, "response.body", matches, "responseBody");
+                handled = true;
+            }
+            catch { }
+        }
+        if (!handled &&
+            (contentTypeHeader.includes("text/html") ||
+                responseBody.trim().startsWith("<"))) {
+            searchInHtml(responseBody, keyword, "response.body", matches, "responseBody");
+            handled = true;
+        }
+        if (!handled) {
+            matches.push({
+                path: "response.body",
+                value: responseBody,
+                context: highlightMatch(responseBody, keyword, CONTEXT_LENGTH_BODY),
+                source: "responseBody",
+            });
+        }
+    }
+    catch { }
+};

package/lib/tools/networkSearch/grouping.js

@@ -0,0 +1,37 @@
+export const normalizePath = (path) => {
+    if (path.includes(" > "))
+        return path.replace(/:nth-child\(\d+\)/g, ":nth-child(*)");
+    return path.replace(/\.(?:\d+)(?=\.|$)/g, ".*");
+};
+export const getDepth = (path) => {
+    const separators = path.match(/\.|>/g) || [];
+    return separators.length;
+};
+export const mergeGroupedMatches = (a, b) => {
+    const map = new Map();
+    for (const g of a)
+        map.set(g.normalized, {
+            normalized: g.normalized,
+            count: g.count,
+            examples: g.examples.slice(0, 3),
+        });
+    for (const g of b) {
+        const existing = map.get(g.normalized);
+        if (existing) {
+            existing.count += g.count;
+            for (const e of g.examples) {
+                if (existing.examples.length < 3 &&
+                    !existing.examples.some((x) => x.context === e.context))
+                    existing.examples.push(e);
+            }
+        }
+        else {
+            map.set(g.normalized, {
+                normalized: g.normalized,
+                count: g.count,
+                examples: g.examples.slice(0, 3),
+            });
+        }
+    }
+    return Array.from(map.values());
+};

package/lib/tools/networkSearch/helpers.js

@@ -0,0 +1,32 @@
+import { truncateStringTo } from "../../utils/truncate.js";
+export const parseKeywordParams = (keyword) => {
+    const out = [];
+    try {
+        const sp = new URLSearchParams(keyword);
+        sp.forEach((value, key) => {
+            if (key)
+                out.push({ name: key, value });
+        });
+    }
+    catch { }
+    return out;
+};
+export const highlightMatch = (text, keyword, maxLength = 50) => {
+    const lowerText = text.toLowerCase();
+    const index = lowerText.indexOf(keyword);
+    if (index === -1)
+        return truncateStringTo(text, maxLength).text;
+    const contextBefore = Math.floor((maxLength - keyword.length) / 2);
+    const contextAfter = maxLength - keyword.length - contextBefore;
+    const start = Math.max(0, index - contextBefore);
+    const end = Math.min(text.length, index + keyword.length + contextAfter);
+    let result = "";
+    if (start > 0)
+        result += "...";
+    result += text.substring(start, index);
+    result += text.substring(index, index + keyword.length);
+    result += text.substring(index + keyword.length, end);
+    if (end < text.length)
+        result += "...";
+    return result;
+};

package/lib/tools/networkSearch/searchHtml.js

@@ -0,0 +1,76 @@
+import * as cheerio from "cheerio";
+import { highlightMatch } from "./helpers.js";
+export const getElementPath = ($el) => {
+    const path = [];
+    let current = $el;
+    while (current.length &&
+        current[0].type === "tag" &&
+        current[0].name !== "html") {
+        let selector = current[0].name.toLowerCase();
+        const id = current.attr("id");
+        if (id) {
+            selector += `#${id}`;
+            path.unshift(selector);
+            break;
+        }
+        const classes = current.attr("class");
+        if (classes)
+            selector += `.${classes.trim().split(/\s+/).join(".")}`;
+        const tagName = current[0].type === "tag" ? current[0].name : "";
+        const siblings = current
+            .parent()
+            .children()
+            .filter((_, el) => el.type === "tag" && el.name === tagName);
+        if (siblings.length > 1) {
+            const index = siblings.index(current) + 1;
+            selector += `:nth-child(${index})`;
+        }
+        path.unshift(selector);
+        current = current.parent();
+    }
+    return path.join(" > ");
+};
+export const searchInHtml = (html, keyword, basePath, matches, source) => {
+    const $ = cheerio.load(html);
+    $("*")
+        .contents()
+        .each((_, node) => {
+        if (node.type === "text") {
+            const text = (node.data || "").trim();
+            if (text && text.toLowerCase().includes(keyword)) {
+                const parent = $(node).parent();
+                if (parent.length) {
+                    const elPath = getElementPath(parent);
+                    const path = elPath ? `${basePath} > ${elPath}` : basePath;
+                    matches.push({
+                        path,
+                        value: text,
+                        context: highlightMatch(text, keyword, 300),
+                        source,
+                    });
+                }
+            }
+        }
+    });
+    $("*").each((_, el) => {
+        if (el.type === "tag") {
+            const attrs = el.attribs;
+            if (attrs) {
+                Object.entries(attrs).forEach(([key, val]) => {
+                    if (typeof val === "string" && val.toLowerCase().includes(keyword)) {
+                        const elPath = getElementPath($(el));
+                        const path = elPath
+                            ? `${basePath} > ${elPath}@${key}`
+                            : `${basePath}@${key}`;
+                        matches.push({
+                            path,
+                            value: val,
+                            context: highlightMatch(val, keyword, 300),
+                            source,
+                        });
+                    }
+                });
+            }
+        }
+    });
+};

package/lib/tools/networkSearch/types.js

@@ -0,0 +1 @@
+export {};

package/lib/tools/networkSearch/urlSearch.js

@@ -0,0 +1,124 @@
+import { highlightMatch } from "./helpers.js";
+const CONTEXT_LENGTH_DEFAULT = 300;
+export const searchInUrls = (request, response, keyword, keywordParams, matches) => {
+    try {
+        const reqUrl = request.url();
+        const reqUrlLower = reqUrl.toLowerCase();
+        const keywordPathOnly = keyword.split("?")[0];
+        if (reqUrlLower.includes(keyword)) {
+            matches.push({
+                path: "request.url",
+                value: reqUrl,
+                context: `url: ${highlightMatch(reqUrl, keyword, CONTEXT_LENGTH_DEFAULT)}`,
+                source: "requestUrl",
+            });
+        }
+        else if (keywordPathOnly && reqUrlLower.includes(keywordPathOnly)) {
+            matches.push({
+                path: "request.url",
+                value: reqUrl,
+                context: `url: ${highlightMatch(reqUrl, keywordPathOnly, CONTEXT_LENGTH_DEFAULT)}`,
+                source: "requestUrl",
+            });
+        }
+        else {
+            try {
+                const u = new URL(reqUrl);
+                const pathnameLower = u.pathname.toLowerCase();
+                if (pathnameLower.includes(keyword) ||
+                    (keywordPathOnly && pathnameLower.includes(keywordPathOnly)))
+                    matches.push({
+                        path: "request.url",
+                        value: reqUrl,
+                        context: `url: ${highlightMatch(reqUrl, keywordPathOnly || keyword, CONTEXT_LENGTH_DEFAULT)}`,
+                        source: "requestUrl",
+                    });
+            }
+            catch { }
+        }
+        if (keywordParams.length) {
+            try {
+                const u = new URL(reqUrl);
+                for (const { name, value } of keywordParams) {
+                    if (!name)
+                        continue;
+                    const pageVal = u.searchParams.get(name);
+                    if (!pageVal)
+                        continue;
+                    const valLower = (value || "").toLowerCase();
+                    if (!valLower)
+                        continue;
+                    const pageValLower = pageVal.toLowerCase();
+                    if (pageValLower.includes(valLower))
+                        matches.push({
+                            path: `request.url.query.${name}`,
+                            value: pageVal,
+                            context: `${name}=${highlightMatch(pageVal, value, CONTEXT_LENGTH_DEFAULT)}`,
+                            source: "requestUrl",
+                        });
+                }
+            }
+            catch { }
+        }
+        if (response) {
+            const resUrl = response.url();
+            const resUrlLower = resUrl.toLowerCase();
+            if (resUrlLower.includes(keyword)) {
+                matches.push({
+                    path: "response.url",
+                    value: resUrl,
+                    context: `url: ${highlightMatch(resUrl, keyword, CONTEXT_LENGTH_DEFAULT)}`,
+                    source: "responseUrl",
+                });
+            }
+            else if (keywordPathOnly && resUrlLower.includes(keywordPathOnly)) {
+                matches.push({
+                    path: "response.url",
+                    value: resUrl,
+                    context: `url: ${highlightMatch(resUrl, keywordPathOnly, CONTEXT_LENGTH_DEFAULT)}`,
+                    source: "responseUrl",
+                });
+            }
+            else {
+                try {
+                    const u2 = new URL(resUrl);
+                    const pathnameLower2 = u2.pathname.toLowerCase();
+                    if (pathnameLower2.includes(keyword) ||
+                        (keywordPathOnly && pathnameLower2.includes(keywordPathOnly)))
+                        matches.push({
+                            path: "response.url",
+                            value: resUrl,
+                            context: `url: ${highlightMatch(resUrl, keywordPathOnly || keyword, CONTEXT_LENGTH_DEFAULT)}`,
+                            source: "responseUrl",
+                        });
+                }
+                catch { }
+            }
+            if (keywordParams.length) {
+                try {
+                    const u2 = new URL(resUrl);
+                    for (const { name, value } of keywordParams) {
+                        if (!name)
+                            continue;
+                        const pageVal = u2.searchParams.get(name);
+                        if (!pageVal)
+                            continue;
+                        const valLower = (value || "").toLowerCase();
+                        if (!valLower)
+                            continue;
+                        const pageValLower = pageVal.toLowerCase();
+                        if (pageValLower.includes(valLower))
+                            matches.push({
+                                path: `response.url.query.${name}`,
+                                value: pageVal,
+                                context: `${name}=${highlightMatch(pageVal, value, CONTEXT_LENGTH_DEFAULT)}`,
+                                source: "responseUrl",
+                            });
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+};