ff-automationv2 2.1.3 → 2.2.2

package/src/fireflinkData/fireflinkScript/scriptGenrationData.ts

@@ -1,30 +0,0 @@
-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/llmConfig/llmConfiguration.ts

@@ -1,26 +0,0 @@
-
-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

@@ -1,46 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,322 +0,0 @@
-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 {
-
-            if (!el || !el.getBoundingClientRect) return "unknown";
-
-            const rect = el.getBoundingClientRect();
-            if (rect.width === 0 || rect.height === 0) return "false";
-
-            const testPoints = [
-                [rect.left + 5, rect.top + 5],
-                [rect.right - 5, rect.top + 5],
-                [rect.left + 5, rect.bottom - 5],
-                [rect.right - 5, rect.bottom - 5],
-                [rect.left + rect.width / 2, rect.top + rect.height / 2]
-            ];
-
-            for (let [x, y] of testPoints) {
-
-                let topEl = document.elementFromPoint(x, y);
-                if (!topEl) continue;
-
-                if (topEl === el || el.contains(topEl)) continue;
-
-                const style = getComputedStyle(topEl);
-
-                if (
-                    style.pointerEvents === "none" ||
-                    style.opacity === "0" ||
-                    style.visibility === "hidden"
-                ) continue;
-
-                if (el.closest("label")?.contains(topEl)) continue;
-                if (topEl.closest("label")?.contains(el)) continue;
-                if (el.parentElement?.contains(topEl)) continue;
-
-                const isBlocking =
-                    ["BUTTON", "A"].includes(topEl.tagName) ||
-                    (topEl as HTMLElement).onclick ||
-                    topEl.getAttribute("role") === "button";
-
-                if (isBlocking) return "true";
-            }
-
-            return "false";
-        }
-
-        // ==========================================================
-        // VISIBILITY CHECK
-        // ==========================================================
-        function isUsable(node: Element): boolean {
-
-            const s = getComputedStyle(node);
-
-            if (
-                s.display === "none" ||
-                s.visibility === "hidden" ||
-                s.opacity === "0" ||
-                s.pointerEvents === "none"
-            ) return false;
-
-            const rect = node.getBoundingClientRect();
-            if (rect.width === 0 || rect.height === 0) return false;
-
-            return true;
-        }
-
-        // ==========================================================
-        // ANNOTATION
-        // ==========================================================
-        function annotate(node: Element): void {
-
-            const s = getComputedStyle(node);
-
-            node.setAttribute("element-visibility", s.visibility || "");
-            node.setAttribute("element-pointer-events", s.pointerEvents || "");
-            node.setAttribute("element-zindex", s.zIndex || "");
-
-            if (!isUsable(node)) {
-                node.setAttribute("element-covered", "true");
-                return;
-            }
-
-            try {
-                node.setAttribute(
-                    "element-covered",
-                    getCoverageStatus(node)
-                );
-            } catch {
-                node.setAttribute("element-covered", "unknown");
-            }
-        }
-
-        // ==========================================================
-        // XPATH (Shadow + iframe safe)
-        // ==========================================================
-        function getXPath(node: Element): string {
-
-            if (!node || node.nodeType !== 1) return "";
-
-            let segments: string[] = [];
-            let current: Element | null = node;
-
-            while (current && current.nodeType === 1) {
-
-                const parent = current.parentNode;
-
-                if (parent instanceof ShadowRoot) {
-
-                    const host = parent.host;
-
-                    const siblings = Array.from(parent.children)
-                        .filter(n => n.tagName === current!.tagName);
-
-                    const index = siblings.indexOf(current) + 1;
-
-                    segments.unshift(
-                        "shadow/" +
-                        current.tagName.toLowerCase() +
-                        "[" + index + "]"
-                    );
-
-                    current = host as Element;
-                    continue;
-                }
-
-                let index = 1;
-
-                if (parent && (parent as Element).children) {
-
-                    const siblings = Array.from(
-                        (parent as Element).children
-                    ).filter(n => n.tagName === current!.tagName);
-
-                    index = siblings.indexOf(current) + 1;
-                }
-
-                segments.unshift(
-                    current.tagName.toLowerCase() +
-                    "[" + index + "]"
-                );
-
-                if (!parent || parent.nodeType !== 1) break;
-
-                current = parent as Element;
-            }
-
-            let path = "/" + segments.join("/");
-
-            if (node.ownerDocument !== document) {
-
-                const frameEl =
-                    node.ownerDocument.defaultView?.frameElement;
-
-                if (frameEl) {
-
-                    let framePath =
-                        frameEl.getAttribute("ff-xpath");
-
-                    if (!framePath) {
-                        framePath = getXPath(frameEl);
-                    }
-
-                    path = framePath + path;
-                }
-            }
-
-            return path;
-        }
-
-        // ==========================================================
-        // TRUE NODE WALK (TreeWalker)
-        // ==========================================================
-        function walk(root: Node): void {
-
-            const walker = document.createTreeWalker(
-                root,
-                NodeFilter.SHOW_ELEMENT,
-                null
-            );
-
-            let node = walker.currentNode as Element | null;
-
-            while (node) {
-
-                if (
-                    node.nodeType === 1 &&
-                    !["META", "STYLE", "SCRIPT"]
-                        .includes(node.tagName)
-                ) {
-
-                    const fireId =
-                        "Fire-Flink-" + nodeIndex++;
-
-                    const xpath = getXPath(node);
-
-                    node.setAttribute("ff-inspect", fireId);
-                    node.setAttribute("ff-xpath", xpath);
-
-                    xpaths[fireId] = xpath;
-
-                    annotate(node);
-                }
-
-                if ((node as HTMLElement).shadowRoot) {
-                    walk((node as HTMLElement).shadowRoot!);
-                }
-
-                if (node.tagName === "IFRAME") {
-                    try {
-                        const doc =
-                            (node as HTMLIFrameElement)
-                                .contentDocument;
-
-                        if (doc?.documentElement) {
-                            walk(doc.documentElement);
-                        }
-                    } catch {
-                        node.setAttribute(
-                            "ff-cross-origin",
-                            "true"
-                        );
-                    }
-                }
-
-                node = walker.nextNode() as Element | null;
-            }
-        }
-
-        // Start traversal
-        walk(document.documentElement);
-
-        // ==========================================================
-        // 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)) {
-                if (attr.name === "srcdoc") continue;
-
-                html +=
-                    " " + attr.name +
-                    "=\"" +
-                    attr.value.replace(/"/g, "&quot;") +
-                    "\"";
-            }
-
-            html += ">";
-
-            if ((el as HTMLElement).shadowRoot) {
-                html += "<!--#shadow-root-->";
-                (el as HTMLElement)
-                    .shadowRoot!
-                    .childNodes
-                    .forEach(child => {
-                        html += serializeNode(child);
-                    });
-                html += "<!--#/shadow-root-->";
-            }
-
-            if (
-                tag === "iframe" &&
-                el.getAttribute("ff-cross-origin") !== "true"
-            ) {
-                try {
-                    const doc =
-                        (el as HTMLIFrameElement)
-                            .contentDocument;
-
-                    if (doc) {
-                        html += serializeNode(
-                            doc.documentElement
-                        );
-                    }
-                } catch { }
-            }
-
-            el.childNodes.forEach(child => {
-                html += serializeNode(child);
-            });
-
-            html += "</" + tag + ">";
-            return html;
-        }
-
-        return {
-            dom:
-                "<!DOCTYPE html>\n" +
-                serializeNode(document.documentElement),
-            selectors: xpaths
-        };
-
-    });
-}

