app-manager-edge-worker 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "app-manager-edge-worker",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Distributed Scraper Edge Worker for Apps Manager. Run on any local machine, VPS, or Termux Android device to serve browser and HTTP scraping jobs.",
   "type": "module",
   "bin": {

package/src/handlers/previewHandler.js

@@ -93,48 +93,210 @@ export async function handleInspectElement(payload) {
                     height: Math.round(rect.height),
                 };
 
+                // ─── Helper: count matching elements for a CSS selector ───
+                const countMatches = (sel) => {
+                    try { return document.querySelectorAll(sel).length; } catch { return 999; }
+                };
+
+                // ─── Helper: Full positional CSS path anchored at nearest ID ───
+                const buildCssPath = (element, maxDepth = 8) => {
+                    const parts = [];
+                    let curr = element;
+                    while (curr && curr.nodeType === 1 && curr !== document.documentElement) {
+                        if (curr === document.body) { parts.unshift("body"); break; }
+                        let seg = curr.tagName.toLowerCase();
+                        if (curr.id && /^[a-zA-Z][\w-]*$/.test(curr.id)) {
+                            parts.unshift(`#${curr.id}`);
+                            break;
+                        }
+                        if (curr.parentElement) {
+                            const pos = Array.from(curr.parentElement.children).indexOf(curr) + 1;
+                            seg += `:nth-child(${pos})`;
+                        }
+                        parts.unshift(seg);
+                        curr = curr.parentElement;
+                        if (parts.length >= maxDepth) break;
+                    }
+                    return parts.join(" > ");
+                };
+
+                // ─── Helper: Shortest unique CSS path using class combos + nth-child ───
+                const buildShortUniqueSelector = (element) => {
+                    const pathParts = [];
+                    let curr = element;
+                    while (curr && curr !== document.documentElement) {
+                        if (curr === document.body) { pathParts.unshift("body"); break; }
+                        let seg = curr.tagName.toLowerCase();
+                        if (curr.id && /^[a-zA-Z][\w-]*$/.test(curr.id)) {
+                            pathParts.unshift(`#${curr.id}`);
+                            break;
+                        }
+                        const classes = (curr.className && typeof curr.className === "string")
+                            ? curr.className.split(/\s+/).filter(c => c && /^[a-zA-Z_-][\w-]*$/.test(c))
+                            : [];
+                        let foundUnique = false;
+                        for (let len = Math.min(classes.length, 5); len >= 1; len--) {
+                            const combo = classes.slice(0, len);
+                            const candidate = `${seg}.${combo.join(".")}`;
+                            const full = [...pathParts, candidate].join(" > ");
+                            if (countMatches(full) === 1) {
+                                pathParts.unshift(candidate);
+                                foundUnique = true;
+                                break;
+                            }
+                        }
+                        if (!foundUnique) {
+                            if (curr.parentElement) {
+                                const pos = Array.from(curr.parentElement.children).indexOf(curr) + 1;
+                                seg += `:nth-child(${pos})`;
+                            }
+                            pathParts.unshift(seg);
+                        }
+                        const full = pathParts.join(" > ");
+                        if (countMatches(full) === 1) break;
+                        curr = curr.parentElement;
+                    }
+                    return pathParts.join(" > ");
+                };
+
+                // ─── Helper: Robust absolute XPath ───
+                const buildXPath = (element) => {
+                    if (!element || element === document) return "";
+                    if (element.id && /^[a-zA-Z][\w-]*$/.test(element.id)) {
+                        return `//*[@id="${element.id}"]`;
+                    }
+                    if (element === document.body) return "/html/body";
+                    const parts = [];
+                    let curr = element;
+                    while (curr && curr.nodeType === 1 && curr !== document.documentElement) {
+                        if (curr === document.body) { parts.unshift("body"); break; }
+                        if (curr.id && /^[a-zA-Z][\w-]*$/.test(curr.id)) {
+                            parts.unshift(`//*[@id="${curr.id}"]`);
+                            return parts.join("/");
+                        }
+                        const tag = curr.tagName.toLowerCase();
+                        let idx = 1;
+                        let sib = curr.previousElementSibling;
+                        while (sib) {
+                            if (sib.tagName.toLowerCase() === tag) idx++;
+                            sib = sib.previousElementSibling;
+                        }
+                        const total = curr.parentElement
+                            ? Array.from(curr.parentElement.children).filter(c => c.tagName.toLowerCase() === tag).length
+                            : 1;
+                        parts.unshift(total > 1 ? `${tag}[${idx}]` : tag);
+                        curr = curr.parentElement;
+                    }
+                    return "/" + parts.join("/");
+                };
+
+                // ─── Build ranked candidates ───
                 const candidates = [];
-                if (el.id) {
-                    candidates.push({ type: "css", value: `#${el.id}`, attribute: "text" });
+                const seen = new Set();
+                const addCandidate = (type, value, extra = {}) => {
+                    if (!value || seen.has(value)) return;
+                    seen.add(value);
+                    const matchCount = type === "css" ? countMatches(value) : null;
+                    candidates.push({ type, value, attribute: "text", matchCount, ...extra });
+                };
+
+                // 1. ID (most reliable, unique)
+                if (el.id && /^[a-zA-Z][\w-]*$/.test(el.id)) {
+                    addCandidate("css", `#${el.id}`, { specificity: "unique", label: "ID Selector" });
                 }
 
+                // 2. data-* and aria-* attributes
                 for (const attr of el.attributes) {
-                    if (attr.name.startsWith("data-") && attr.value) {
-                        candidates.push({
-                            type: "css",
-                            value: `[${attr.name}='${attr.value}']`,
-                            attribute: "text",
+                    if ((attr.name.startsWith("data-") || attr.name.startsWith("aria-")) && attr.value && attr.value.length < 80) {
+                        addCandidate("css", `${el.tagName.toLowerCase()}[${attr.name}="${attr.value}"]`, {
+                            specificity: "high", label: `Attribute: ${attr.name}`
                         });
                     }
                 }
 
-                if (el.className && typeof el.className === "string") {
-                    const classes = el.className
-                        .split(/\s+/)
-                        .filter((c) => c && !c.includes(":") && !c.includes("/") && !c.includes("["));
-                    if (classes.length > 0) {
-                        candidates.push({
-                            type: "css",
-                            value: `${el.tagName.toLowerCase()}.${classes.slice(0, 2).join(".")}`,
-                            attribute: "text",
+                // 3. Shortest unique CSS path
+                const shortUnique = buildShortUniqueSelector(el);
+                if (shortUnique) {
+                    const mc = countMatches(shortUnique);
+                    addCandidate("css", shortUnique, {
+                        specificity: mc === 1 ? "unique" : "medium",
+                        label: "Smart CSS Path",
+                        matchCount: mc,
+                    });
+                }
+
+                // 4. Class-based selectors (increasing combos until unique)
+                const classes = (el.className && typeof el.className === "string")
+                    ? el.className.split(/\s+/).filter(c => c && /^[a-zA-Z_-][\w-]*$/.test(c))
+                    : [];
+                for (let len = 1; len <= Math.min(classes.length, 5); len++) {
+                    const sel = `${el.tagName.toLowerCase()}.${classes.slice(0, len).join(".")}`;
+                    const mc = countMatches(sel);
+                    addCandidate("css", sel, {
+                        specificity: mc === 1 ? "unique" : mc <= 3 ? "medium" : "generic",
+                        label: "Class Selector",
+                        matchCount: mc,
+                    });
+                    if (mc === 1) break;
+                }
+
+                // 5. Table-specific selectors
+                const tr = el.closest("tr");
+                if (tr && tr.parentElement) {
+                    const rowIdx = Array.from(tr.parentElement.children).indexOf(tr) + 1;
+                    const td = el.closest("td, th");
+                    if (td) {
+                        const colIdx = Array.from(tr.children).indexOf(td) + 1;
+                        addCandidate("css", `table tr:nth-child(${rowIdx}) td:nth-child(${colIdx})`, {
+                            specificity: "medium", label: "Table Cell"
+                        });
+                        addCandidate("css", `table tbody tr:nth-child(${rowIdx}) td:nth-child(${colIdx})`, {
+                            specificity: "medium", label: "Table Cell (tbody)"
                         });
                     }
                 }
 
-                const tagName = el.tagName.toLowerCase();
-                candidates.push({ type: "css", value: tagName, attribute: "text" });
+                // 6. Full structural CSS path
+                const fullCss = buildCssPath(el, 8);
+                addCandidate("css", fullCss, { specificity: "unique", label: "Full CSS Path (Structural)" });
+
+                // 7. XPath — most reliable for scrapers
+                const xpath = buildXPath(el);
+                addCandidate("xpath", xpath, { specificity: "high", label: "XPath" });
+
+                // Sort by specificity: unique > high > medium > generic
+                const rank = { unique: 0, high: 1, medium: 2, generic: 3 };
+                candidates.sort((a, b) => (rank[a.specificity] ?? 4) - (rank[b.specificity] ?? 4));
+
+                // ─── Breadcrumb hierarchy for UI ───
+                const hierarchy = [];
+                let curr = el;
+                while (curr && curr !== document.body && hierarchy.length < 7) {
+                    let desc = curr.tagName.toLowerCase();
+                    if (curr.id) {
+                        desc += `#${curr.id}`;
+                    } else if (curr.classList && curr.classList.length > 0) {
+                        const cls = Array.from(curr.classList)
+                            .filter(c => /^[a-zA-Z_-][\w-]*$/.test(c))
+                            .slice(0, 2);
+                        if (cls.length) desc += `.${cls.join(".")}`;
+                    }
+                    hierarchy.unshift(desc);
+                    curr = curr.parentElement;
+                }
 
                 const text = el.innerText ? el.innerText.trim() : el.textContent?.trim() || "";
 
                 return {
                     found: true,
-                    tagName,
+                    tagName: el.tagName.toLowerCase(),
                     text,
                     attributes: Array.from(el.attributes).reduce((acc, a) => {
                         acc[a.name] = a.value;
                         return acc;
                     }, {}),
                     candidates,
+                    hierarchy,
                     boundingRect,
                 };
             }, x, y);