webpilot-engine 2.0.0__py3-none-any.whl

services/field_interaction_service.py

@@ -0,0 +1,174 @@
+"""Field value setting and DOM verification service."""
+
+from __future__ import annotations
+
+from typing import Any
+from playwright.sync_api import Page
+
+from adapters.dom_scripts import (
+    SET_FIELD_DOM_SCRIPT,
+    PICKLIST_AUTO_SCROLL_SCRIPT,
+    VERIFY_FIELD_DOM_SCRIPT,
+)
+from constants.timeouts import (
+    PAUSE_INPUT_SET_MS,
+    PAUSE_RETRY_FALLBACK_MS,
+    PAUSE_PICKLIST_EXPAND_MS,
+    PAUSE_PICKLIST_CLOSE_MS,
+)
+
+
+class FieldInteractionService:
+    """Sets form field values across standard and complex enterprise widgets and verifies DOM state."""
+
+    def __init__(self, page: Page):
+        self.page = page
+
+    def set_field(self, target_identifier: str, value: Any) -> bool:
+        """Sets field value according to its widget type using JS manipulation or Playwright fallback."""
+        res = self.page.evaluate(SET_FIELD_DOM_SCRIPT, [target_identifier, value])
+
+        # Picklist: trigger button click + scoped auto-scrolling
+        if res.get("type") == "picklist" and res.get("trigger_button"):
+            try:
+                btn_loc = self.page.locator(f'[id="{res["trigger_button"]}"]').first
+                if btn_loc.is_visible(timeout=1500):
+                    btn_loc.scroll_into_view_if_needed()
+                    btn_loc.click(force=True)
+                    self.page.wait_for_timeout(PAUSE_PICKLIST_EXPAND_MS)
+
+                    pick_res = self.page.evaluate(PICKLIST_AUTO_SCROLL_SCRIPT, [res["id"], value])
+
+                    if pick_res.get("success"):
+                        self.page.wait_for_timeout(300)
+                        return True
+                    else:
+                        self.page.keyboard.press("Escape")
+                        self.page.wait_for_timeout(PAUSE_PICKLIST_CLOSE_MS)
+            except Exception as exc:
+                print(f"    [!] Picklist click error: {exc}")
+
+        # Non-picklist JS success
+        if res.get("success") and res.get("type") not in ("picklist",):
+            return True
+
+        # Fallback to Playwright native interaction
+        return self._playwright_click_fallback(target_identifier, value)
+
+    def _playwright_click_fallback(self, target: str, value: Any) -> bool:
+        """Fallback setter using Playwright native locators (click / fill)."""
+        page = self.page
+        strval = str(value)
+        lower = target.lower().strip()
+
+        # 1. Picklist combobox by aria-label or title
+        for loc in [
+            page.locator(f'input[aria-label*="{target}"][role="combobox"]'),
+            page.locator(f'input[title*="{target}"][role="combobox"]'),
+        ]:
+            try:
+                if loc.count() > 0 and loc.first.is_visible(timeout=300):
+                    loc.first.click()
+                    page.wait_for_timeout(300)
+                    for role_name in ["menuitem", "option", "listitem"]:
+                        opt = page.get_by_role(role_name, name=strval, exact=False)  # type: ignore
+                        if opt.count() > 0:
+                            opt.first.click()
+                            page.wait_for_timeout(PAUSE_RETRY_FALLBACK_MS)
+                            return True
+                    page.keyboard.press("Escape")
+            except Exception:
+                pass
+
+        # 2. Native radio by ARIA role
+        try:
+            radio = page.get_by_role("radio", name=strval, exact=False)
+            if radio.count() > 0:
+                radio.first.click()
+                return True
+        except Exception:
+            pass
+
+        # 3. Custom ARIA radioLabel spans (SuccessFactors)
+        for selector in [
+            f'.radioLabel:text-is("{strval}")',
+            f'.radioLabel:has-text("{strval}")',
+        ]:
+            try:
+                spans = page.locator(selector)
+                if spans.count() > 0:
+                    spans.first.click()
+                    return True
+            except Exception:
+                pass
+
+        # 4. Text / Textarea via label
+        try:
+            field = page.get_by_label(lower, exact=False)
+            if field.count() > 0 and field.first.is_visible(timeout=300):
+                field.first.fill(strval)
+                field.first.dispatch_event("change")
+                return True
+        except Exception:
+            pass
+
+        # 5. Text via placeholder
+        try:
+            field = page.get_by_placeholder(lower, exact=False)
+            if field.count() > 0 and field.first.is_visible(timeout=300):
+                field.first.fill(strval)
+                field.first.dispatch_event("change")
+                return True
+        except Exception:
+            pass
+
+        # 6. Username / Email generic heuristic
+        if lower in ("username", "user", "email", "login", "user name", "email address"):
+            for sel in [
+                'input[type="email"]',
+                'input[name*="user" i]',
+                'input[id*="user" i]',
+                'input[name*="email" i]',
+                'input[id*="email" i]',
+                'input[autocomplete="username"]',
+                'input[autocomplete="email"]',
+            ]:
+                try:
+                    f = page.locator(sel)
+                    if f.count() > 0 and f.first.is_visible(timeout=300):
+                        f.first.fill(strval)
+                        f.first.dispatch_event("input")
+                        f.first.dispatch_event("change")
+                        return True
+                except Exception:
+                    pass
+
+        # 7. Password generic heuristic
+        if lower in ("password", "pass", "pwd", "user password"):
+            try:
+                f = page.locator('input[type="password"]')
+                if f.count() > 0 and f.first.is_visible(timeout=300):
+                    f.first.fill(strval)
+                    f.first.dispatch_event("input")
+                    f.first.dispatch_event("change")
+                    return True
+            except Exception:
+                pass
+
+        return False
+
+    def verify_field_value(self, target: str, expected: Any) -> bool:
+        """Reads back current DOM value and checks if it matches expected."""
+        expected_str = str(expected).strip().lower()
+        junk = {"login/ view profile", "no selection", ""}
+
+        try:
+            actual = self.page.evaluate(VERIFY_FIELD_DOM_SCRIPT, [target, expected_str])
+            if actual is None:
+                return False
+            actual_lower = str(actual).strip().lower()
+            if actual_lower in junk:
+                return False
+            return expected_str in actual_lower
+        except Exception:
+            return False

