ff-automationv2 1.0.0

package/src/fireflinkData/fireflinkLocators/typeList.ts

@@ -0,0 +1,36 @@
+const elementType: { [key: string]: string } = {
+    'Link': 'link',
+    'Text Field': 'textfield',
+    'Icon': 'icon',
+    'Button': 'button',
+    'Radio Button': 'radioButton',
+    'Text': 'text',
+    'Textarea': 'textarea',
+    'Image': 'image',
+    'Dropdown': 'dropdown',
+    'Checkbox': 'checkbox',
+    'Tab': 'tab',
+    'Action Overflow button': 'action overflow button',
+    'Hamburger menu': 'hamburger icon',
+    'Toggle Button': 'toggle button',
+    'Suggestion': 'suggestion',
+    'Time Picker': 'time picker',
+    'Date Picker': 'date picker',
+    'Toaster Message': 'toaster message',
+    'Card': 'card',
+    'Tooltip': 'tooltip',
+    'Option': 'option',
+    'Calender': 'calender',
+    'Sliders': 'sliders',
+    'Visual Testing': 'visual testing'
+} as const;
+
+export const normalizedElementType: Record<string, string> =
+    Object.fromEntries(
+        Object.entries(elementType).map(([key, value]) => [
+            key.toLowerCase().replace(/\s+/g, ""),
+            value,
+        ])
+    );
+
+

package/src/fireflinkData/fireflinkScript/scriptGenrationData.ts

