site-agent-pro 1.0.0

package/dist/core/interaction.js

@@ -0,0 +1,202 @@
+export const INTERACTION_VISIBLE_TIMEOUT_MS = 5000;
+const HUMAN_TYPING_DELAY_MS = 30;
+function normalizeInteractionText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function normalizeInteractionKey(value) {
+    return normalizeInteractionText(value).toLowerCase();
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeAttributeValue(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildPattern(value, mode) {
+    const normalized = normalizeInteractionText(value);
+    if (!normalized) {
+        return null;
+    }
+    const flexible = escapeRegExp(normalized).replace(/\s+/g, "\\s+");
+    if (mode === "exact") {
+        return new RegExp(`^\\s*${flexible}\\s*(?:[:*]\\s*)?$`, "i");
+    }
+    return new RegExp(flexible, "i");
+}
+function buildUniquePatterns(values, mode) {
+    const seen = new Set();
+    const patterns = [];
+    for (const value of values) {
+        const pattern = buildPattern(value, mode);
+        if (!pattern) {
+            continue;
+        }
+        const key = `${pattern.source}/${pattern.flags}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        patterns.push(pattern);
+    }
+    return patterns;
+}
+function resolveFieldRoles(field) {
+    if (field.tag === "textarea") {
+        return ["textbox"];
+    }
+    if (field.tag === "select") {
+        return ["combobox", "listbox"];
+    }
+    switch (field.inputType) {
+        case "checkbox":
+            return ["checkbox"];
+        case "radio":
+            return ["radio"];
+        case "number":
+            return ["spinbutton"];
+        case "password":
+            return [];
+        default:
+            return ["textbox"];
+    }
+}
+async function firstVisibleCandidate(candidates) {
+    for (const candidate of candidates) {
+        const locator = candidate.locator.first();
+        try {
+            if (await locator.isVisible({ timeout: 400 })) {
+                return {
+                    locator,
+                    strategy: candidate.strategy
+                };
+            }
+        }
+        catch {
+            // continue
+        }
+    }
+    return null;
+}
+export function buildLooseAccessiblePattern(value) {
+    return buildPattern(value, "loose");
+}
+export async function waitForVisible(locator, timeout = INTERACTION_VISIBLE_TIMEOUT_MS) {
+    const resolved = locator.first();
+    await resolved.waitFor({ state: "visible", timeout });
+    return resolved;
+}
+export async function prepareLocatorForInteraction(locator) {
+    const resolved = await waitForVisible(locator);
+    await resolved.scrollIntoViewIfNeeded().catch(() => undefined);
+    return resolved;
+}
+export async function resolvePreferredFieldLocator(args) {
+    const exactNamePatterns = buildUniquePatterns([args.field.label], "exact");
+    const looseNamePatterns = buildUniquePatterns([...(args.preferredNames ?? []), args.field.label], "loose");
+    const exactPlaceholderPatterns = buildUniquePatterns([args.field.placeholder], "exact");
+    const loosePlaceholderPatterns = buildUniquePatterns([args.field.placeholder, ...(args.preferredNames ?? [])], "loose");
+    const roles = resolveFieldRoles(args.field);
+    const candidates = [];
+    for (const pattern of exactNamePatterns) {
+        for (const role of roles) {
+            candidates.push({
+                locator: args.page.getByRole(role, { name: pattern }),
+                strategy: `getByRole(${role})`
+            });
+        }
+        candidates.push({
+            locator: args.page.getByLabel(pattern),
+            strategy: "getByLabel"
+        });
+    }
+    for (const pattern of exactPlaceholderPatterns) {
+        candidates.push({
+            locator: args.page.getByPlaceholder(pattern),
+            strategy: "getByPlaceholder"
+        });
+    }
+    for (const pattern of looseNamePatterns) {
+        for (const role of roles) {
+            candidates.push({
+                locator: args.page.getByRole(role, { name: pattern }),
+                strategy: `getByRole(${role})`
+            });
+        }
+        candidates.push({
+            locator: args.page.getByLabel(pattern),
+            strategy: "getByLabel"
+        });
+    }
+    for (const pattern of loosePlaceholderPatterns) {
+        candidates.push({
+            locator: args.page.getByPlaceholder(pattern),
+            strategy: "getByPlaceholder"
+        });
+    }
+    if (normalizeInteractionText(args.field.name)) {
+        candidates.push({
+            locator: args.page.locator(`[name="${escapeAttributeValue(args.field.name)}"]`),
+            strategy: "name attribute"
+        });
+    }
+    if (normalizeInteractionText(args.field.id)) {
+        candidates.push({
+            locator: args.page.locator(`[id="${escapeAttributeValue(args.field.id)}"]`),
+            strategy: "id attribute"
+        });
+    }
+    candidates.push({
+        locator: args.fallbackLocator.first(),
+        strategy: "marker fallback"
+    });
+    return (await firstVisibleCandidate(candidates)) ?? {
+        locator: args.fallbackLocator.first(),
+        strategy: "marker fallback"
+    };
+}
+async function readLocatorValue(locator) {
+    return locator
+        .inputValue()
+        .catch(async () => {
+        return locator
+            .evaluate((element) => {
+            if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+                return element.value;
+            }
+            return "";
+        })
+            .catch(() => "");
+    });
+}
+async function clearFieldValue(locator) {
+    await locator.click({ timeout: 2000 }).catch(async () => {
+        await locator.focus().catch(() => undefined);
+    });
+    await locator.selectText().catch(() => undefined);
+    const modifier = process.platform === "darwin" ? "Meta" : "Control";
+    await locator.press(`${modifier}+A`).catch(() => undefined);
+    await locator.press("Delete").catch(() => undefined);
+    await locator.press("Backspace").catch(() => undefined);
+    const remainingValue = normalizeInteractionKey(await readLocatorValue(locator));
+    if (!remainingValue) {
+        return;
+    }
+    // Fall back to a DOM-level clear only when keyboard selection did not take.
+    await locator
+        .evaluate((element) => {
+        if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+            element.value = "";
+            element.dispatchEvent(new Event("input", { bubbles: true }));
+            element.dispatchEvent(new Event("change", { bubbles: true }));
+        }
+    })
+        .catch(() => undefined);
+}
+export async function typeLikeHuman(locator, value) {
+    const prepared = await prepareLocatorForInteraction(locator);
+    await clearFieldValue(prepared);
+    if (!value) {
+        return;
+    }
+    await prepared.pressSequentially(value, { delay: HUMAN_TYPING_DELAY_MS });
+}

package/dist/core/pageState.js

@@ -0,0 +1,201 @@
+import { PageStateSchema } from "../schemas/types.js";
+export async function capturePageState(page) {
+    const title = await page.title().catch(() => "");
+    const url = page.url();
+    const rawVisibleText = await page.locator("body").innerText().catch(() => "");
+    const visibleText = rawVisibleText.replace(/\s+/g, " ").slice(0, 4200);
+    const visibleLines = rawVisibleText
+        .split(/\r?\n/)
+        .map((line) => line.replace(/\s+/g, " ").trim())
+        .filter(Boolean)
+        .slice(0, 140);
+    const snapshot = await page.evaluate(() => {
+        let nextAgentId = 1;
+        const assignAgentId = (element) => {
+            const existing = (element.getAttribute("data-site-agent-id") || "").trim();
+            if (existing) {
+                const existingNumber = Number(existing);
+                if (Number.isFinite(existingNumber) && existingNumber >= nextAgentId) {
+                    nextAgentId = existingNumber + 1;
+                }
+                return existing;
+            }
+            const agentId = String(nextAgentId++);
+            element.setAttribute("data-site-agent-id", agentId);
+            return agentId;
+        };
+        const nodes = Array.from(document.querySelectorAll("a, button, input, textarea, select, summary, [role='button'], [role='link'], [role='tab'], [role='menuitem'], [role='textbox']"));
+        const interactive = nodes
+            .map((element) => {
+            const rect = element.getBoundingClientRect();
+            const style = window.getComputedStyle(element);
+            const visible = rect.width > 0 &&
+                rect.height > 0 &&
+                style.visibility !== "hidden" &&
+                style.display !== "none";
+            if (!visible) {
+                return null;
+            }
+            const buttonValueText = element instanceof HTMLInputElement && ["submit", "button", "reset"].includes((element.type || "").toLowerCase())
+                ? element.value || ""
+                : "";
+            const text = (element.innerText ||
+                element.getAttribute("aria-label") ||
+                buttonValueText ||
+                element.getAttribute("placeholder") ||
+                element.getAttribute("title") ||
+                "")
+                .trim()
+                .replace(/\s+/g, " ")
+                .slice(0, 120);
+            const role = element.getAttribute("role") || element.tagName.toLowerCase();
+            const tag = element.tagName.toLowerCase();
+            const type = element.getAttribute("type") || undefined;
+            const href = element instanceof HTMLAnchorElement ? element.href : undefined;
+            const disabled = element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+            if (!text) {
+                return null;
+            }
+            const agentId = assignAgentId(element);
+            return {
+                agentId,
+                role,
+                tag,
+                type,
+                text,
+                href,
+                disabled
+            };
+        })
+            .filter(Boolean)
+            .slice(0, 100);
+        const formFields = Array.from(document.querySelectorAll("input, textarea, select"))
+            .map((element) => {
+            const rect = element.getBoundingClientRect();
+            const style = window.getComputedStyle(element);
+            const inputType = element instanceof HTMLInputElement ? (element.type || "text").replace(/\s+/g, " ").trim().toLowerCase() : "";
+            if (rect.width <= 0 ||
+                rect.height <= 0 ||
+                style.visibility === "hidden" ||
+                style.display === "none" ||
+                element.disabled ||
+                inputType === "hidden" ||
+                inputType === "submit" ||
+                inputType === "button" ||
+                inputType === "image") {
+                return null;
+            }
+            const labelParts = [];
+            if ("labels" in element && element.labels) {
+                for (const label of Array.from(element.labels)) {
+                    labelParts.push((label.innerText || label.textContent || "").replace(/\s+/g, " ").trim());
+                }
+            }
+            const ariaLabelledBy = element.getAttribute("aria-labelledby");
+            if (ariaLabelledBy) {
+                for (const id of ariaLabelledBy.split(/\s+/)) {
+                    const labelElement = document.getElementById(id);
+                    if (labelElement) {
+                        labelParts.push((labelElement.textContent || "").replace(/\s+/g, " ").trim());
+                    }
+                }
+            }
+            const closestLabel = element.closest("label");
+            if (closestLabel) {
+                labelParts.push((closestLabel.innerText || closestLabel.textContent || "").replace(/\s+/g, " ").trim());
+            }
+            const ariaLabel = (element.getAttribute("aria-label") || "").replace(/\s+/g, " ").trim();
+            if (ariaLabel) {
+                labelParts.push(ariaLabel);
+            }
+            // If still no labels, look for a preceding text-heavy sibling or parent text
+            if (labelParts.filter(Boolean).length === 0) {
+                let prev = element.previousElementSibling;
+                while (prev) {
+                    const text = (prev.textContent || "").replace(/\s+/g, " ").trim();
+                    if (text.length > 1 && text.length < 60) {
+                        labelParts.push(text);
+                        break;
+                    }
+                    prev = prev.previousElementSibling;
+                }
+            }
+            const options = element instanceof HTMLSelectElement
+                ? Array.from(element.options)
+                    .map((option) => (option.textContent || "").replace(/\s+/g, " ").trim())
+                    .filter(Boolean)
+                    .slice(0, 50)
+                : [];
+            const agentId = assignAgentId(element);
+            return {
+                agentId,
+                label: labelParts.filter(Boolean).join(" ").replace(/\s+/g, " ").trim(),
+                placeholder: (element.getAttribute("placeholder") || "").replace(/\s+/g, " ").trim(),
+                name: (element.getAttribute("name") || "").replace(/\s+/g, " ").trim(),
+                id: (element.id || "").replace(/\s+/g, " ").trim(),
+                tag: element.tagName.toLowerCase(),
+                inputType: inputType || element.tagName.toLowerCase(),
+                autocomplete: (element.getAttribute("autocomplete") || "").replace(/\s+/g, " ").trim().toLowerCase(),
+                inputMode: (element.getAttribute("inputmode") || "").replace(/\s+/g, " ").trim().toLowerCase(),
+                value: element instanceof HTMLSelectElement
+                    ? (element.selectedOptions[0]?.textContent || "").replace(/\s+/g, " ").trim()
+                    : (element.value || "").replace(/\s+/g, " ").trim(),
+                required: element.required || element.getAttribute("aria-required") === "true",
+                checked: element instanceof HTMLInputElement ? element.checked : undefined,
+                maxLength: element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement
+                    ? element.maxLength > 0
+                        ? element.maxLength
+                        : null
+                    : null,
+                options
+            };
+        })
+            .filter(Boolean)
+            .slice(0, 50);
+        const numberedElements = [];
+        const seenAgentIds = new Set();
+        for (const item of interactive) {
+            if (!item) {
+                continue;
+            }
+            if (seenAgentIds.has(item.agentId)) {
+                continue;
+            }
+            seenAgentIds.add(item.agentId);
+            numberedElements.push(`[${item.agentId}] ${item.role || item.tag}: "${item.text}"`);
+        }
+        for (const field of formFields) {
+            if (!field) {
+                continue;
+            }
+            if (seenAgentIds.has(field.agentId)) {
+                continue;
+            }
+            seenAgentIds.add(field.agentId);
+            const label = field.label || field.placeholder || field.name || field.id || field.inputType || field.tag;
+            numberedElements.push(`[${field.agentId}] field: "${label}"`);
+        }
+        const headings = Array.from(document.querySelectorAll("h1, h2, h3"))
+            .map((heading) => heading.textContent?.trim() || "")
+            .filter(Boolean)
+            .slice(0, 16);
+        const formsPresent = document.querySelectorAll("form").length > 0;
+        const modalHints = Array.from(document.querySelectorAll("dialog, [role='dialog'], .modal, [aria-modal='true']"))
+            .map((element) => element.textContent?.trim()?.slice(0, 140) || "")
+            .filter(Boolean)
+            .slice(0, 4);
+        return { interactive, formFields, numberedElements, headings, formsPresent, modalHints };
+    });
+    return PageStateSchema.parse({
+        title,
+        url,
+        visibleText,
+        visibleLines,
+        formFields: snapshot.formFields,
+        interactive: snapshot.interactive,
+        numberedElements: snapshot.numberedElements,
+        headings: snapshot.headings,
+        formsPresent: snapshot.formsPresent,
+        modalHints: snapshot.modalHints
+    });
+}