services/form_filler_service.py

@@ -0,0 +1,106 @@
+"""Sequential form filling orchestration service."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Tuple
+from playwright.sync_api import Page
+
+from constants.selectors import SELECTOR_SECTION_BUTTON
+from constants.timeouts import PAUSE_INPUT_SET_MS, PAUSE_RETRY_FALLBACK_MS
+from services.field_interaction_service import FieldInteractionService
+
+
+class FormFillerService:
+    """Orchestrates section-by-section and global sequential form filling."""
+
+    def __init__(self, page: Page, field_service: FieldInteractionService):
+        self.page = page
+        self.field_service = field_service
+
+    def fill_form_sequential(self, field_mappings: List[Tuple[str, Any]]) -> Dict[str, List[Tuple[str, Any]]]:
+        """Universal sequential form filler. Opens one section, fills matching fields, then advances."""
+        results: Dict[str, List[Tuple[str, Any]]] = {
+            "confirmed": [],
+            "unconfirmed": [],
+            "failed": [],
+        }
+
+        pending = list(field_mappings)
+        section_count = self.page.locator(SELECTOR_SECTION_BUTTON).count()
+        print(f"[*] Sequential fill: {len(pending)} fields across {section_count} sections.")
+
+        def try_fill(key: str, val: Any) -> str:
+            """Attempt fill + DOM verify. Returns 'confirmed', 'unconfirmed', or 'failed'."""
+            success = self.field_service.set_field(key, val)
+            if not success:
+                return "failed"
+
+            self.page.wait_for_timeout(PAUSE_INPUT_SET_MS)
+            if self.field_service.verify_field_value(key, val):
+                return "confirmed"
+
+            # One retry via pure Playwright click
+            self.page.wait_for_timeout(PAUSE_RETRY_FALLBACK_MS)
+            self.field_service._playwright_click_fallback(key, val)
+            self.page.wait_for_timeout(PAUSE_RETRY_FALLBACK_MS)
+            if self.field_service.verify_field_value(key, val):
+                return "confirmed"
+            return "unconfirmed"
+
+        # Pass 1: Section by section
+        for sec_idx in range(section_count):
+            if not pending:
+                break
+
+            sec_btn = self.page.locator(SELECTOR_SECTION_BUTTON).nth(sec_idx)
+            try:
+                sec_label = sec_btn.inner_text(timeout=800).strip()[:50]
+            except Exception:
+                sec_label = f"Section {sec_idx + 1}"
+
+            try:
+                is_collapsed = sec_btn.get_attribute("aria-expanded") == "false"
+                if is_collapsed:
+                    sec_btn.scroll_into_view_if_needed()
+                    sec_btn.click(force=True)
+                    self.page.wait_for_timeout(400)
+                    print(f"  [▶] Opened: {sec_label}")
+                else:
+                    print(f"  [=] Already open: {sec_label}")
+            except Exception:
+                print(f"  [?] Could not check/open: {sec_label}")
+
+            still_pending = []
+            for key, val in pending:
+                status = try_fill(key, val)
+                if status == "confirmed":
+                    results["confirmed"].append((key, val))
+                    print(f"    [✓] {key!r} -> {val!r}")
+                elif status == "unconfirmed":
+                    still_pending.append((key, val))
+                else:
+                    still_pending.append((key, val))
+
+            pending = still_pending
+
+        # Pass 2: Global retry for unmatched fields
+        if pending:
+            print(f"\n[*] Pass 2: {len(pending)} field(s) not matched in any section — trying globally...")
+            for key, val in pending:
+                status = try_fill(key, val)
+                if status == "confirmed":
+                    results["confirmed"].append((key, val))
+                    print(f"  [✓] {key!r} -> {val!r}")
+                elif status == "unconfirmed":
+                    results["unconfirmed"].append((key, val))
+                    print(f"  [?] Not confirmed: {key!r} -> {val!r}")
+                else:
+                    results["failed"].append((key, val))
+                    print(f"  [✗] Failed: {key!r} -> {val!r}")
+
+        print(
+            f"\n[*] Fill summary: ✓{len(results['confirmed'])} confirmed | "
+            f"?{len(results['unconfirmed'])} unconfirmed | "
+            f"✗{len(results['failed'])} failed"
+        )
+        return results

services/inspection_formatter_service.py

@@ -0,0 +1,68 @@
+"""Inspection summary formatting service."""
+
+from typing import Any, Dict
+
+class InspectionFormatterService:
+    """Formats raw inspection schema into a concise, token-optimized summary."""
+
+    @staticmethod
+    def format_summary(data: Dict[str, Any]) -> str:
+        """Returns a concise, human-readable summary of the inspected form."""
+        lines = []
+        lines.append(f"=== FORM INSPECTION SUMMARY: '{data.get('title')}' ===")
+        lines.append(f"URL: {data.get('url')}\n")
+
+        # Sections
+        sections = data.get("sections", [])
+        if sections:
+            lines.append(f"📁 Sections ({len(sections)}): " + ", ".join(sections))
+            lines.append("")
+
+        # Inputs
+        inputs = data.get("inputs", [])
+        lines.append(f"📝 Text & Numeric Input Fields ({len(inputs)}):")
+        for inp in inputs:
+            req_flag = " [REQUIRED]" if inp.get("required") else ""
+            cur = f" = '{inp['value']}'" if inp.get("value") else ""
+            lines.append(f"  • Label: '{inp['label']}' (ID: {inp['id']}){req_flag}{cur}")
+        lines.append("")
+
+        # Dropdowns
+        dropdowns = data.get("dropdowns", [])
+        lines.append(f"🔽 Dropdowns & Picklists ({len(dropdowns)}):")
+        for dd in dropdowns:
+            req_flag = " [REQUIRED]" if dd.get("required") else ""
+            cur = f" = '{dd['value']}'" if dd.get("value") else ""
+            opts = dd.get("sample_options") or []
+            sample_str = f" [Sample: {', '.join(opts[:4])}]" if opts else ""
+            lines.append(f"  • Label: '{dd['label']}' (ID: {dd['id']}){req_flag}{cur}{sample_str}")
+        lines.append("")
+
+        # Choices
+        choices = data.get("choices", [])
+        lines.append(f"🔘 Choice Groups (Radio / Checkbox) ({len(choices)}):")
+        for ch in choices:
+            req_flag = " [REQUIRED]" if ch.get("required") else ""
+            opts_str = ", ".join(ch.get("options", []))
+            sel = f" [Selected: {ch['selected']}]" if ch.get("selected") else ""
+            lines.append(f"  • Question: '{ch['question']}'{req_flag} -> [{opts_str}]{sel}")
+        lines.append("")
+
+        # File Uploads
+        uploads = data.get("file_uploads", [])
+        lines.append(f"📎 File Upload Areas ({len(uploads)}):")
+        for up in uploads:
+            req_flag = " [REQUIRED]" if up.get("required") else ""
+            lines.append(f"  • Label: '{up['label']}' (ID: {up['id']}){req_flag}")
+        if data.get("already_uploaded_files"):
+            lines.append(f"    Already attached: {data['already_uploaded_files']}")
+        lines.append("")
+
+        # Action Buttons
+        buttons = data.get("buttons", [])
+        lines.append(f"🔘 Key Action Buttons ({len(buttons)}):")
+        for btn in buttons:
+            lines.append(f"  • [{btn.get('action', 'action').upper()}] '{btn['text']}' (ID: {btn['id']})")
+        lines.append("")
+
+        return "\n".join(lines)

services/inspection_service.py

@@ -0,0 +1,40 @@
+"""Form schema inspection service."""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+from playwright.sync_api import Page
+from adapters.dom_scripts import INSPECT_PAGE_DOM_SCRIPT, PROBE_PICKLIST_OPTIONS_SCRIPT
+
+class InspectionService:
+    """Inspects webpage DOM and produces structured form schema."""
+
+    def __init__(self, page: Page):
+        self.page = page
+
+    def inspect(self, unpack_options: bool = True) -> Dict[str, Any]:
+        """Deep inspection of the active page. Extracts form components, inputs, buttons, and uploads."""
+        raw = self.page.evaluate(INSPECT_PAGE_DOM_SCRIPT)
+
+        if unpack_options:
+            print("[*] Probing picklist samples (unpack_options=True)...")
+            for dd in raw.get("dropdowns", []):
+                btn_id = dd.get("trigger_id")
+                if btn_id and self.page.locator(f'[id="{btn_id}"]').count() > 0:
+                    try:
+                        btn_loc = self.page.locator(f'[id="{btn_id}"]').first
+                        if btn_loc.is_visible():
+                            btn_loc.click(force=True)
+                            self.page.wait_for_timeout(300)
+                            base_id = dd["id"].replace(":_input", "")
+                            owns_id = f"{base_id}:_listSelect"
+                            opts = self.page.evaluate(PROBE_PICKLIST_OPTIONS_SCRIPT, owns_id)
+                            if opts:
+                                dd["options_count"] = len(opts)
+                                dd["sample_options"] = opts[:5]
+                            self.page.keyboard.press("Escape")
+                            self.page.wait_for_timeout(100)
+                    except Exception:
+                        pass
+
+        return raw

services/reactive_interaction_service.py

@@ -0,0 +1,174 @@
+"""Reactive button clicking and state observation service."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+from playwright.sync_api import BrowserContext, Page
+
+from adapters.dom_scripts import CLICK_BUTTON_DOM_SCRIPT
+from constants.selectors import SELECTOR_MODAL_DIALOGS
+from constants.timeouts import PAUSE_REACTIVE_STABILIZE_MS
+from services.inspection_service import InspectionService
+from validators.form_validator import FormValidator
+
+
+class ReactiveInteractionService:
+    """Clicks buttons and actively tracks environmental mutations (tabs, routes, modals, fields)."""
+
+    def __init__(
+        self,
+        page: Page,
+        context: BrowserContext,
+        inspection_service: InspectionService,
+        form_validator: FormValidator,
+        on_active_page_change: Optional[Callable[[Page], None]] = None,
+    ):
+        self.page = page
+        self.context = context
+        self.inspection_service = inspection_service
+        self.form_validator = form_validator
+        self.on_active_page_change = on_active_page_change
+
+    def click_button(self, button_text_or_purpose: str) -> Dict[str, Any]:
+        """Intelligently clicks a button/link and monitors reactive consequences."""
+        target = button_text_or_purpose.strip()
+
+        # 1. Baseline state
+        pre_url = self.page.url
+        pre_tabs_count = len(self.context.pages)
+        pre_inputs_count = self.page.locator("input, select, textarea").count()
+        pre_modals_count = self.page.locator(SELECTOR_MODAL_DIALOGS).count()
+
+        clicked = False
+
+        # Strategy A: Native ID
+        clean_id = target.lstrip("#")
+        try:
+            loc = self.page.locator(f"#{clean_id}")
+            if loc.count() > 0 and loc.first.is_visible():
+                loc.first.click()
+                clicked = True
+        except Exception:
+            pass
+
+        # Strategy B: Native Text / Role
+        if not clicked:
+            try:
+                for selector in [
+                    f"button:has-text('{target}')",
+                    f"a:has-text('{target}')",
+                    f"[role='button']:has-text('{target}')",
+                    f"input[type='button'][value*='{target}']",
+                    f"input[type='submit'][value*='{target}']",
+                    f".modal-footer p:has-text('{target}')",
+                    f"p:has-text('{target}')",
+                    f"span:has-text('{target}')",
+                ]:
+                    cand = self.page.locator(selector)
+                    if cand.count() > 0 and cand.first.is_visible():
+                        cand.first.click()
+                        clicked = True
+                        break
+            except Exception:
+                pass
+
+        # Strategy C: JavaScript fallback
+        if not clicked:
+            clicked = self.page.evaluate(CLICK_BUTTON_DOM_SCRIPT, target)
+
+        # Strategy D: Modal Dismiss / Escape fallback
+        if not clicked and target.lower().strip() in ("close", "dismiss", "cancel", "escape"):
+            try:
+                self.page.keyboard.press("Escape")
+                clicked = True
+            except Exception:
+                pass
+
+        if not clicked:
+            return {"success": False, "target": target}
+
+        # 2. Wait for reactive stabilization and loading overlay dissolution
+        self.page.wait_for_timeout(PAUSE_REACTIVE_STABILIZE_MS)
+        try:
+            self.page.wait_for_load_state("domcontentloaded", timeout=4000)
+        except Exception:
+            pass
+
+        self._wait_for_loading_dissolution()
+
+        # 3. Assess reactive changes
+        outcome: Dict[str, Any] = {
+            "success": True,
+            "target": target,
+            "redirected": False,
+            "new_window": False,
+            "new_url": None,
+            "modal_opened": False,
+            "modal_text": "",
+            "new_inputs_count": 0,
+            "schema": None,
+            "alerts": self.form_validator.get_validation_errors(),
+        }
+
+        # Check for new window / tab
+        if len(self.context.pages) > pre_tabs_count:
+            self.page = self.context.pages[-1]
+            if self.on_active_page_change:
+                self.on_active_page_change(self.page)
+            outcome["new_window"] = True
+            outcome["new_url"] = self.page.url
+            outcome["schema"] = self.inspection_service.inspect(unpack_options=False)
+            return outcome
+
+        # Check for URL redirect / client-side route change
+        post_url = self.page.url
+        if post_url != pre_url:
+            outcome["redirected"] = True
+            outcome["new_url"] = post_url
+            outcome["schema"] = self.inspection_service.inspect(unpack_options=False)
+            return outcome
+
+        # Check for modal / dialog appearance
+        post_modals = self.page.locator(SELECTOR_MODAL_DIALOGS)
+        if post_modals.count() > pre_modals_count:
+            outcome["modal_opened"] = True
+            try:
+                outcome["modal_text"] = post_modals.first.inner_text().strip()[:400]
+            except Exception:
+                pass
+            outcome["schema"] = self.inspection_service.inspect(unpack_options=False)
+            return outcome
+
+        # Check for dynamic DOM form inputs growth
+        post_inputs_count = self.page.locator("input, select, textarea").count()
+        if post_inputs_count > pre_inputs_count:
+            outcome["new_inputs_count"] = post_inputs_count - pre_inputs_count
+            outcome["schema"] = self.inspection_service.inspect(unpack_options=False)
+            return outcome
+
+        return outcome
+
+    def _wait_for_loading_dissolution(self, timeout_ms: int = 10000) -> None:
+        """Detects if a blocking loader, spinner, or progress bar appeared and waits for its dissolution."""
+        try:
+            loader_selectors = [
+                "#loading:visible",
+                ".loading:visible",
+                ".spinner:visible",
+                ".busyIndicator:visible",
+                ".sapUiBusy:visible",
+                "[role='progressbar']:visible",
+                "[aria-busy='true']",
+            ]
+            for sel in loader_selectors:
+                loc = self.page.locator(sel)
+                if loc.count() > 0 and loc.first.is_visible():
+                    print(f"[*] Blocking loader detected ('{sel}'). Waiting for completion...")
+                    try:
+                        loc.first.wait_for(state="hidden", timeout=timeout_ms)
+                        print("[✓] Loader completed and disappeared.")
+                    except Exception:
+                        pass
+                    break
+        except Exception:
+            pass

supervisor/__init__.py

@@ -0,0 +1,13 @@
+"""Supervisor package for Multi-Tier Master Supervisor & Operational Worker."""
+
+from supervisor.client import SupervisorClient
+from supervisor.contracts import SupervisorActionRequest, SupervisorActionResponse
+from supervisor.master_daemon import MasterSupervisor, run_master_daemon
+
+__all__ = [
+    "SupervisorClient",
+    "SupervisorActionRequest",
+    "SupervisorActionResponse",
+    "MasterSupervisor",
+    "run_master_daemon",
+]