ff-automationv2 2.2.36-beta.0 → 2.2.36-beta.2

package/dist/llmConfig/llmConfiguration.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceProviderProviderConfiguration = void 0;
+const openai_1 = require("@ai-sdk/openai");
+const anthropic_1 = require("@ai-sdk/anthropic");
+const google_1 = require("@ai-sdk/google");
+const google_vertex_1 = require("@ai-sdk/google-vertex");
+const azure_1 = require("@ai-sdk/azure");
+const PROVIDERS = {
+    Groq: openai_1.createOpenAI,
+    DefaultFireFlink: openai_1.createOpenAI,
+    OpenAi: openai_1.createOpenAI,
+    Anthropic: anthropic_1.createAnthropic,
+};
+class ServiceProviderProviderConfiguration {
+    async getProvider(aiInfo) {
+        if (aiInfo.serviceProvider === "Azure_AI") {
+            return (0, azure_1.createAzure)({
+                apiKey: aiInfo.apiKey,
+                resourceName: aiInfo.resource,
+            });
+        }
+        if (aiInfo.serviceProvider === "Gemini") {
+            if (aiInfo.accountType === "Enterprise Level") {
+                return (0, google_vertex_1.createVertex)({
+                    project: aiInfo.projectId,
+                    location: aiInfo.region,
+                    googleAuthOptions: {
+                        credentials: aiInfo.enterpriseConfigFile,
+                    },
+                });
+            }
+            return (0, google_1.createGoogleGenerativeAI)({
+                apiKey: aiInfo.apiKey,
+            });
+        }
+        const providerFactory = PROVIDERS[aiInfo.serviceProvider];
+        if (!providerFactory) {
+            throw new Error(`Unsupported provider: ${aiInfo.serviceProvider}`);
+        }
+        if (aiInfo.serviceProvider === "Groq" || aiInfo.serviceProvider === "DefaultFireFlink") {
+            return providerFactory({
+                baseURL: "https://api.groq.com/openai/v1",
+                apiKey: aiInfo.apiKey
+            });
+        }
+        else {
+            return providerFactory({
+                apiKey: aiInfo.apiKey,
+            });
+        }
+    }
+}
+exports.ServiceProviderProviderConfiguration = ServiceProviderProviderConfiguration;

package/dist/service/api/fireflinkApi.service.d.ts

@@ -0,0 +1,4 @@
+import { IFireFlinkApiService } from "../../core/interfaces/fireflinkScriptPayloadInterface.js";
+export declare class FireFlinkApiService implements IFireFlinkApiService {
+    getInstancesDetailsApi(url: string): Promise<any>;
+}

package/dist/service/api/fireflinkApi.service.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FireFlinkApiService = void 0;
+const axios_1 = __importDefault(require("axios"));
+class FireFlinkApiService {
+    async getInstancesDetailsApi(url) {
+        try {
+            const response = await axios_1.default.get(url, {
+                timeout: 30000,
+            });
+            return response.data;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ECONNABORTED") {
+                throw new Error("Request to FireFlink API timed out for getting the instances details", { 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 for getting the instances details", { cause: error });
+        }
+    }
+}
+exports.FireFlinkApiService = FireFlinkApiService;

package/dist/service/fireflink.service.d.ts

@@ -0,0 +1,8 @@
+import { IFireflinkService, IFireFlinkApiService } from "../core/interfaces/fireflinkScriptPayloadInterface.js";
+export declare class fireflinkService implements IFireflinkService {
+    private apiService;
+    private kafkaProducer;
+    constructor(apiService: IFireFlinkApiService, broker: string[], sslConfig: any);
+    runGetInstancesDetails(projectId: string, _token: string, serverHost: string, licenseId: string): Promise<any>;
+    produceMessageToKafka(key: string, kafkaArgs: any): Promise<void>;
+}

package/dist/service/fireflink.service.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fireflinkService = void 0;
+const fireflinkKafka_service_js_1 = require("./kafka/fireflinkKafka.service.js");
+const logData_js_1 = require("../utils/logger/logData.js");
+class fireflinkService {
+    constructor(apiService, broker, sslConfig) {
+        this.apiService = apiService;
+        this.kafkaProducer = new fireflinkKafka_service_js_1.KafkaProducerService(broker, sslConfig);
+    }
+    async runGetInstancesDetails(projectId, _token, serverHost, licenseId) {
+        const url = `${serverHost}/project/optimize/v3/ai-service-provider/internal/selected-instance?projectId=${projectId}&licenseId=${licenseId}`;
+        const maxRetries = 5;
+        let lastError;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const finalResult = await this.apiService.getInstancesDetailsApi(url);
+                if (finalResult) {
+                    logData_js_1.logger.info("Instance API Responded Successfully");
+                    return finalResult;
+                }
+                else {
+                    throw new Error("Instance API responded with an error: " + JSON.stringify(finalResult));
+                }
+            }
+            catch (error) {
+                lastError = error;
+                logData_js_1.logger.info(`Attempt ${attempt} of ${maxRetries} failed to fetch instance details from FireFlink API: ${error?.message || error}`);
+                if (attempt < maxRetries) {
+                    await new Promise((resolve) => setTimeout(resolve, 1000 * attempt));
+                }
+            }
+        }
+        logData_js_1.logger.error(`Failed to get instance details after ${maxRetries} attempts, ${lastError}`);
+        throw new Error("Failed to get instance details", { cause: lastError });
+    }
+    async produceMessageToKafka(key, kafkaArgs) {
+        await this.kafkaProducer.produceMessage(key, kafkaArgs);
+    }
+}
+exports.fireflinkService = fireflinkService;