package/src/utils/helpers/enterActionHelper.ts

@@ -1,94 +0,0 @@
-import { JSDOM } from "jsdom";
-
-export interface EnterActionResult {
-    ffNumber: number;
-    xpathPath: string;
-}
-
-export const enterActionHelper = (
-    pageDOM: string,
-    ffNumber: string
-): EnterActionResult => {
-
-    //  Extract numeric part
-    const match = ffNumber.match(/\d+$/);
-    let numericFF = match ? parseInt(match[0], 10) : 0;
-
-    const parser = new JSDOM(pageDOM);
-    const doc = parser.window.document;
-
-    const isEditable = (el: Element | null): boolean => {
-        if (!el) return false;
-
-        const tag = el.tagName?.toLowerCase();
-
-        return (
-            ["input", "textarea", "select"].includes(tag) ||
-            el.getAttribute("contenteditable") === "true"
-        );
-    };
-
-    const getXPath = (el: Element | null): string => {
-        return el?.getAttribute("ff-xpath") || "";
-    };
-
-    let element = doc.querySelector(
-        `[ff-inspect="Fire-Flink-${numericFF}"]`
-    );
-
-    if (!element) {
-        return { ffNumber: numericFF, xpathPath: "" };
-    }
-
-    let xpathPath = "";
-
-    //  Current element editable
-    if (isEditable(element)) {
-        xpathPath = getXPath(element);
-
-    } else {
-
-        // Search editable child
-        let editableChild: Element | null = null;
-
-        for (const child of Array.from(element.querySelectorAll("*"))) {
-            if (isEditable(child)) {
-                editableChild = child;
-                break;
-            }
-        }
-
-        if (editableChild) {
-            xpathPath = getXPath(editableChild);
-
-        } else {
-
-            // Try next 10 FF elements
-            for (let offset = 1; offset <= 10; offset++) {
-                const nextNum = numericFF + offset;
-
-                const nextTarget = doc.querySelector(
-                    `[ff-inspect="Fire-Flink-${nextNum}"]`
-                );
-
-                if (isEditable(nextTarget)) {
-                    numericFF = nextNum;
-                    xpathPath = getXPath(nextTarget);
-                    break;
-                }
-            }
-
-            // Final fallback
-            if (!xpathPath) {
-                xpathPath = getXPath(element);
-            }
-        }
-    }
-
-    // console.log("xpathPath", xpathPath);
-
-    return {
-        ffNumber: numericFF,
-        xpathPath
-    };
-};