@@ -0,0 +1,30 @@
+import { IScriptGenerationData } from "../../core/interfaces/scriptGenrationDataInterface.js";
+import { IPayload } from "../../core/interfaces/fireflinkScriptPayloadInterface.js";
+import { FireFlinkApiService } from "../../service/fireflinkApi.service.js";
+import { ScriptRunner } from "../../service/scriptRunner.service.js";
+
+const apiService = new FireFlinkApiService();
+const scriptRunner = new ScriptRunner(apiService);
+
+export class ScriptDataAppender {
+    private data: IScriptGenerationData[] = [];
+    add(item: IScriptGenerationData): void {
+        this.data.push(item);
+    }
+    getData(): IScriptGenerationData[] {
+        return this.data;
+    }
+    produceScriptGenerationData(
+        result: any,
+        payload: IPayload,
+        token: string,
+        serverHost: string
+    ): Promise<any> {
+        return scriptRunner.runScriptFromPayload(
+            result,
+            payload,
+            token,
+            serverHost
+        );
+    }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+
+import { AutomationRunner } from "./core/main/runAutomationScript.js";
+
+export { AutomationRunner };
+

package/src/llmConfig/llmConfiguration.ts

@@ -0,0 +1,26 @@
+
+import { IServiceProviderBaseUrlConfiguration } from "../core/interfaces/llmConfigurationInterface.js";
+export class ServiceProviderBaseUrlProvider
+    implements IServiceProviderBaseUrlConfiguration {
+
+    private readonly baseUrls: Record<string, string> = {
+        Groq: "https://api.groq.com/openai/v1",
+        DefaultFireFlink: "https://api.groq.com/openai/v1",
+        OpenAi: "https://api.openai.com/v1",
+        Anthropic: "https://api.anthropic.com/v1/",
+        Gemini: "https://generativelanguage.googleapis.com/v1beta/openai/"
+    };
+
+    public getBaseUrl(provider: string): string {
+        const url = this.baseUrls[provider];
+
+        if (!url) {
+            throw new Error(`Unsupported service provider: ${provider}`);
+        }
+
+        return url;
+    }
+}
+
+
+

package/src/service/fireflinkApi.service.ts

@@ -0,0 +1,46 @@
+import axios, { AxiosError } from "axios";
+import { IFireFlinkApiService } from "../core/interfaces/fireflinkScriptPayloadInterface.js";
+
+export class FireFlinkApiService implements IFireFlinkApiService {
+
+    async callFireFlinkApi(
+        headers: Record<string, string>,
+        body: any,
+        url: string
+    ): Promise<any> {
+
+        try {
+            const response = await axios.post(url, body, {
+                headers,
+                timeout: 30000,
+            });
+
+            return response.data;
+
+        } catch (error: any) {
+
+            const err = error as AxiosError;
+
+            if (err.code === "ECONNABORTED") {
+                throw new Error(
+                    "Request to FireFlink API timed out",
+                    { cause: error }
+                );
+            }
+
+            if (err.response) {
+                throw new Error(
+                    `HTTP Error ${err.response.status}: ${JSON.stringify(
+                        err.response.data
+                    )}`,
+                    { cause: error }
+                );
+            }
+
+            throw new Error(
+                "Unexpected error while calling FireFlink API",
+                { cause: error }
+            );
+        }
+    }
+}

package/src/service/scriptRunner.service.ts

@@ -0,0 +1,83 @@
+import {
+    IPayload,
+    IScriptRunner,
+    IStep,
+    IFireFlinkApiService,
+} from "../core/interfaces/fireflinkScriptPayloadInterface";
+
+import { logger } from "../utils/logger/logData.js"
+
+export class ScriptRunner implements IScriptRunner {
+    constructor(private apiService: IFireFlinkApiService) { }
+
+    async runScriptFromPayload(
+        result: any[] | [],
+        payload: IPayload,
+        token: string,
+        serverHost: string
+    ): Promise<any> {
+        let stepData: IStep[];
+
+        try {
+            stepData =
+                typeof result === "string" ? JSON.parse(result) : result;
+
+        } catch (error) {
+            logger.error(`Failed to parse final llm data: ${error}`);
+            return;
+        }
+        logger.info("Sending script payload to FireFlink");
+
+        const body = {
+            stepData: stepData,
+            scriptName: payload.scriptName,
+            scriptType: payload.scriptType,
+            projectId: payload.projectId,
+            testCaseId: payload.testCaseId,
+            promptId: payload.promptId,
+            pageDetails: payload.pageDetails,
+            generatedBy: payload.generatedBy,
+            webSocketId: payload.webSocketId,
+            licenseType: payload.licenseType,
+            licenseId: payload.licenseId,
+            userId: payload.userId,
+            topic: payload.topic,
+            projectType: payload.projectType,
+            tokensConsumed: payload.tokensConsumed,
+        };
+        logger.info("PayLoad for Fireflink : ", body)
+        const headers = {
+            Accept: "*/*",
+            "Accept-Language": "en-US,en;q=0.9",
+            "Content-Type": "application/json",
+            projectId: payload.projectId || "",
+            Authorization: `Bearer ${token}`,
+        };
+
+        const url = `${serverHost}/project/optimize/v3/bulk/scripts/script-payload`;
+
+        try {
+            const finalResult = await this.apiService.callFireFlinkApi(
+                headers,
+                JSON.stringify(body),
+                url
+            );
+            if (finalResult) {
+                logger.error(
+                    "Successfully submitted automation script to FireFlink API."
+                );
+            } else {
+                throw new Error(
+                    "FireFlink API responded with an error: " + JSON.stringify(finalResult));
+            }
+            return finalResult;
+        } catch (error: any) {
+            logger.error(
+                `Failed to submit automation script, ${error}`
+            );
+            throw new Error(
+                "Failed to submit automation script", { cause: error }
+            );
+        }
+    }
+}

package/src/utils/DomExtraction/jsForAttributeInjection.ts

@@ -0,0 +1,254 @@
+import type { Browser } from "webdriverio";
+
+export interface AnnotatedDOMResult {
+    dom: string;
+    selectors: Record<string, string>;
+}
+
+export async function getAnnotatedDOM(
+    browser: Browser
+): Promise<AnnotatedDOMResult> {
+
+    return await browser.execute<AnnotatedDOMResult, []>(() => {
+
+        let nodeIndex = 0;
+        const xpaths: Record<string, string> = {};
+
+        // ==========================================================
+        // COVERAGE CHECK
+        // ==========================================================
+        function getCoverageStatus(el: Element): string {
+
+            try {
+                if (!el || !el.getBoundingClientRect) return "any";
+
+                const rect = el.getBoundingClientRect();
+                if (rect.width === 0 || rect.height === 0) return "false";
+
+                const x = rect.left + rect.width / 2;
+                const y = rect.top + rect.height / 2;
+
+                const topEl = el.ownerDocument.elementFromPoint(x, y);
+                if (!topEl) return "false";
+
+                if (topEl === el || el.contains(topEl)) return "false";
+
+                const style = getComputedStyle(topEl);
+
+                if (
+                    style.pointerEvents === "none" ||
+                    style.opacity === "0" ||
+                    style.visibility === "hidden"
+                ) return "false";
+
+                return "true";
+            } catch {
+                return "any";
+            }
+        }
+
+        // ==========================================================
+        // INTERACTIVITY METADATA
+        // ==========================================================
+        function annotateInteractivity(el: Element): void {
+
+            const s = getComputedStyle(el);
+
+            el.setAttribute("element-visibility", s.visibility || "");
+            el.setAttribute("element-pointer-events", s.pointerEvents || "");
+            el.setAttribute("element-zindex", s.zIndex || "");
+            el.setAttribute("element-covered", getCoverageStatus(el));
+        }
+
+        // ==========================================================
+        // GLOBAL XPATH (Shadow + Iframe Safe)
+        // ==========================================================
+        function getXPath(node: Element): string {
+
+            if (!node || node.nodeType !== 1) return "";
+
+            const segments: string[] = [];
+            let current: Node | null = node;
+
+            while (current && current.nodeType === 1) {
+
+                const el = current as Element;
+                const parent = el.parentNode;
+
+                let index = 1;
+
+                if (parent && (parent as Element).children) {
+                    const siblings = Array.from(
+                        (parent as Element).children
+                    ).filter(n => n.tagName === el.tagName);
+
+                    index = siblings.indexOf(el) + 1;
+                }
+
+                segments.unshift(
+                    el.tagName.toLowerCase() + "[" + index + "]"
+                );
+
+                // ---------------------------
+                // Shadow DOM handling
+                // ---------------------------
+                if (parent instanceof ShadowRoot) {
+                    segments.unshift("shadow");
+                    current = parent.host;
+                    continue;
+                }
+
+                // ---------------------------
+                // Iframe root handling
+                // ---------------------------
+                if (
+                    el.ownerDocument !== document &&
+                    el === el.ownerDocument.documentElement
+                ) {
+                    const frameEl =
+                        el.ownerDocument.defaultView?.frameElement as Element | null;
+
+                    if (frameEl && frameEl.getAttribute("ff-xpath")) {
+                        return (
+                            frameEl.getAttribute("ff-xpath") +
+                            "/" +
+                            segments.join("/")
+                        );
+                    }
+                }
+
+                if (!parent || parent.nodeType !== 1) break;
+
+                current = parent;
+            }
+
+            return "/" + segments.join("/");
+        }
+
+        // ==========================================================
+        // PROCESS NODE
+        // ==========================================================
+        function processNode(node: Element): void {
+
+            if (!node || node.nodeType !== 1) return;
+
+            const fireId = `Fire-Flink-${nodeIndex++}`;
+            const xpath = getXPath(node);
+
+            node.setAttribute("ff-inspect", fireId);
+            node.setAttribute("ff-xpath", xpath);
+
+            xpaths[fireId] = xpath;
+
+            annotateInteractivity(node);
+
+            // ---------------------------
+            // Shadow DOM
+            // ---------------------------
+            const shadowRoot = (node as HTMLElement).shadowRoot;
+            if (shadowRoot) {
+                shadowRoot.querySelectorAll("*")
+                    .forEach(el => processNode(el as Element));
+            }
+
+            // ---------------------------
+            // Same-origin iframe
+            // ---------------------------
+            if (node.tagName === "IFRAME") {
+                try {
+                    const doc =
+                        (node as HTMLIFrameElement).contentDocument;
+
+                    if (doc) {
+                        processNode(doc.documentElement);
+                        doc.querySelectorAll("*")
+                            .forEach(el => processNode(el as Element));
+                    }
+                } catch {
+                    node.setAttribute("ff-cross-origin", "true");
+                }
+            }
+
+            node.querySelectorAll(":scope > *")
+                .forEach(el => processNode(el as Element));
+        }
+
+        // ==========================================================
+        // INITIAL INJECTION
+        // ==========================================================
+        document.querySelectorAll("*")
+            .forEach(el => processNode(el as Element));
+
+        // ==========================================================
+        // SERIALIZER
+        // ==========================================================
+        function serializeNode(node: Node): string {
+
+            if (node.nodeType === Node.TEXT_NODE) {
+                return node.textContent || "";
+            }
+
+            if (node.nodeType !== Node.ELEMENT_NODE) return "";
+
+            const el = node as Element;
+            const tag = el.tagName.toLowerCase();
+            let html = `<${tag}`;
+
+            for (const attr of Array.from(el.attributes)) {
+
+                // Avoid dumping large srcdoc inline
+                if (attr.name === "srcdoc") continue;
+
+                html += ` ${attr.name}="${attr.value.replace(/"/g, "&quot;")}"`;
+            }
+
+            html += ">";
+
+            // Shadow DOM serialization
+            const shadowRoot = (el as HTMLElement).shadowRoot;
+            if (shadowRoot) {
+                html += "<!--#shadow-root-open-->";
+                shadowRoot.querySelectorAll("*")
+                    .forEach(child => {
+                        html += serializeNode(child);
+                    });
+                html += "<!--#/shadow-root-->";
+            }
+
+            // Iframe serialization
+            if (
+                tag === "iframe" &&
+                el.getAttribute("ff-cross-origin") !== "true"
+            ) {
+                try {
+                    const doc =
+                        (el as HTMLIFrameElement).contentDocument;
+
+                    if (doc) {
+                        html += "<!--#iframe-content-->";
+                        html += serializeNode(doc.documentElement);
+                        html += "<!--#/iframe-content-->";
+                    }
+                } catch {
+                    // cross-origin iframe, cannot access content 
+                }
+            }
+
+            for (const child of Array.from(el.childNodes)) {
+                html += serializeNode(child);
+            }
+
+            html += `</${tag}>`;
+
+            return html;
+        }
+
+        return {
+            dom:
+                "<!DOCTYPE html>\\n" +
+                serializeNode(document.documentElement),
+            selectors: xpaths
+        };
+
+    });
+}

package/src/utils/javascript/jsFindElement.ts

@@ -0,0 +1,161 @@
+export const Find_element_by_ff_js_script = `
+  const target = arguments[0];
+  const callback = arguments[arguments.length - 1];
+
+  const MAX_WAIT = 2000;
+  const INTERVAL = 50;
+  const start = Date.now();
+
+  // ---------------- FINDER ----------------
+  function findByFfInspect(root) {
+      const visited = new Set();
+      const stack = [{ node: root, frames: [] }];
+
+      while (stack.length > 0) {
+          const { node, frames } = stack.pop();
+          if (!node) continue;
+
+          if (
+              node.nodeType === Node.DOCUMENT_NODE ||
+              node.nodeType === Node.DOCUMENT_FRAGMENT_NODE
+          ) {
+              if (visited.has(node)) continue;
+              visited.add(node);
+          }
+
+          if (node.nodeType === Node.ELEMENT_NODE) {
+
+              if (node.getAttribute && node.getAttribute("ff-inspect") === target) {
+                  return { node, frames };
+              }
+
+              if (node.shadowRoot) {
+                  stack.push({ node: node.shadowRoot, frames });
+              }
+
+              if (node.tagName === "IFRAME") {
+                try {
+                    const doc = node.contentDocument || node.contentWindow?.document;
+                    if (doc) {
+                        const meta = {
+                            id: node.id || null,
+                            name: node.getAttribute("name") || null,
+                            title: node.getAttribute("title") || null,
+                            aria: node.getAttribute("aria-label") || null,
+                            src: node.getAttribute("src") || null,
+                        };
+
+                        stack.push({
+                            node: doc,
+                            frames: [...frames, meta]
+                        });
+                    }
+                } catch (e) {}
+              }
+
+              const kids = node.children || node.childNodes;
+              for (let i = kids.length - 1; i >= 0; i--) {
+                  stack.push({ node: kids[i], frames });
+              }
+          }
+
+          else if (
+              node.nodeType === Node.DOCUMENT_NODE ||
+              node.nodeType === Node.DOCUMENT_FRAGMENT_NODE
+          ) {
+              const kids = node.childNodes;
+              for (let i = kids.length - 1; i >= 0; i--) {
+                  stack.push({ node: kids[i], frames });
+              }
+          }
+      }
+
+      return null;
+  }
+
+  // ---------------- CLICKABILITY ----------------
+  function isClickable(el) {
+      if (!el || el.nodeType !== Node.ELEMENT_NODE) return false;
+      const tag = el.tagName.toLowerCase();
+      if (tag === "button" || tag === "a") return true;
+      if (el.getAttribute("role") === "button") return true;
+      if (tag === "input") {
+          const t = (el.getAttribute("type") || "").toLowerCase();
+          return t === "button" || t === "submit";
+      }
+      return false;
+  }
+
+  function findClickableInside(root) {
+      const queue = [root];
+      while (queue.length) {
+          const node = queue.shift();
+          if (isClickable(node)) return node;
+          const kids = node.children || node.childNodes;
+          for (let k of kids) queue.push(k);
+      }
+      return null;
+  }
+
+  // ---------------- XPATH BUILDER ----------------
+  function buildXPath(el) {
+      if (!el) return null;
+
+      if (el.id) return \`//*[@id="\${el.id}"]\`;
+
+      const name = el.getAttribute("name");
+      if (name) return \`//*[@name="\${name}"]\`;
+
+      const text = el.textContent && el.textContent.trim();
+      if (text && text.length < 50) {
+          const escaped = text.replace(/"/g, '\\\\"');
+          const xp = \`//*[text()="\${escaped}"]\`;
+          try {
+              const n = document.evaluate(xp, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+              if (n.singleNodeValue === el) return xp;
+          } catch {}
+      }
+
+      const parts = [];
+      let node = el;
+
+      while (node && node.nodeType === Node.ELEMENT_NODE) {
+          let idx = 1;
+          let sib = node.previousSibling;
+          while (sib) {
+              if (sib.nodeType === Node.ELEMENT_NODE && sib.nodeName === node.nodeName) idx++;
+              sib = sib.previousSibling;
+          }
+          parts.unshift(node.nodeName.toLowerCase() + "[" + idx + "]");
+          node = node.parentNode instanceof ShadowRoot ? node.parentNode.host : node.parentNode;
+      }
+
+      return "/" + parts.join("/");
+  }
+
+  // ---------------- WAIT LOOP ----------------
+  (function attempt() {
+      const found = findByFfInspect(document);
+
+      if (!found) {
+          if (Date.now() - start > MAX_WAIT) {
+              return callback({ success: false, reason: "timeout" });
+          }
+          return setTimeout(attempt, INTERVAL);
+      }
+
+      let targetNode = found.node;
+      if (!isClickable(targetNode)) {
+          const inside = findClickableInside(targetNode);
+          if (inside) targetNode = inside;
+      }
+
+      const xpath = buildXPath(targetNode);
+
+      return callback({
+          success: true,
+          xpath,
+          frames: found.frames
+      });
+  })();
+`;