@wong2kim/wmux 1.1.1 → 1.1.2

package/dist/mcp/mcp/playwright/anti-detection.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAntiDetection = applyAntiDetection;
+exports.evaluateWithGesture = evaluateWithGesture;
+// ---------------------------------------------------------------------------
+// Anti-detection helpers
+// ---------------------------------------------------------------------------
+/**
+ * Apply anti-detection measures to the page via init scripts.
+ *
+ * Currently patches `navigator.webdriver` to return `undefined` so that
+ * common bot-detection scripts do not flag the session.
+ */
+async function applyAntiDetection(page) {
+    await page.context().addInitScript(() => {
+        // Override navigator.webdriver to hide automation flag
+        Object.defineProperty(navigator, 'webdriver', {
+            get: () => undefined,
+            configurable: true,
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// CDP-powered evaluate with user gesture
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate a JavaScript expression in the page context with the
+ * `userGesture` flag set to `true`.
+ *
+ * This is useful for actions that require a transient user activation
+ * (e.g. opening a popup, triggering downloads) without an actual mouse /
+ * keyboard event.
+ *
+ * Internally opens a CDP session and calls `Runtime.evaluate`.
+ */
+async function evaluateWithGesture(page, expression) {
+    const client = await page.context().newCDPSession(page);
+    try {
+        const result = await client.send('Runtime.evaluate', {
+            expression,
+            userGesture: true,
+            returnByValue: true,
+            awaitPromise: true,
+        });
+        if (result.exceptionDetails) {
+            const msg = result.exceptionDetails.exception?.description ??
+                result.exceptionDetails.text ??
+                'CDP Runtime.evaluate threw an exception';
+            throw new Error(msg);
+        }
+        return result.result.value;
+    }
+    finally {
+        await client.detach().catch(() => {
+            /* best-effort cleanup */
+        });
+    }
+}

package/dist/mcp/mcp/playwright/dom-intelligence.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSmartSnapshot = getSmartSnapshot;
+exports.getLocatorByRef = getLocatorByRef;
+exports.clearElementCache = clearElementCache;
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const DEFAULT_MAX_CONTENT_LENGTH = 3000;
+/** Roles considered interactive — elements with these roles get indexed */
+const INTERACTIVE_ROLES = new Set([
+    'button',
+    'link',
+    'textbox',
+    'checkbox',
+    'radio',
+    'combobox',
+    'listbox',
+    'menuitem',
+    'menuitemcheckbox',
+    'menuitemradio',
+    'option',
+    'searchbox',
+    'slider',
+    'spinbutton',
+    'switch',
+    'tab',
+    'treeitem',
+]);
+// ---------------------------------------------------------------------------
+// Element cache — stores indexed elements from the last snapshot
+// ---------------------------------------------------------------------------
+let elementCache = [];
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Escape special characters in a string for use inside a Playwright
+ * locator expression (e.g. `getByRole('button', { name: '...' })`).
+ */
+function escapeLocatorName(name) {
+    return name.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+/**
+ * Build a Playwright locator string for a given role and name.
+ *
+ * If the name is empty, falls back to `getByRole('role')` without a
+ * name filter. When duplicate names exist for the same role, callers
+ * should use `.nth()` — but we provide the base locator here.
+ */
+function buildLocatorString(role, name) {
+    if (!name) {
+        return `getByRole('${role}')`;
+    }
+    return `getByRole('${role}', { name: '${escapeLocatorName(name)}' })`;
+}
+/**
+ * Recursively walk the CDP accessibility tree and collect interactive
+ * elements into the provided array, assigning 1-based ref numbers.
+ */
+function collectInteractiveElements(nodeMap, node, elements) {
+    if (node.ignored)
+        return;
+    const role = node.role?.value ?? 'none';
+    const name = node.name?.value ?? '';
+    if (INTERACTIVE_ROLES.has(role)) {
+        const ref = elements.length + 1; // 1-based
+        const element = {
+            ref,
+            role,
+            name,
+            locator: buildLocatorString(role, name),
+        };
+        if (node.value?.value) {
+            element.value = node.value.value;
+        }
+        if (node.description?.value) {
+            element.description = node.description.value;
+        }
+        elements.push(element);
+    }
+    // Recurse into children
+    if (node.childIds) {
+        for (const childId of node.childIds) {
+            const child = nodeMap.get(childId);
+            if (child) {
+                collectInteractiveElements(nodeMap, child, elements);
+            }
+        }
+    }
+}
+/**
+ * Fetch the full accessibility tree via CDP and return indexed interactive
+ * elements.
+ */
+async function getInteractiveElements(page) {
+    const client = await page.context().newCDPSession(page);
+    try {
+        const { nodes } = (await client.send('Accessibility.getFullAXTree'));
+        if (nodes.length === 0)
+            return [];
+        // Build a map for quick lookup by nodeId
+        const nodeMap = new Map();
+        for (const n of nodes)
+            nodeMap.set(n.nodeId, n);
+        const elements = [];
+        collectInteractiveElements(nodeMap, nodes[0], elements);
+        return elements;
+    }
+    finally {
+        await client.detach().catch(() => {
+            /* best-effort cleanup */
+        });
+    }
+}
+/**
+ * Retrieve truncated page text content.
+ */
+async function getPageContent(page, maxLength) {
+    try {
+        const text = await page.innerText('body');
+        if (text.length <= maxLength)
+            return text;
+        return text.slice(0, maxLength) + '\n... (truncated)';
+    }
+    catch {
+        return '';
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Generate a "smart snapshot" of the page: a structured representation
+ * containing only interactive elements (with 1-based ref indices) plus a
+ * truncated text summary of the page content.
+ *
+ * The indexed elements are cached internally so that `getLocatorByRef()`
+ * can resolve a ref number back to a Playwright locator string without
+ * re-querying the page.
+ */
+async function getSmartSnapshot(page, options) {
+    const maxContentLength = options?.maxContentLength ?? DEFAULT_MAX_CONTENT_LENGTH;
+    const [url, title, elements, content] = await Promise.all([
+        Promise.resolve(page.url()),
+        page.title(),
+        getInteractiveElements(page),
+        getPageContent(page, maxContentLength),
+    ]);
+    // Update element cache
+    elementCache = elements;
+    return { url, title, elements, content };
+}
+/**
+ * Look up a Playwright locator string by the 1-based ref number assigned
+ * during the most recent `getSmartSnapshot()` call.
+ *
+ * Returns `null` if the ref is out of range or no snapshot has been taken.
+ */
+function getLocatorByRef(ref) {
+    if (ref < 1 || ref > elementCache.length)
+        return null;
+    return elementCache[ref - 1].locator;
+}
+/**
+ * Clear the cached element list. Useful when navigating to a new page
+ * to avoid stale refs.
+ */
+function clearElementCache() {
+    elementCache = [];
+}

package/dist/mcp/mcp/playwright/human-typing.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDelaySchedule = generateDelaySchedule;
+exports.typeHumanlike = typeHumanlike;
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+const DEFAULT_MIN_DELAY = 50;
+const DEFAULT_MAX_DELAY = 150;
+function randomDelay(min, max) {
+    return Math.random() * (max - min) + min;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Generate an array of per-character delay values (in ms) for the given
+ * text.  This mirrors `HumanBehavior.generateTypingSchedule()` from the
+ * main process but is independent of that class.
+ */
+function generateDelaySchedule(text, options) {
+    const min = options?.minDelay ?? DEFAULT_MIN_DELAY;
+    const max = options?.maxDelay ?? DEFAULT_MAX_DELAY;
+    return Array.from({ length: text.length }, () => randomDelay(min, max));
+}
+/**
+ * Type `text` into the element identified by `selector` with randomised
+ * inter-keystroke delays that mimic human typing.
+ *
+ * Each character is pressed individually via `page.keyboard.press()` with
+ * a random pause between `minDelay` and `maxDelay` milliseconds.
+ *
+ * If `selector` is provided the element is clicked first to ensure focus.
+ */
+async function typeHumanlike(page, selector, text, options) {
+    // Focus the target element
+    if (selector) {
+        await page.click(selector);
+    }
+    const delays = generateDelaySchedule(text, options);
+    for (let i = 0; i < text.length; i++) {
+        await page.keyboard.press(text[i]);
+        await sleep(delays[i]);
+    }
+}