package/dist/service/kafka/fireflinkKafka.service.d.ts

@@ -0,0 +1,6 @@
+export declare class KafkaProducerService {
+    private kafka;
+    private kafkaProducer;
+    constructor(brokers: string[], sslConfig: any);
+    produceMessage(key: string, kafkaArgs: any): Promise<void>;
+}

package/dist/service/kafka/fireflinkKafka.service.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaProducerService = void 0;
+const kafkajs_1 = require("kafkajs");
+const logData_js_1 = require("../../utils/logger/logData.js");
+class KafkaProducerService {
+    constructor(brokers, sslConfig) {
+        this.kafka = new kafkajs_1.Kafka({
+            clientId: "FireFlinK-AI-Automation",
+            brokers,
+            ssl: sslConfig,
+            logLevel: kafkajs_1.logLevel.ERROR,
+            connectionTimeout: 10000,
+            requestTimeout: 60000,
+            retry: {
+                initialRetryTime: 300,
+                retries: 10,
+            },
+        });
+        this.kafkaProducer = this.kafka.producer();
+    }
+    async produceMessage(key, kafkaArgs) {
+        try {
+            await this.kafkaProducer.connect();
+            logData_js_1.logger.info("Kafka connected successfully");
+            await this.kafkaProducer.send({
+                topic: kafkaArgs.topic,
+                messages: [{ value: JSON.stringify(kafkaArgs.message), key: key, headers: {
+                            type: "logs"
+                        }
+                    }],
+            });
+            logData_js_1.logger.info("Kafka produced message successfully and Kafka producer disconnected successfully");
+        }
+        catch (error) {
+            await this.kafkaProducer.disconnect();
+            logData_js_1.logger.error("An error occurred and the Kafka producer disconnected without sending the message", error);
+        }
+    }
+}
+exports.KafkaProducerService = KafkaProducerService;

package/dist/utils/DomExtraction/jsForAttributeInjection.d.ts

