@wordbricks/playwright-mcp 0.1.25 → 0.1.27

package/lib/utils/graphql.js

@@ -0,0 +1,269 @@
+import { filter, join, pipe } from "@fxts/core";
+const getString = (v) => typeof v === "string" ? v : undefined;
+const hasPersistedQuery = (v) => {
+    return isPlainObject(v) && "persistedQuery" in v;
+};
+const readGraphQLishBody = (v) => {
+    if (!isPlainObject(v))
+        return undefined;
+    const q = getString(v["query"]);
+    const variables = v["variables"];
+    const operationName = getString(v["operationName"]);
+    const hasPersisted = hasPersistedQuery(v["extensions"]);
+    if (!q && !hasPersisted && !operationName)
+        return undefined;
+    return { query: q, variables, operationName, hasPersisted };
+};
+export const isPlainObject = (value) => {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+};
+function getHeader(headers, name, altName) {
+    if (!headers)
+        return undefined;
+    const v1 = headers[name];
+    if (typeof v1 === "string")
+        return v1;
+    if (Array.isArray(v1))
+        return v1.join(", ");
+    if (altName) {
+        const v2 = headers[altName];
+        if (typeof v2 === "string")
+            return v2;
+        if (Array.isArray(v2))
+            return v2.join(", ");
+    }
+    return undefined;
+}
+export const safeJSONParse = (text) => {
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+const isOperationType = (s) => {
+    return s === "query" || s === "mutation" || s === "subscription";
+};
+const parseOperationFromQuery = (query) => {
+    if (!query)
+        return { type: "unknown" };
+    const trimmed = query.trim().replace(/^#.*$/gm, "").trim();
+    if (!trimmed)
+        return { type: "unknown" };
+    if (trimmed.startsWith("{"))
+        return { type: "query" };
+    const m = /^(query|mutation|subscription)\b\s*([A-Za-z_][A-Za-z0-9_]*)?/i.exec(trimmed);
+    if (m) {
+        const maybe = m[1].toLowerCase();
+        const type = isOperationType(maybe)
+            ? maybe
+            : "unknown";
+        const name = m[2] || undefined;
+        return { type, name };
+    }
+    return { type: "unknown" };
+};
+export const parseGraphQLRequestFromHttp = (method, url, headersIn, bodyText) => {
+    const contentType = getHeader(headersIn, "content-type", "Content-Type") || "";
+    const u = new URL(url, "http://dummy"); // base to satisfy URL if relative
+    let query;
+    let variables;
+    let operationName;
+    let isPersistedQuery = false;
+    if ((method || "GET").toUpperCase() === "GET") {
+        const params = u.searchParams;
+        const queryParam = params.get("query");
+        const opNameParam = params.get("operationName") ?? undefined;
+        const vars = params.get("variables");
+        const ext = params.get("extensions");
+        const extObj = ext ? safeJSONParse(ext) : undefined;
+        const hasPersisted = isPlainObject(extObj) && "persistedQuery" in extObj;
+        if (queryParam) {
+            // Only treat as GraphQL if the query actually looks like GraphQL
+            const parsedOp = parseOperationFromQuery(queryParam);
+            if (parsedOp.type !== "unknown") {
+                query = queryParam;
+                operationName = opNameParam;
+                if (vars)
+                    variables = safeJSONParse(vars);
+            }
+        }
+        else if (hasPersisted) {
+            // Accept persisted queries even without a `query` param
+            isPersistedQuery = true;
+            operationName = opNameParam;
+            if (vars)
+                variables = safeJSONParse(vars);
+        }
+    }
+    else {
+        // POST/others
+        if (contentType.includes("application/json") ||
+            contentType.includes("application/graphql") ||
+            contentType.includes("application/x-www-form-urlencoded") ||
+            typeof bodyText === "string") {
+            const bodyObj = safeJSONParse(bodyText || "");
+            const parsed = readGraphQLishBody(bodyObj);
+            if (parsed) {
+                if (parsed.query) {
+                    const parsedOp = parseOperationFromQuery(parsed.query);
+                    if (parsedOp.type !== "unknown") {
+                        query = parsed.query;
+                        variables = parsed.variables;
+                        operationName = parsed.operationName;
+                    }
+                }
+                else if (parsed.hasPersisted) {
+                    isPersistedQuery = true;
+                    variables = parsed.variables;
+                    operationName = parsed.operationName;
+                }
+            }
+        }
+    }
+    if (!query && !isPersistedQuery)
+        return undefined;
+    const { type: operationType, name } = parseOperationFromQuery(query);
+    if (operationName && !name) {
+        // Respect provided operationName when query is anonymous
+        return { operationType, operationName, query, variables, isPersistedQuery };
+    }
+    return {
+        operationType,
+        operationName: name ?? operationName,
+        query,
+        variables,
+        isPersistedQuery,
+    };
+};
+export const summarizeGraphQL = (parsed) => {
+    const type = parsed.operationType === "unknown" ? "operation" : parsed.operationType;
+    return pipe([parsed.operationName ? `${type} ${parsed.operationName}` : type], filter((v) => typeof v === "string"), join(" "));
+};
+export const extractGraphQLResponseInfo = (bodyText) => {
+    const json = safeJSONParse(bodyText || "");
+    if (!isPlainObject(json))
+        return undefined;
+    const errorsVal = json["errors"];
+    const dataVal = json["data"];
+    const hasGraphQLShape = Array.isArray(errorsVal) || isPlainObject(dataVal);
+    if (!hasGraphQLShape)
+        return undefined;
+    const errors = Array.isArray(errorsVal) ? errorsVal : [];
+    const dataKeys = isPlainObject(dataVal) ? Object.keys(dataVal) : [];
+    const topMessages = errors.slice(0, 3).map((e) => {
+        if (isPlainObject(e)) {
+            const m = e["message"];
+            if (typeof m === "string")
+                return m;
+        }
+        try {
+            return JSON.stringify(e);
+        }
+        catch {
+            return String(e);
+        }
+    });
+    return {
+        hasErrors: errors.length > 0,
+        errorCount: errors.length,
+        topMessages,
+        dataKeys,
+    };
+};
+/**
+ * Minify a GraphQL operation string by removing comments and unnecessary whitespace,
+ * while preserving string literals and required token separators.
+ */
+export const minifyGraphQLQuery = (input) => {
+    let out = "";
+    let i = 0;
+    const len = input.length;
+    let inString = null;
+    let escaped = false;
+    let pendingSpace = false;
+    const isIdent = (ch) => /[A-Za-z0-9_]/.test(ch);
+    const isWhitespace = (ch) => ch === " " || ch === "\n" || ch === "\r" || ch === "\t" || ch === "\f";
+    const isPunct = (ch) => "{}()[]:!@$,=|&.".includes(ch);
+    while (i < len) {
+        const ch = input[i];
+        if (inString) {
+            out += ch;
+            if (escaped)
+                escaped = false;
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === inString)
+                inString = null;
+            i++;
+            continue;
+        }
+        // Not inside string
+        if (ch === '"' || ch === "'") {
+            // flush pending space
+            if (pendingSpace) {
+                out += " ";
+                pendingSpace = false;
+            }
+            inString = ch;
+            out += ch;
+            i++;
+            continue;
+        }
+        // Line comment start (# ... end of line)
+        if (ch === "#") {
+            // Skip until end of line
+            while (i < len && input[i] !== "\n")
+                i++;
+            continue;
+        }
+        // Whitespace handling
+        if (isWhitespace(ch)) {
+            // Defer deciding about a space until we see the next significant char
+            pendingSpace = true;
+            i++;
+            continue;
+        }
+        // Punctuation: never needs surrounding spaces
+        if (isPunct(ch)) {
+            out += ch;
+            pendingSpace = false;
+            i++;
+            continue;
+        }
+        // ch is part of an identifier/number or other token
+        if (pendingSpace) {
+            // Add a space only if the previous output char and current char both look like identifiers
+            const prev = out[out.length - 1] || "";
+            if (isIdent(prev) && isIdent(ch))
+                out += " ";
+            pendingSpace = false;
+        }
+        out += ch;
+        i++;
+    }
+    return out.trim();
+};
+/**
+ * Recursively minify GraphQL query strings within a typical GraphQL request body.
+ * - If body is an object or array, it returns a new value with any `query` string minimized.
+ * - Other fields are preserved as-is.
+ */
+export const minifyGraphQLRequestBody = (body) => {
+    if (Array.isArray(body))
+        return body.map((item) => minifyGraphQLRequestBody(item));
+    if (isPlainObject(body)) {
+        const out = {};
+        for (const [k, v] of Object.entries(body)) {
+            if (k === "query" && typeof v === "string")
+                out[k] = minifyGraphQLQuery(v);
+            else
+                out[k] = minifyGraphQLRequestBody(v);
+        }
+        return out;
+    }
+    return body;
+};

package/lib/utils/guid.js

@@ -0,0 +1,22 @@
+/**
+ * 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 crypto from "crypto";
+export function createGuid() {
+    return crypto.randomBytes(16).toString("hex");
+}
+export function createHash(data) {
+    return crypto.createHash("sha256").update(data).digest("hex").slice(0, 7);
+}

package/lib/utils/httpServer.js

@@ -0,0 +1,39 @@
+/**
+ * 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 assert from "assert";
+import http from "http";
+export async function startHttpServer(config) {
+    const { host, port } = config;
+    const httpServer = http.createServer();
+    await new Promise((resolve, reject) => {
+        httpServer.on("error", reject);
+        httpServer.listen(port, host, () => {
+            resolve();
+            httpServer.removeListener("error", reject);
+        });
+    });
+    return httpServer;
+}
+export function httpAddressToString(address) {
+    assert(address, "Could not bind server socket");
+    if (typeof address === "string")
+        return address;
+    const resolvedPort = address.port;
+    let resolvedHost = address.family === "IPv4" ? address.address : `[${address.address}]`;
+    if (resolvedHost === "0.0.0.0" || resolvedHost === "[::]")
+        resolvedHost = "localhost";
+    return `http://${resolvedHost}:${resolvedPort}`;
+}

package/lib/utils/log.js

@@ -0,0 +1,21 @@
+/**
+ * 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 debug from "debug";
+const errorsDebug = debug("pw:mcp:errors");
+export function logUnhandledError(error) {
+    errorsDebug(error);
+}
+export const testDebug = debug("pw:mcp:test");

package/lib/utils/manualPromise.js

@@ -0,0 +1,111 @@
+/**
+ * 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.
+ */
+export class ManualPromise extends Promise {
+    _resolve;
+    _reject;
+    _isDone;
+    constructor() {
+        let resolve;
+        let reject;
+        super((f, r) => {
+            resolve = f;
+            reject = r;
+        });
+        this._isDone = false;
+        this._resolve = resolve;
+        this._reject = reject;
+    }
+    isDone() {
+        return this._isDone;
+    }
+    resolve(t) {
+        this._isDone = true;
+        this._resolve(t);
+    }
+    reject(e) {
+        this._isDone = true;
+        this._reject(e);
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    get [Symbol.toStringTag]() {
+        return "ManualPromise";
+    }
+}
+export class LongStandingScope {
+    _terminateError;
+    _closeError;
+    _terminatePromises = new Map();
+    _isClosed = false;
+    reject(error) {
+        this._isClosed = true;
+        this._terminateError = error;
+        for (const p of this._terminatePromises.keys())
+            p.resolve(error);
+    }
+    close(error) {
+        this._isClosed = true;
+        this._closeError = error;
+        for (const [p, frames] of this._terminatePromises)
+            p.resolve(cloneError(error, frames));
+    }
+    isClosed() {
+        return this._isClosed;
+    }
+    static async raceMultiple(scopes, promise) {
+        return Promise.race(scopes.map((s) => s.race(promise)));
+    }
+    async race(promise) {
+        return this._race(Array.isArray(promise) ? promise : [promise], false);
+    }
+    async safeRace(promise, defaultValue) {
+        return this._race([promise], true, defaultValue);
+    }
+    async _race(promises, safe, defaultValue) {
+        const terminatePromise = new ManualPromise();
+        const frames = captureRawStack();
+        if (this._terminateError)
+            terminatePromise.resolve(this._terminateError);
+        if (this._closeError)
+            terminatePromise.resolve(cloneError(this._closeError, frames));
+        this._terminatePromises.set(terminatePromise, frames);
+        try {
+            return await Promise.race([
+                terminatePromise.then((e) => (safe ? defaultValue : Promise.reject(e))),
+                ...promises,
+            ]);
+        }
+        finally {
+            this._terminatePromises.delete(terminatePromise);
+        }
+    }
+}
+function cloneError(error, frames) {
+    const clone = new Error();
+    clone.name = error.name;
+    clone.message = error.message;
+    clone.stack = [error.name + ":" + error.message, ...frames].join("\n");
+    return clone;
+}
+function captureRawStack() {
+    const stackTraceLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 50;
+    const error = new Error();
+    const stack = error.stack || "";
+    Error.stackTraceLimit = stackTraceLimit;
+    return stack.split("\n");
+}

package/lib/utils/networkFormat.js

@@ -0,0 +1,14 @@
+import { formatUrlWithTrimmedParams } from "../hooks/networkFilters.js";
+import { parseGraphQLRequestFromHttp, summarizeGraphQL } from "./graphql.js";
+export const formatNetworkSummaryLine = (input, opts) => {
+    const method = (input.method || "").toUpperCase();
+    const formattedUrl = opts?.trimParams === false
+        ? input.url
+        : formatUrlWithTrimmedParams(input.url);
+    const st = input.statusText ? ` ${input.statusText}` : "";
+    let line = `${method} ${formattedUrl} → ${input.status}${st}`;
+    const gql = parseGraphQLRequestFromHttp(input.method, input.url, input.headers || {}, input.postData ?? undefined);
+    if (gql)
+        line += ` [GraphQL: ${summarizeGraphQL(gql)}]`;
+    return line;
+};

package/lib/utils/package.js

@@ -0,0 +1,20 @@
+/**
+ * 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 fs from "fs";
+import path from "path";
+import url from "url";
+const __filename = url.fileURLToPath(import.meta.url);
+export const packageJSON = JSON.parse(fs.readFileSync(path.join(path.dirname(__filename), "..", "..", "package.json"), "utf8"));

package/lib/utils/result.js

@@ -0,0 +1,2 @@
+export const Ok = (value) => ({ ok: true, value });
+export const Err = (error) => ({ ok: false, error });

package/lib/utils/sanitizeHtml.js

@@ -0,0 +1,130 @@
+import { pipe, when } from "@fxts/core";
+import * as cheerio from "cheerio";
+import { ElementType } from "domelementtype";
+const I18N_PATTERNS = [
+    /window\.__i18n\s*=/i,
+    /window\.__translations\s*=/i,
+    /window\.i18n\s*=/i,
+    /window\._translations\s*=/i,
+    /\btranslations\s*:\s*{/i,
+    /\blocales\s*:\s*{/i,
+    /\bmessages\s*:\s*{/i,
+    /\bi18nData\s*=/i,
+    /\btranslationData\s*=/i,
+];
+export const isI18nScript = (content) => {
+    const text = content || "";
+    const hasI18nPattern = I18N_PATTERNS.some((pattern) => pattern.test(text));
+    const langCodePattern = /["'](?:[a-z]{2}(?:[_-][A-Z]{2})?|zh-(?:CN|TW|HK)|pt-BR|en-(?:US|GB|CA|AU)|es-(?:ES|MX|AR)|fr-(?:FR|CA)|de-(?:DE|AT|CH))["']\s*:\s*{/g;
+    const matches = text.match(langCodePattern) || [];
+    const hasLangCodeStructure = matches.length >= 2;
+    return hasI18nPattern || hasLangCodeStructure;
+};
+export const removeI18nScripts = ($) => {
+    $("script").each((_, el) => {
+        const content = $(el).html() || "";
+        if (isI18nScript(content))
+            $(el).remove();
+    });
+    return $;
+};
+export const removeScriptTags = ($) => {
+    $("script").remove();
+    return $;
+};
+export const removeStyleTags = ($) => {
+    $("style").remove();
+    return $;
+};
+export const NON_ESSENTIAL_RELS = [
+    "stylesheet",
+    "preload",
+    "prefetch",
+    "preconnect",
+    "dns-prefetch",
+    "modulepreload",
+    "icon",
+    "shortcut icon",
+    "apple-touch-icon",
+    "apple-touch-icon-precomposed",
+    "manifest",
+    "pingback",
+    "prerender",
+    "subresource",
+];
+export const removeNonEssentialLinks = ($) => {
+    $("link").each((_, el) => {
+        const rel = ($(el).attr("rel") || "").toLowerCase();
+        const type = ($(el).attr("type") || "").toLowerCase();
+        if (type === "text/css") {
+            $(el).remove();
+            return;
+        }
+        if (rel) {
+            const relValues = rel.split(/\s+/);
+            const hasNonEssential = relValues.some((value) => NON_ESSENTIAL_RELS.includes(value) ||
+                (value === "shortcut" && relValues.includes("icon")));
+            if (hasNonEssential)
+                $(el).remove();
+        }
+    });
+    return $;
+};
+export const removeMetaTags = ($) => {
+    $("meta").remove();
+    return $;
+};
+export const removeHtmlComments = ($) => {
+    $("*")
+        .contents()
+        .each((_, node) => {
+        if (node.type === ElementType.Comment)
+            $(node).remove();
+    });
+    return $;
+};
+export const SVG_ATTRIBUTES_TO_REMOVE = [
+    "xmlns",
+    "d",
+    "fill",
+    "stroke",
+    "stroke-width",
+    "stroke-linecap",
+    "stroke-linejoin",
+    "stroke-dasharray",
+    "opacity",
+    "fill-opacity",
+    "stroke-opacity",
+    "transform",
+    "rotate",
+    "scale",
+    "translate",
+    "filter",
+    "mask",
+    "clip-path",
+    "paint-order",
+    "vector-effect",
+    "shape-rendering",
+    "gradientUnits",
+    "gradientTransform",
+    "patternUnits",
+    "patternTransform",
+    "marker-start",
+    "marker-mid",
+    "marker-end",
+    "style",
+];
+export const stripSvgAttributes = ($) => {
+    $("svg, svg *").each((_, el) => {
+        SVG_ATTRIBUTES_TO_REMOVE.forEach((attr) => {
+            $(el).removeAttr(attr);
+        });
+    });
+    return $;
+};
+export const minifyHtml = (html) => html.replace(/>\s+</g, "><").trim();
+export const sanitizeHtml = (html, options) => {
+    if (!options.shouldRemoveScripts && !options.shouldRemoveStyles)
+        return html;
+    return pipe(cheerio.load(html, { xmlMode: false }), when(() => !options.shouldRemoveScripts, removeI18nScripts), when(() => options.shouldRemoveScripts, removeScriptTags), when(() => options.shouldRemoveStyles, removeStyleTags), removeNonEssentialLinks, removeMetaTags, removeHtmlComments, stripSvgAttributes, ($) => minifyHtml($.root().html() || ""));
+};