app-manager-edge-worker 1.3.0 → 1.3.1

package/README.md

@@ -201,6 +201,14 @@ Log levels: `[INFO]` · `[SUCCESS]` · `[WARN]` · `[ERROR]` · `[TASK]` (job di
 
 ---
 
+### v1.3.1
+- **Robust Portal Input Resolution & Dynamic SPA Lifecycle Engine**:
+  - **Dynamic Multi-Selector Fallback Generation**: Form input selectors now automatically generate and evaluate candidate fallbacks (e.g. `input[name="for_gstin"]` expands to include `#for_gstin`, `[name="for_gstin"]`, `input#for_gstin`, `input[data-ng-model*="gstin"]`, and placeholder variants), resolving elements regardless of framework attribute formatting.
+  - **IFrame-Aware Element Discovery**: Introduced `locateElementInPageOrFrames` across `HITL_SESSION_INIT`, `HITL_SESSION_REFRESH`, and `HITL_SESSION_SOLVE`, querying the main page as well as all nested frames/iframes for inputs, captchas, and submit buttons.
+  - **Realistic Timeout Scaling**: Replaced fragile hardcoded timeouts (4s - 6s) with dynamic portal timeout scaling (`Math.max(timeoutMs, 20000)`), granting heavy client-side frameworks (AngularJS, React) sufficient headroom to download scripts and compile views.
+  - **AngularJS Scope & Model Synchronization**: Typed input values now dispatch full keyboard cascades (`input`, `change`, `keydown`, `keyup`, `blur`) and directly synchronize AngularJS `ngModel` (`$setViewValue`, `$render`, `$apply`) to trigger dynamic validation and captcha loaders (e.g. `showCap1`).
+  - **Actionable Diagnostic Logging**: Failure to locate an element now logs the browser's active URL and document title in terminal output with detailed context.
+
 ### v1.3.0
 - **Multi-Error Identifier Rules & Inspection Resilience Engine**:
   - **Custom Error Identifier Rules**: Supported typed error detection rules (`errorDetection.rules`) allowing classification of multiple distinct errors (e.g. `INVALID_GSTIN`, `INVALID_CAPTCHA`, `NOT_FOUND`) with tailored actions (`RETRY_CAPTCHA`, `BUSINESS_ERROR`, `ABORT_SESSION`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "app-manager-edge-worker",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "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/banner.js

@@ -1,7 +1,7 @@
 import { createRequire } from "module";
 
 const require = createRequire(import.meta.url);
-let workerVersion = "1.3.0";
+let workerVersion = "1.3.1";
 try {
     const pkg = require("../package.json");
     if (pkg?.version) workerVersion = pkg.version;

package/src/client.js

@@ -20,7 +20,7 @@ import fs from "fs";
 import { getWhatsAppHandler } from "./handlers/whatsappHandler.js";
 import { printBanner, logInfo, logSuccess, logWarn, logError, logJob } from "./banner.js";
 
-let workerPkgVersion = "1.3.0";
+let workerPkgVersion = "1.3.1";
 try {
     const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
     if (pkg?.version) workerPkgVersion = pkg.version;

package/src/handlers/interactiveHandler.js

@@ -1,6 +1,7 @@
 import crypto from "crypto";
 import localBrowserManager from "../browser.js";
 import { runTransformPipeline, castValueToType } from "./transformUtils.js";
+import { logInfo, logWarn, logError } from "../banner.js";
 
 /**
  * In-memory map of active interactive sessions on this Edge Worker.
@@ -93,6 +94,82 @@ async function purgeSession(sessionId) {
     activeSessions.delete(sessionId);
 }
 
+/**
+ * Constructs a robust set of CSS selectors for an input field based on its configured selector and paramKey.
+ * Handles IDs, name attributes, ng-model attributes, placeholders, and comma-separated selectors.
+ */
+function buildRobustInputSelectors(selector, paramKey) {
+    const set = new Set();
+    if (selector && typeof selector === "string") {
+        selector.split(",").map((s) => s.trim()).filter(Boolean).forEach((s) => set.add(s));
+
+        // If selector contains [name="xxx"] or [name='xxx'], extract the name
+        const nameMatch = selector.match(/\[name=["']?([^"'\]\s]+)["']?\]/i);
+        if (nameMatch && nameMatch[1]) {
+            const name = nameMatch[1];
+            set.add(`#${name}`);
+            set.add(`input[name="${name}"]`);
+            set.add(`[name="${name}"]`);
+            set.add(`input#${name}`);
+        }
+
+        // If selector contains #xxx or [id="xxx"], extract the id
+        const idMatch = selector.match(/#([a-zA-Z0-9_\-]+)/) || selector.match(/\[id=["']?([^"'\]\s]+)["']?\]/i);
+        if (idMatch && idMatch[1]) {
+            const id = idMatch[1];
+            set.add(`#${id}`);
+            set.add(`input[name="${id}"]`);
+            set.add(`[name="${id}"]`);
+            set.add(`input#${id}`);
+        }
+    }
+
+    if (paramKey && typeof paramKey === "string") {
+        const pk = paramKey.trim();
+        set.add(`#${pk}`);
+        set.add(`input[name="${pk}"]`);
+        set.add(`[name="${pk}"]`);
+        set.add(`input[data-ng-model*="${pk}"]`);
+        set.add(`input[ng-model*="${pk}"]`);
+        set.add(`input[placeholder*="${pk}" i]`);
+    }
+
+    return Array.from(set);
+}
+
+/**
+ * Searches for an element in the main page or any child iframe, waiting up to timeoutMs.
+ * Returns { target: page | frame, element, matchedSelector } or null.
+ */
+async function locateElementInPageOrFrames(page, selectorList, timeoutMs = 15000) {
+    const combinedSelector = Array.isArray(selectorList) ? selectorList.join(", ") : String(selectorList);
+
+    // 1. Try waiting on the top page first
+    try {
+        const el = await page.waitForSelector(combinedSelector, { timeout: timeoutMs });
+        if (el) {
+            return { target: page, element: el, matchedSelector: combinedSelector };
+        }
+    } catch (_) {
+        // Top-level wait timed out or failed; inspect child frames next
+    }
+
+    // 2. Scan child frames/iframes if not found on top-level page
+    try {
+        const frames = page.frames();
+        for (const frame of frames) {
+            try {
+                const fEl = await frame.$(combinedSelector);
+                if (fEl) {
+                    return { target: frame, element: fEl, matchedSelector: combinedSelector };
+                }
+            } catch (_) {}
+        }
+    } catch (_) {}
+
+    return null;
+}
+
 /**
  * 1. Handles HITL_SESSION_INIT:
  *    Launches page, pre-fills initial form inputs, captures captcha screenshot,
@@ -106,6 +183,7 @@ export async function handleInteractiveSessionInit(payload) {
         captchaConfig = {},
         preScrapeActions = [],
         authentication = null,
+        navigation = {},
         timeoutMs = 30000,
         fieldMappings = [],
         collections = [],
@@ -146,10 +224,13 @@ export async function handleInteractiveSessionInit(payload) {
             }
         }
 
-        // Navigate to target portal
-        await page.goto(url, { waitUntil: "domcontentloaded", timeout: timeoutMs });
+        // Navigate to target portal with flexible waitUntil and realistic timeout
+        const navTimeout = navigation.timeoutMs || timeoutMs || 30000;
+        const navWaitUntil = navigation.waitUntil || "domcontentloaded";
+
+        await page.goto(url, { waitUntil: navWaitUntil, timeout: navTimeout });
         try {
-            await page.waitForNetworkIdle({ idleTime: 500, timeout: 3500 }).catch(() => {});
+            await page.waitForNetworkIdle({ idleTime: 500, timeout: 4000 }).catch(() => {});
         } catch (_) {}
 
         // Execute pre-scrape actions if present
@@ -157,14 +238,15 @@ export async function handleInteractiveSessionInit(payload) {
             for (const action of preScrapeActions) {
                 try {
                     const actType = (action.type || action.actionType || "").toUpperCase();
+                    const actionTimeout = Math.max(action.timeoutMs || 0, 10000);
                     if (actType === "CLICK" && action.selector) {
-                        await page.waitForSelector(action.selector, { timeout: action.timeoutMs || 4000 });
+                        await page.waitForSelector(action.selector, { timeout: actionTimeout });
                         await page.click(action.selector);
                     } else if (actType === "TYPE" && action.selector) {
-                        await page.waitForSelector(action.selector, { timeout: action.timeoutMs || 4000 });
+                        await page.waitForSelector(action.selector, { timeout: actionTimeout });
                         await page.type(action.selector, action.value || "", { delay: 30 });
                     } else if (actType === "WAIT_FOR" && action.selector) {
-                        await page.waitForSelector(action.selector, { timeout: action.timeoutMs || 8000 });
+                        await page.waitForSelector(action.selector, { timeout: actionTimeout });
                     }
                     if (action.delayMs > 0) {
                         await new Promise((r) => setTimeout(r, Math.min(action.delayMs, 4000)));
@@ -175,47 +257,98 @@ export async function handleInteractiveSessionInit(payload) {
             }
         }
 
-        // Fill Form Inputs (e.g. GSTIN, PAN, registration number)
+        // Fill Form Inputs (e.g. GSTIN, PAN, registration number) with robust selector fallbacks & frame support
         if (Array.isArray(formInputs) && formInputs.length > 0) {
             for (const input of formInputs) {
                 if (!input.selector || input.value === undefined || input.value === null) continue;
-                await page.waitForSelector(input.selector, { timeout: 6000 });
+
+                const inputTimeout = Math.max(input.timeoutMs || 0, timeoutMs || 30000, 20000);
+                const robustSelectors = buildRobustInputSelectors(input.selector, input.paramKey);
+
+                const located = await locateElementInPageOrFrames(page, robustSelectors, inputTimeout);
+                if (!located || !located.element) {
+                    const currentUrl = page.url();
+                    const pageTitle = (await page.title().catch(() => "")) || "Untitled";
+                    logWarn(
+                        `[HITL_SESSION_INIT] Input selector '${input.selector}' (or fallbacks: ${robustSelectors.join(", ")}) not found after ${inputTimeout}ms on page "${pageTitle}" (${currentUrl})`
+                    );
+                    throw new Error(
+                        `Waiting for selector '${input.selector}' failed on page "${pageTitle}" (${currentUrl}) after ${inputTimeout}ms. Ensure portal is reachable and selector is correct.`
+                    );
+                }
+
+                const { target, element, matchedSelector } = located;
 
                 if (input.clearFirst !== false) {
-                    await page.click(input.selector, { clickCount: 3 }).catch(() => {});
+                    await element.click({ clickCount: 3 }).catch(() => {});
                     await page.keyboard.press("Backspace").catch(() => {});
                 }
 
                 if (input.actionType === "SELECT") {
-                    await page.select(input.selector, String(input.value));
+                    await target.select(matchedSelector, String(input.value));
                 } else {
-                    await page.type(input.selector, String(input.value), { delay: input.delayMs || 30 });
+                    await element.type(String(input.value), { delay: input.delayMs || 30 });
                 }
 
-                // Explicitly dispatch input, change, and blur events to trigger AngularJS/React/portal validation listeners
-                await page.evaluate((sel) => {
+                // Explicitly dispatch input, change, keydown, keyup, and blur events, plus sync AngularJS ngModel if present
+                await target.evaluate((sel) => {
                     const el = document.querySelector(sel);
                     if (el) {
                         el.dispatchEvent(new Event("input", { bubbles: true }));
                         el.dispatchEvent(new Event("change", { bubbles: true }));
+                        el.dispatchEvent(new KeyboardEvent("keydown", { bubbles: true, key: "Enter" }));
+                        el.dispatchEvent(new KeyboardEvent("keyup", { bubbles: true, key: "Enter" }));
                         el.dispatchEvent(new Event("blur", { bubbles: true }));
+
+                        // AngularJS scope & ngModel synchronization
+                        if (window.angular) {
+                            try {
+                                const ngEl = window.angular.element(el);
+                                const ngModel = ngEl.controller("ngModel");
+                                if (ngModel) {
+                                    ngModel.$setViewValue(el.value);
+                                    ngModel.$render();
+                                    ngModel.$commitViewValue();
+                                }
+                                const scope = ngEl.scope();
+                                if (scope && !scope.$$phase) {
+                                    scope.$apply();
+                                }
+                            } catch (_) {}
+                        }
                     }
-                }, input.selector).catch(() => {});
-                await page.keyboard.press("Tab").catch(() => {});
+                }, matchedSelector).catch(() => {});
 
-                await new Promise((r) => setTimeout(r, 250));
+                await page.keyboard.press("Tab").catch(() => {});
+                await new Promise((r) => setTimeout(r, 300));
             }
         }
 
-        // Locate and Screenshot Captcha DOM Element
-        const imageSelector = captchaConfig.imageSelector || "img[src*='captcha'], #imgCaptcha, #captchaImg";
-        await page.waitForSelector(imageSelector, { timeout: 8000 });
-
-        const captchaElement = await page.$(imageSelector);
-        if (!captchaElement) {
-            throw new Error(`Captcha element not found with selector: ${imageSelector}`);
+        // Locate and Screenshot Captcha DOM Element with robust candidate fallbacks
+        const imageTimeout = Math.max(captchaConfig.timeoutMs || 0, timeoutMs || 30000, 15000);
+        const candidateImageSelectors = [
+            captchaConfig.imageSelector,
+            "#imgCaptcha",
+            "#captchaImg",
+            "img[src*='captcha' i]",
+            "img[id*='captcha' i]",
+            "img[alt*='captcha' i]",
+            "canvas[id*='captcha' i]",
+            ".captcha-image img",
+            "#captcha_image",
+        ].filter(Boolean);
+
+        const locatedImage = await locateElementInPageOrFrames(page, candidateImageSelectors, imageTimeout);
+        if (!locatedImage || !locatedImage.element) {
+            const currentUrl = page.url();
+            const pageTitle = (await page.title().catch(() => "")) || "Untitled";
+            throw new Error(
+                `Captcha element not found with selector '${captchaConfig.imageSelector || candidateImageSelectors[0]}' on page "${pageTitle}" (${currentUrl}) after ${imageTimeout}ms`
+            );
         }
 
+        const captchaElement = locatedImage.element;
+
         // Capture screenshot of the exact visual captcha DOM node
         const screenshotBuffer = await captchaElement.screenshot({
             encoding: "binary",
@@ -291,19 +424,29 @@ export async function handleInteractiveSessionRefresh(payload) {
     const imageSelector = cfg.imageSelector || "img[src*='captcha'], #imgCaptcha";
     const refreshSelector = cfg.refreshSelector;
 
+    const candidateImageSelectors = [
+        cfg.imageSelector,
+        "#imgCaptcha",
+        "#captchaImg",
+        "img[src*='captcha' i]",
+        "img[id*='captcha' i]",
+    ].filter(Boolean);
+
     // 1. Snapshot current image hash and src attribute
-    const oldEl = await page.$(imageSelector);
-    if (!oldEl) {
+    const locatedOldImg = await locateElementInPageOrFrames(page, candidateImageSelectors, 8000);
+    if (!locatedOldImg || !locatedOldImg.element) {
         throw new Error(`Captcha element not found with selector: ${imageSelector}`);
     }
+    const oldEl = locatedOldImg.element;
+    const effectiveImageSelector = locatedOldImg.matchedSelector;
 
     const oldBuffer = await oldEl.screenshot({ encoding: "binary" });
     const oldHash = crypto.createHash("md5").update(oldBuffer).digest("hex");
 
-    const oldSrc = await page.evaluate((sel) => {
+    const oldSrc = await locatedOldImg.target.evaluate((sel) => {
         const el = document.querySelector(sel);
         return el ? el.getAttribute("src") : null;
-    }, imageSelector);
+    }, effectiveImageSelector);
 
     // 2. Click the reload button with robust candidate fallbacks
     const candidateSelectors = [
@@ -328,9 +471,9 @@ export async function handleInteractiveSessionRefresh(payload) {
     let clicked = false;
     for (const sel of candidateSelectors) {
         try {
-            const btn = await page.$(sel);
-            if (btn) {
-                await btn.click();
+            const locatedBtn = await locateElementInPageOrFrames(page, [sel], 500);
+            if (locatedBtn && locatedBtn.element) {
+                await locatedBtn.element.click();
                 clicked = true;
                 break;
             }
@@ -442,15 +585,70 @@ export async function handleInteractiveSessionSolve(payload) {
 
     const invalidPattern = cfg.errorDetection?.invalidCaptchaPattern || "captcha.*(incorrect|invalid|wrong|mismatch|enter text)";
 
-    // 1. Type captcha solution
-    await page.waitForSelector(inputSelector, { timeout: 4000 });
-    await page.click(inputSelector, { clickCount: 3 }).catch(() => {});
+    // 1. Type captcha solution with robust candidate fallbacks & frame search
+    const solveTimeout = Math.max(cfg.inputTimeoutMs || 0, 15000);
+    const candidateInputSelectors = [
+        inputSelector,
+        "#fo-captcha",
+        "#captcha",
+        "input[name='cap']",
+        "input[name*='captcha' i]",
+        "input[id*='captcha' i]",
+        "input[placeholder*='captcha' i]",
+    ].filter(Boolean);
+
+    const locatedInput = await locateElementInPageOrFrames(page, candidateInputSelectors, solveTimeout);
+    if (!locatedInput || !locatedInput.element) {
+        throw new Error(`Captcha input field not found with selector: ${inputSelector}`);
+    }
+
+    await locatedInput.element.click({ clickCount: 3 }).catch(() => {});
     await page.keyboard.press("Backspace").catch(() => {});
-    await page.type(inputSelector, String(captchaSolution).trim(), { delay: 35 });
+    await locatedInput.element.type(String(captchaSolution).trim(), { delay: 35 });
+
+    // Sync input events and AngularJS ngModel for captcha input
+    await locatedInput.target.evaluate((sel) => {
+        const el = document.querySelector(sel);
+        if (el) {
+            el.dispatchEvent(new Event("input", { bubbles: true }));
+            el.dispatchEvent(new Event("change", { bubbles: true }));
+            el.dispatchEvent(new KeyboardEvent("keydown", { bubbles: true, key: "Enter" }));
+            el.dispatchEvent(new KeyboardEvent("keyup", { bubbles: true, key: "Enter" }));
+            el.dispatchEvent(new Event("blur", { bubbles: true }));
+
+            if (window.angular) {
+                try {
+                    const ngEl = window.angular.element(el);
+                    const ngModel = ngEl.controller("ngModel");
+                    if (ngModel) {
+                        ngModel.$setViewValue(el.value);
+                        ngModel.$render();
+                        ngModel.$commitViewValue();
+                    }
+                    const scope = ngEl.scope();
+                    if (scope && !scope.$$phase) scope.$apply();
+                } catch (_) {}
+            }
+        }
+    }, locatedInput.matchedSelector).catch(() => {});
+
+    // 2. Click submit button with candidate fallbacks & frame search
+    const candidateSubmitSelectors = [
+        submitSelector,
+        "#lotsearch",
+        "button[type='submit']",
+        "input[type='submit']",
+        "button[id*='search' i]",
+        "button[id*='submit' i]",
+        "button.btn-primary",
+    ].filter(Boolean);
+
+    const locatedSubmit = await locateElementInPageOrFrames(page, candidateSubmitSelectors, solveTimeout);
+    if (!locatedSubmit || !locatedSubmit.element) {
+        throw new Error(`Submit button not found with selector: ${submitSelector}`);
+    }
 
-    // 2. Click submit button
-    await page.waitForSelector(submitSelector, { timeout: 4000 });
-    await page.click(submitSelector);
+    await locatedSubmit.element.click();
 
     // 3. Post-Submit Race: Wait for Success Selector OR Error Selector
     // In inspection mode, use a shorter safety window (5-7s) so users aren't stalled waiting on empty selectors