@@ -0,0 +1,13 @@
+import { CrossOriginIframeInfo, RawDomInjectionResult, ICombineDomResult, InjectIframeFunction } from "../crossOrigin/crossOriginInterface.js";
+import { markCrossOriginElements, combineDom, processCrossOriginIframes } from "../crossOrigin/crossOriginHelper.js";
+export { CrossOriginIframeInfo, RawDomInjectionResult, ICombineDomResult, InjectIframeFunction, markCrossOriginElements, combineDom, processCrossOriginIframes };
+export interface AnnotatedDOMResult {
+    dom: string;
+}
+export declare function getAnnotatedDOM(browser: WebdriverIO.Browser): Promise<AnnotatedDOMResult>;
+export declare function injectReact(browser: WebdriverIO.Browser, startIndex?: number): Promise<RawDomInjectionResult>;
+export declare function getReactAnnotatedDOM(browser: WebdriverIO.Browser, startIndex?: number): Promise<AnnotatedDOMResult>;
+export declare const INJECT_AND_SERIALIZE_DOM_JS = "\nreturn (function (startIndex) {\n  let nodeIndex = typeof startIndex === \"number\" ? startIndex : 0;\nfunction getCoverageStatus(el) {\n    if (!el || !el.getBoundingClientRect) return \"unknown\";\n    const s = getComputedStyle(el);\n    if (s.pointerEvents === \"none\") return \"false\";\n    const rect = el.getBoundingClientRect();\n    if (rect.width === 0 || rect.height === 0) return \"false\";\n    // Off-screen element \u2014 check if something is blocking the viewport\n    const isOffScreen =\n        rect.bottom < 0 ||\n        rect.right < 0 ||\n        rect.top > window.innerHeight ||\n        rect.left > window.innerWidth;\n    if (isOffScreen) {\n        const centerEl = document.elementFromPoint(\n            window.innerWidth / 2,\n            window.innerHeight / 2\n        );\n        if (centerEl && centerEl !== document.body && centerEl !== document.documentElement) {\n            // Something is at center of viewport \u2014 check if el and centerEl\n            // share the same scrollable container\n            const elScrollParent = getScrollParent(el);\n            const centerScrollParent = getScrollParent(centerEl);\n            if (elScrollParent !== centerScrollParent) return \"true\";\n        }\n        return \"false\";\n    }\n    // On-screen element \u2014 use elementFromPoint\n    const testPoints = [\n        [rect.left + 5, rect.top + 5],\n        [rect.right - 5, rect.top + 5],\n        [rect.left + 5, rect.bottom - 5],\n        [rect.right - 5, rect.bottom - 5],\n        [rect.left + rect.width / 2, rect.top + rect.height / 2]\n    ];\n    for (const [x, y] of testPoints) {\n        if (x < 0 || y < 0 || x > window.innerWidth || y > window.innerHeight) continue;\n        const topEl = document.elementFromPoint(x, y);\n        if (!topEl) continue;\n        if (topEl === el || el.contains(topEl)) continue;\n        if (topEl.contains(el)) continue; // topEl is ancestor, not a cover\n        return \"true\";\n    }\n    return \"false\";\n}\nfunction getScrollParent(node) {\n    if (!node || node === document.body) return document.body;\n    const s = getComputedStyle(node);\n    if (\n        s.overflow === \"auto\" || s.overflow === \"scroll\" ||\n        s.overflowY === \"auto\" || s.overflowY === \"scroll\"\n    ) return node;\n    return getScrollParent(node.parentElement);\n}\nfunction isUsable(node) {\n    const s = getComputedStyle(node);\n    if (s.display === \"none\" || s.visibility === \"hidden\" || s.opacity === \"0\") return false;\n    const rect = node.getBoundingClientRect();\n    if (rect.width === 0 || rect.height === 0) return false;\n    return true;\n}\n\nfunction isSelectRelated(node) {\n    return (\n        node.matches?.(\"select, option\") ||\n        node.closest?.(\"select, [role='listbox'], [role='combobox']\")\n    );\n}\n  function annotate(node) {\n    const s = getComputedStyle(node);\n    node.setAttribute(\"element-visibility\", s.visibility || \"\");\n    node.setAttribute(\"element-pointer-events\", s.pointerEvents || \"\");\n    node.setAttribute(\"element-zindex\", s.zIndex || \"\");\n     if (isSelectRelated(node)) {\n        node.setAttribute(\"element-covered\", \"false\");\n        return;\n    }\n\n    if (!isUsable(node)) {\n        node.setAttribute(\"element-covered\", \"true\");\n        return;\n    }\n     try {\n        node.setAttribute(\"element-covered\", getCoverageStatus(node));\n        \n    } catch {\n        node.setAttribute(\"element-covered\", \"unknown\");\n    }\n  }\n  function getXPath(node) {\n    if (!node || node.nodeType !== 1) return \"\";\n    let segments = [];\n    let current = node;\n    while (current && current.nodeType === 1) {\n        const parent = current.parentNode;\n        if (parent instanceof ShadowRoot) {\n            const host = parent.host;\n            const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);\n            const index = siblings.indexOf(current) + 1;\n            segments.unshift(\"shadow/\" + current.tagName.toLowerCase() + \"[\" + index + \"]\");\n            current = host;\n            continue;\n        }\n        let index = 1;\n        if (parent && parent.children) {\n            const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);\n            index = siblings.indexOf(current) + 1;\n        }\n        segments.unshift(current.tagName.toLowerCase() + \"[\" + index + \"]\");\n        if (!parent || parent.nodeType !== 1) break;\n        current = parent;\n    }\n    let path = \"/\" + segments.join(\"/\");\n    if (node.ownerDocument !== document) {\n        const frameEl = node.ownerDocument.defaultView && node.ownerDocument.defaultView.frameElement;\n        if (frameEl) {\n            let framePath = frameEl.getAttribute(\"ff-xpath\");\n            if (!framePath) framePath = getXPath(frameEl);\n            path = framePath + path;\n        }\n    }\n    path = path.replace(//div[0]/div[0]/g, \"/div[1]\").replace(//div[0]/g, \"/div[1]\");\n    return path;\n  }\n  function walk(root) {\n     const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);\n    let node = walker.currentNode;\n    while (node) {\n        if (node.nodeType === 1 \n            && typeof node.setAttribute === 'function'\n            && ![\"META\", \"STYLE\", \"SCRIPT\"].includes(node.tagName)) {\n            node.setAttribute(\"ff-inspect\", \"Fire-Flink-\" + nodeIndex++);\n            node.setAttribute(\"ff-xpath\", getXPath(node));\n            annotate(node);\n        }\n        if (node.shadowRoot) walk(node.shadowRoot);\n        if (node.tagName === \"IFRAME\") {\n            try {\n                const doc = node.contentDocument;\n                if (doc && doc.documentElement) {\n                    walk(doc.documentElement);\n                } else {\n                    node.setAttribute(\"ff-cross-origin\", \"true\");\n                }\n            } catch {\n                node.setAttribute(\"ff-cross-origin\", \"true\");\n            }\n        }\n        node = walker.nextNode();\n    }\n  }\nfunction cleanup(root) {\n    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);\n    let node = walker.currentNode;\n    while (node) {\n     if (node.nodeType === 1 && typeof node.removeAttribute === 'function') {\n        node.removeAttribute(\"ff-inspect\");\n        node.removeAttribute(\"ff-xpath\");\n        node.removeAttribute(\"element-visibility\");\n        node.removeAttribute(\"element-pointer-events\");\n        node.removeAttribute(\"element-zindex\");\n        node.removeAttribute(\"element-covered\");\n        node.removeAttribute(\"ff-cross-origin\");\n}\n        if (node.shadowRoot) cleanup(node.shadowRoot);\n        node = walker.nextNode();\n    }\n}\ncleanup(document.documentElement);\n// Force browser to settle DOM after cleanup\nvoid document.documentElement.offsetHeight;\nwalk(document.documentElement);\n  function serializeNode(node) {\n    if (node.nodeType === Node.TEXT_NODE) return node.textContent;\n    if (node.nodeType !== Node.ELEMENT_NODE) return \"\";\n    const tag = node.tagName.toLowerCase();\n    let html = \"<\" + tag;\n    for (const attr of node.attributes) {\n        if (attr.name === \"srcdoc\") continue;\n        html += \" \" + attr.name + \"=\"\" + attr.value.replace(/\"/g, \"&quot;\") + \"\"\";\n    }\n    html += \">\";\n    if (node.shadowRoot) {\n        html += \"<!--#shadow-root-->\";\n        node.shadowRoot.childNodes.forEach(child => { html += serializeNode(child); });\n        html += \"<!--#/shadow-root-->\";\n    }\n    if (tag === \"iframe\" && node.getAttribute(\"ff-cross-origin\") !== \"true\") {\n        try {\n            const doc = node.contentDocument;\n            if (doc) html += serializeNode(doc.documentElement);\n        } catch {}\n    }\n    node.childNodes.forEach(child => { html += serializeNode(child); });\n    html += \"</\" + tag + \">\";\n    return html;\n  }\n\n  const crossOriginIframes =\n      Array.from(\n          document.querySelectorAll(\"iframe\")\n      )\n      .filter(\n          iframe =>\n              iframe.getAttribute(\n                  \"ff-cross-origin\"\n              ) === \"true\"\n      )\n      .map(iframe => ({\n          xpath:\n              iframe.getAttribute(\n                  \"ff-xpath\"\n              ),\n\n          src:\n              iframe.getAttribute(\"src\"),\n\n          title:\n              iframe.getAttribute(\"title\"),\n\n          name:\n              iframe.getAttribute(\"name\")\n      }));\n\n  return {\n      dom: \"<!DOCTYPE html>\n\" + serializeNode(document.documentElement),\n      crossOriginIframes: crossOriginIframes,\n      nextNodeIndex: nodeIndex\n  };\n})(arguments[0]);\n";
+export declare function injectAngular(browser: WebdriverIO.Browser, startIndex?: number): Promise<RawDomInjectionResult>;
+export declare function getAngularAnnotatedDOM(browser: WebdriverIO.Browser, startIndex?: number): Promise<AnnotatedDOMResult>;
+export declare function getAnnotatedDOMForMobile(driver: WebdriverIO.Browser, existingDom?: string): Promise<AnnotatedDOMResult>;