package/src/utils/logger/logData.ts

@@ -1,81 +0,0 @@
-import fs from "fs";
-import path from "path";
-import beautify from "js-beautify";
-
-const logsDir = path.resolve(process.cwd(), "logs");
-const domDir = path.resolve(process.cwd(), "dom");
-
-if (!fs.existsSync(logsDir)) {
-    fs.mkdirSync(logsDir, { recursive: true });
-}
-
-if (!fs.existsSync(domDir)) {
-    fs.mkdirSync(domDir, { recursive: true });
-}
-
-const logFilePath = path.join(logsDir, "ai-execution-logs.txt");
-
-export const logger = {
-    info: (...args: any[]) => {
-        const formattedArgs = args.map(arg =>
-            typeof arg === "object"
-                ? JSON.stringify(arg, null, 2)
-                : arg
-        );
-
-        const message = `[INFO] ${new Date().toISOString()} - ${formattedArgs.join(" ")}\n`;
-
-        fs.appendFileSync(logFilePath, message, "utf-8");
-    },
-
-    error: (...args: any[]) => {
-        const formattedArgs = args.map(arg =>
-            typeof arg === "object"
-                ? JSON.stringify(arg, null, 2)
-                : arg
-        );
-
-        const message = `[ERROR] ${new Date().toISOString()} - ${formattedArgs.join(" ")}\n`;
-
-        fs.appendFileSync(logFilePath, message, "utf-8");
-    },
-
-    saveDOM: (domContent: string, fileName?: string) => {
-
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const finalFileName = fileName
-            ? `${fileName}.html`
-            : `dom-${timestamp}.html`;
-
-        const filePath = path.join(domDir, finalFileName);
-
-        const formattedHTML = beautify.html(domContent, {
-            indent_size: 2,
-            preserve_newlines: false,
-            wrap_line_length: 120
-        });
-
-        fs.writeFileSync(filePath, formattedHTML, "utf-8");
-    },
-
-    saveJSON: (data: unknown, fileName?: string) => {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-
-        const finalFileName = fileName
-            ? `${fileName}.json`
-            : `data-${timestamp}.json`;
-
-        const filePath = path.join(domDir, finalFileName);
-
-        fs.writeFileSync(
-            filePath,
-            JSON.stringify(data, null, 2),
-            "utf-8"
-        );
-
-
-    }
-
-
-};
-