@wordbricks/playwright-mcp 0.1.22 → 0.1.24

package/lib/tools/networkSearch/bodySearch.js

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

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

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

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

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

package/lib/tools/networkSearch/urlSearch.js

@@ -1,124 +0,0 @@
-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 { }
-};