ff-automationv2 2.2.0 → 2.2.2

package/dist/imageAnalysisMobile/annotatedScreenshotMobile.js

@@ -0,0 +1,82 @@
+import { createCanvas, loadImage } from "canvas";
+import { XMLParser } from "fast-xml-parser";
+import { logger } from "../utils/logger/logData.js";
+function parseBounds(bounds) {
+    const nums = bounds.match(/\d+/g);
+    if (!nums || nums.length !== 4)
+        return null;
+    return {
+        x1: parseInt(nums[0]),
+        y1: parseInt(nums[1]),
+        x2: parseInt(nums[2]),
+        y2: parseInt(nums[3])
+    };
+}
+function extractBoxes(xmlSource) {
+    const parser = new XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: ""
+    });
+    const tree = parser.parse(xmlSource);
+    const boxes = [];
+    const traverse = (node) => {
+        if (node?.bounds) {
+            const clickable = node.clickable === "true";
+            const enabled = node.enabled === "true";
+            const clazz = node.class || "";
+            if ((clickable && enabled) ||
+                clazz.toLowerCase().includes("edittext") ||
+                clazz.toLowerCase().includes("autocompletetextview")) {
+                const bounds = parseBounds(node.bounds);
+                if (bounds)
+                    boxes.push(bounds);
+            }
+        }
+        for (const key in node) {
+            if (typeof node[key] === "object") {
+                traverse(node[key]);
+            }
+        }
+    };
+    traverse(tree);
+    return boxes;
+}
+const COLORS = [
+    [255, 0, 0],
+    [0, 128, 255],
+    [0, 180, 0],
+    [255, 140, 0],
+    [148, 0, 211],
+    [0, 180, 180],
+    [180, 0, 0],
+    [255, 105, 180],
+];
+async function drawBoxes(screenshotBuffer, boxes) {
+    const img = await loadImage(screenshotBuffer);
+    const canvas = createCanvas(img.width, img.height);
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(img, 0, 0);
+    const scale = img.width / 1080;
+    const fontSize = Math.max(20, Math.floor(28 * scale));
+    ctx.font = `${fontSize}px Arial`;
+    ctx.textBaseline = "top";
+    boxes.forEach((box, index) => {
+        const color = COLORS[index % COLORS.length];
+        const colorStr = `rgb(${color[0]},${color[1]},${color[2]})`;
+        ctx.strokeStyle = colorStr;
+        ctx.lineWidth = Math.max(2, Math.floor(3 * scale));
+        ctx.strokeRect(box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
+        ctx.fillStyle = colorStr;
+        ctx.fillText(String(index + 1), box.x1 + 6, box.y1 + 6);
+    });
+    return canvas.toBuffer("image/png");
+}
+export async function annotateScreenshot(driver, xmlSource) {
+    const screenshotBase64 = await driver.takeScreenshot();
+    const screenshotBuffer = Buffer.from(screenshotBase64, "base64");
+    const boxes = extractBoxes(xmlSource);
+    const boxedImageBuffer = await drawBoxes(screenshotBuffer, boxes);
+    // Uncomment only when debugging
+    await logger.saveImage(boxedImageBuffer, "boxed.png");
+    return boxedImageBuffer;
+}

package/dist/imageAnalysisMobile/annotatedScreenshotMobileInterface.d.ts

@@ -0,0 +1,6 @@
+export interface Bounds {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}

package/dist/imageAnalysisMobile/annotatedScreenshotMobileInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/imageAnalysisWeb/annotateScreenshot.d.ts

@@ -0,0 +1,2 @@
+import { NodeItem } from "./screenshotInterface.js";
+export declare function annotateScreenshot(screenshotBase64: string, nodes: NodeItem[]): Promise<Buffer>;

package/dist/imageAnalysisWeb/annotateScreenshot.js

@@ -0,0 +1,139 @@
+import { createCanvas, loadImage } from "canvas";
+const COLORS = [
+    [255, 0, 0],
+    [0, 128, 255],
+    [0, 180, 0],
+    [255, 140, 0],
+    [148, 0, 211],
+    [0, 180, 180],
+    [180, 0, 0],
+    [255, 105, 180],
+];
+const TAG_PADDING = 4;
+function measureText(ctx, text) {
+    const metrics = ctx.measureText(text);
+    const height = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
+    return { width: metrics.width, height };
+}
+function rectsIntersect(a, b) {
+    const [ax1, ay1, ax2, ay2] = a;
+    const [bx1, by1, bx2, by2] = b;
+    return !(ax2 < bx1 || ax1 > bx2 || ay2 < by1 || ay1 > by2);
+}
+function insideScreen(rect, width, height) {
+    const [x1, y1, x2, y2] = rect;
+    return x1 >= 0 && y1 >= 0 && x2 <= width && y2 <= height;
+}
+function findFreeTagPosition(box, tagW, tagH, elementBoxes, usedTagRects, imgWidth, imgHeight) {
+    const [bx1, by1, bx2, by2] = box;
+    const cx = Math.floor((bx1 + bx2) / 2);
+    const cy = Math.floor((by1 + by2) / 2);
+    const maxRadius = 120;
+    const step = 6;
+    for (let radius = 6; radius < maxRadius; radius += step) {
+        for (let angle = 0; angle < 360; angle += 30) {
+            const rad = (angle * Math.PI) / 180;
+            const lx = Math.floor(cx + radius * Math.cos(rad) - tagW / 2);
+            const ly = Math.floor(cy + radius * Math.sin(rad) - tagH / 2);
+            const rect = [
+                lx - TAG_PADDING,
+                ly - TAG_PADDING,
+                lx + tagW + TAG_PADDING,
+                ly + tagH + TAG_PADDING,
+            ];
+            if (!insideScreen(rect, imgWidth, imgHeight))
+                continue;
+            if (elementBoxes.some((b) => rectsIntersect(rect, b)))
+                continue;
+            if (usedTagRects.some((t) => rectsIntersect(rect, t)))
+                continue;
+            usedTagRects.push(rect);
+            return { x: lx, y: ly };
+        }
+    }
+    const fallbackX = Math.max(0, bx1 - tagW - 10);
+    const fallbackY = Math.max(0, by1 - tagH - 10);
+    usedTagRects.push([fallbackX, fallbackY, fallbackX + tagW, fallbackY + tagH]);
+    return { x: fallbackX, y: fallbackY };
+}
+export async function annotateScreenshot(screenshotBase64, nodes) {
+    const buffer = Buffer.from(screenshotBase64, "base64");
+    const image = await loadImage(buffer);
+    const scale = image.width / 1920;
+    const fontSize = Math.max(10, Math.floor(14 * scale));
+    const canvas = createCanvas(image.width, image.height);
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(image, 0, 0);
+    ctx.font = `${fontSize}px Tahoma`;
+    ctx.textBaseline = "middle";
+    ctx.textAlign = "center";
+    const usedTagRects = [];
+    const elementBoxes = nodes.map((n) => [
+        Math.floor(n.bbox.x),
+        Math.floor(n.bbox.y),
+        Math.floor(n.bbox.x + n.bbox.w),
+        Math.floor(n.bbox.y + n.bbox.h),
+    ]);
+    nodes.forEach((item, i) => {
+        const color = COLORS[i % COLORS.length];
+        const colorStr = `rgb(${color[0]},${color[1]},${color[2]})`;
+        const label = item.ff.split("-").pop() || "";
+        const x1 = Math.floor(item.bbox.x);
+        const y1 = Math.floor(item.bbox.y);
+        const x2 = Math.floor(item.bbox.x + item.bbox.w);
+        const y2 = Math.floor(item.bbox.y + item.bbox.h);
+        ctx.strokeStyle = colorStr;
+        ctx.lineWidth = Math.max(2, Math.floor(2 * scale));
+        ctx.strokeRect(x1, y1, x2 - x1, y2 - y1);
+        const { width: tw, height: th } = measureText(ctx, label);
+        const tagW = Math.max(22, tw + 10);
+        const tagH = Math.max(18, th + 8);
+        const { x: lx, y: ly } = findFreeTagPosition([x1, y1, x2, y2], tagW, tagH, elementBoxes, usedTagRects, canvas.width, canvas.height);
+        ctx.fillStyle = "white";
+        ctx.strokeStyle = colorStr;
+        ctx.lineWidth = 2;
+        ctx.fillRect(lx, ly, tagW, tagH);
+        ctx.strokeRect(lx, ly, tagW, tagH);
+        ctx.fillStyle = colorStr;
+        ctx.fillText(label, lx + tagW / 2, ly + tagH / 2);
+        const tagCx = lx + tagW / 2;
+        const tagCy = ly + tagH / 2;
+        const boxCx = (x1 + x2) / 2;
+        const boxCy = (y1 + y2) / 2;
+        const offset = 2;
+        let lineStartX;
+        let lineStartY;
+        let lineEndX;
+        let lineEndY;
+        if (tagCx < x1) {
+            lineStartX = lx + tagW;
+            lineStartY = tagCy;
+            lineEndX = x1 - offset;
+            lineEndY = boxCy;
+        }
+        else if (tagCx > x2) {
+            lineStartX = lx;
+            lineStartY = tagCy;
+            lineEndX = x2 + offset;
+            lineEndY = boxCy;
+        }
+        else if (tagCy < y1) {
+            lineStartX = tagCx;
+            lineStartY = ly + tagH;
+            lineEndX = boxCx;
+            lineEndY = y1 - offset;
+        }
+        else {
+            lineStartX = tagCx;
+            lineStartY = ly;
+            lineEndX = boxCx;
+            lineEndY = y2 + offset;
+        }
+        ctx.beginPath();
+        ctx.moveTo(lineStartX, lineStartY);
+        ctx.lineTo(lineEndX, lineEndY);
+        ctx.stroke();
+    });
+    const boxedImageBuffer = canvas.toBuffer("image/png");
+    return boxedImageBuffer;
+}

package/dist/imageAnalysisWeb/generateAnnotatedScreenshots.d.ts

@@ -0,0 +1 @@
+export declare function generateAnnotatedScreenshots(driver: WebdriverIO.Browser): Promise<Buffer>;

package/dist/imageAnalysisWeb/generateAnnotatedScreenshots.js

@@ -0,0 +1,28 @@
+import { annotateScreenshot } from "./annotateScreenshot.js";
+import { JS_PRIMARY } from "../utils/javascript/jsForVision.js";
+// import { logger } from "../utils/logger/logData.js";
+export async function generateAnnotatedScreenshots(driver) {
+    const screenshot = await driver.takeScreenshot();
+    // const [primaryRaw, secondaryRaw] = await Promise.all([
+    //   driver.execute(JS_PRIMARY),
+    //   driver.execute(JS_SECONDARY),
+    // ]);
+    const [primaryRaw] = await Promise.all([
+        driver.execute(JS_PRIMARY),
+        // driver.execute(JS_SECONDARY),
+    ]);
+    const primary = primaryRaw ?? [];
+    // let secondary = (secondaryRaw as NodeItem[]) ?? [];
+    // const primaryIds = new Set(primary.map((item) => item.ff));
+    // secondary = secondary.filter((item) => !primaryIds.has(item.ff));
+    const [primaryAnnotated] = await Promise.all([
+        annotateScreenshot(screenshot, primary),
+        // annotateScreenshot(
+        //   screenshot,
+        //   secondary,
+        // )
+    ]);
+    // Uncomment only when debugging
+    // await logger.saveImage(primaryAnnotated, "annotated_primary.png");
+    return primaryAnnotated;
+}

package/dist/imageAnalysisWeb/screenshotInterface.d.ts

@@ -0,0 +1,14 @@
+export interface BBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface NodeItem {
+    ff: string;
+    xpath: string;
+    bbox: BBox;
+    tag: string;
+    text: string;
+}
+export type Rect = [number, number, number, number];

package/dist/imageAnalysisWeb/screenshotInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,4 @@
+import { AutomationRunner } from "./core/main/runAutomationScript.js";
+import dotenv from "dotenv";
+dotenv.config();
+export { AutomationRunner };

package/dist/llmConfig/llmConfiguration.d.ts

@@ -0,0 +1,5 @@
+import { IServiceProviderBaseUrlConfiguration } from "../core/interfaces/llmConfigurationInterface.js";
+export declare class ServiceProviderBaseUrlProvider implements IServiceProviderBaseUrlConfiguration {
+    private readonly baseUrls;
+    getBaseUrl(provider: string): string;
+}

package/dist/llmConfig/llmConfiguration.js

@@ -0,0 +1,18 @@
+export class ServiceProviderBaseUrlProvider {
+    constructor() {
+        this.baseUrls = {
+            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/"
+        };
+    }
+    getBaseUrl(provider) {
+        const url = this.baseUrls[provider];
+        if (!url) {
+            throw new Error(`Unsupported service provider: ${provider}`);
+        }
+        return url;
+    }
+}

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(headers: Record<string, string>, url: string): Promise<any>;
+}

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

@@ -0,0 +1,22 @@
+import axios from "axios";
+export class FireFlinkApiService {
+    async getInstancesDetailsApi(headers, url) {
+        try {
+            const response = await axios.get(url, {
+                headers,
+                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 });
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import { Producer } from "kafkajs";
+import { IKafkaPayload } from "../../core/interfaces/fireflinkScriptPayloadInterface.js";
+export declare class KafkaProducerService {
+    private kafkaProducer;
+    constructor(kafkaProducer: Producer);
+    produceMessage(kafkaArgs: IKafkaPayload): Promise<void>;
+}

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

@@ -0,0 +1,22 @@
+import { logger } from "../../utils/logger/logData.js";
+export class KafkaProducerService {
+    constructor(kafkaProducer) {
+        this.kafkaProducer = kafkaProducer;
+    }
+    async produceMessage(kafkaArgs) {
+        try {
+            await this.kafkaProducer.connect();
+            logger.info("Kafka connected successfully");
+            await this.kafkaProducer.send({
+                topic: kafkaArgs.topic,
+                messages: [{ value: JSON.stringify(kafkaArgs.message) }],
+            });
+            await this.kafkaProducer.disconnect();
+            logger.info("Kafka produced message successfully and Kafka produced disconnected successfully");
+        }
+        catch (error) {
+            await this.kafkaProducer.disconnect();
+            logger.error("An error occurred and the Kafka producer disconnected without sending the message", error);
+        }
+    }
+}

package/dist/service/scriptRunner.service.d.ts

@@ -0,0 +1,10 @@
+import { IScriptRunner, IFireFlinkApiService, IKafkaPayload } from "../core/interfaces/fireflinkScriptPayloadInterface.js";
+import { Producer } from "kafkajs";
+export declare class ScriptRunner implements IScriptRunner {
+    private apiService;
+    private kafkaProducerInstance;
+    private kafkaProducer;
+    constructor(apiService: IFireFlinkApiService, kafkaProducerInstance: Producer);
+    runGetInstancesDetails(projectId: string, token: string, serverHost: string): Promise<any>;
+    produceMessageToKafka(kafkaArgs: IKafkaPayload): Promise<void>;
+}

package/dist/service/scriptRunner.service.js

@@ -0,0 +1,36 @@
+import { KafkaProducerService } from "../service/kafka/fireflinkKafka.service.js";
+import { logger } from "../utils/logger/logData.js";
+export class ScriptRunner {
+    constructor(apiService, kafkaProducerInstance) {
+        this.apiService = apiService;
+        this.kafkaProducerInstance = kafkaProducerInstance;
+        this.kafkaProducer = new KafkaProducerService(this.kafkaProducerInstance);
+    }
+    async runGetInstancesDetails(projectId, token, serverHost) {
+        const headers = {
+            Accept: "*/*",
+            "Accept-Language": "en-US,en;q=0.9",
+            "Content-Type": "application/json",
+            projectId: projectId || "",
+            Authorization: `Bearer ${token}`,
+        };
+        const url = `${serverHost}/project/optimize/v3/ai-service-provider/selected-instance?projectId=${projectId}`;
+        try {
+            const finalResult = await this.apiService.getInstancesDetailsApi(headers, 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) {
+            logger.error(`Failed to submit automation script, ${error}`);
+            throw new Error("Failed to submit automation script", { cause: error });
+        }
+    }
+    async produceMessageToKafka(kafkaArgs) {
+        this.kafkaProducer.produceMessage(kafkaArgs);
+    }
+}

package/dist/tests/Framework.js

@@ -0,0 +1,62 @@
+"use strict";
+// import { AutomationRunner } from "../core/main/runAutomationScript.js";
+// import { RuntimePromptRegistry } from "../framework/promptRegistry.runtime.js";
+// import { RuntimeActionRegistry } from "../framework/actionRegistry.runtime.js";
+// import { createDefaultPromptRegistry, registerDefaultPrompts } from "../framework/registerDefaultPrompts.js";
+// import { createDefaultActionRegistry, registerDefaultActions } from "../framework/registerDefaultActions.js";
+// // export { AutomationRunner };
+// // export { RuntimePromptRegistry };
+// // export { RuntimeActionRegistry };
+// // export { createDefaultPromptRegistry, registerDefaultPrompts };
+// // export { createDefaultActionRegistry, registerDefaultActions };
+// // import { AutomationRunner, RuntimeActionRegistry } from "ff-automationv2";
+// const actionRegistry = new RuntimeActionRegistry();
+// // actionRegistry.register("minimize", {
+// //     handler: async (context) => {
+// //         const browser = await context.session.getCurrentBrowser();
+// //         await browser.minimizeWindow();
+// //         context.scriptAppender.add({
+// //             nlpName: "Minimize",
+// //             elementsData: [],
+// //             stepInputs: []
+// //         });
+// //     },
+// //     requiresExecutor: true,
+// //     requiresElement: false,
+// //     requiresInput: false
+// // });
+// const runner = new AutomationRunner(20000, 15000, { actionRegistry });
+// runner.run({
+//     userStory: "(open the browser ),( navigate to https://www.google.com/) ,(wait for 2 sec),(minimize the browser) ",
+//     platform: "android",
+//     pageDetails: {
+//         Web: {
+//             pageId: "PAG73a7a0ad-c092-4351-8a93-68647f60e343",
+//             pageName: "ai-Page"
+//         }
+//     },
+//     service_accounts: "",
+//     serverHost: "https://test3.fireflink.com",
+//     webSocketId: "",
+//     generatedBy: "",
+//     licenseType: "C-Professional",
+//     licenseId: "LIC3985",
+//     userId: "USR26935",
+//     topic: "Topic-FIREFLINK-aiAutomation-Updates-test3",
+//     projectType: "Web",
+//     browser: {
+//         browserName: "chrome",
+//     },
+//     serverData: {},
+//     scriptName: "url",
+//     scriptType: "android",
+//     projectId: "PJT1116",
+//     testCaseId: "SCR1208",
+//     promptId: "3f6e123c-8ec6-47c1-90e1-1a2f53b49251",
+//     userName: "default-user",
+//     visionApikey: "Z3NrX2VubE44UVI5bmNzMlg0TXVsNDJHV0dkeWIzRllEYmJRV0lremZYaTRkME5VTzBjODZ4eHY=",
+//     apiKey: "Z3NrX2VubE44UVI5bmNzMlg0TXVsNDJHV0dkeWIzRllEYmJRV0lremZYaTRkME5VTzBjODZ4eHY=",
+//     model: "llama-3.3-70b-versatile",
+//     serviceProvider: "Groq",
+//     token: "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJEeE5VelJXSGhLTUVkSTVKQnV6eERFM3NsczVHRkV5cmJNeHVHNWtmNnRZIn0.eyJleHAiOjE3NzUyMjI3OTAsImlhdCI6MTc3MjYzMDc5MCwianRpIjoib25ydHJvOmY2ZDcwNzg1LTk4ODQtNDgzNS04ZjE2LWNiNzk5NjhiNWQzYSIsImlzcyI6Imh0dHA6Ly8xMDMuMTgyLjIxMC4yMjY6MzAxMDcvcmVhbG1zL0ZpcmVGbGluay10ZXN0MyIsImF1ZCI6InRhcmdldC1jbGllbnQiLCJzdWIiOiJmOmNhMzBmNDk3LTY1Y2YtNGU4Zi1iZGE3LTE0ZjM1NTNiYzZmNTpqYWlha2FzaEB5b3BtYWlsLmNvbSIsInR5cCI6IkJlYXJlciIsImF6cCI6ImZsaW5rLXNlcnZpY2UiLCJzaWQiOiJhMzg0MTVkMS1hYWZkLTQ4MTYtOWNhYS01MGVmMGMxZWI0ODciLCJhY3IiOiIxIiwiYWxsb3dlZC1vcmlnaW5zIjpbIioiXSwicmVhbG1fYWNjZXNzIjp7InJvbGVzIjpbIm9mZmxpbmVfYWNjZXNzIiwidW1hX2F1dGhvcml6YXRpb24iXX0sInNjb3BlIjoiZW1haWwgcHJvZmlsZSIsImN1cnJlbnRMaWNlbnNlSWQiOiJMSUMzOTg1IiwiZW1haWxfdmVyaWZpZWQiOmZhbHNlLCJjdXJyZW50UHJpdmlsZWdlIjoiU3VwZXIgQWRtaW4iLCJmdWxsTmFtZSI6ImphaSIsImFjdGl2YXRpb25TdGF0dXMiOiJBQ1RJVkUiLCJwcml2aWxlZ2UiOiJTdXBlciBBZG1pbiIsImxpY2Vuc2VOYW1lIjoiRmlyZUZsaW5rIC0gTElDMzk4NSIsInByZWZlcnJlZF91c2VybmFtZSI6ImphaSIsInVzZXJOYW1lIjoiamFpYWthc2hAeW9wbWFpbC5jb20iLCJiaWxsaW5nQ3ljbGUiOiJRdWFydGVybHkiLCJpZCI6IlVTUjI2OTM1IiwibGljZW5zZUlkIjoiTElDMzk4NSIsImVtYWlsIjoiamFpYWthc2hAeW9wbWFpbC5jb20ifQ.NCu_Oo86ld4tHCjWqTC2YxeBOifhWqwqmh1K7Cz6v4XEhDQuUrdULzKCOBWbYXA86BqT8oqWLOg2lA88G-LRnayCiBEutlbTbPIYsbghyuJCeagA_E9VJnM0fcccJqRi16dKG1em3cuZ2nJTQ8s_Bq1211ovPGI-Jyy2IBTc-fTDI0C4o9x8O0jpT_mz8COzCDwbCAon2e1EKxYjnyU360ZMwmwcnJjWqB5vsr384fKdrq3zx_zLESvW81x2bRGxzGYoO2hS38PWSrZbiOANNXzjVU9nDSU4kx280oBZo251rVRE58jJ4kKDSxLqmshT0TP-PERMqhNps9U2envExg",
+// })

package/dist/tests/test12.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/test12.js

@@ -0,0 +1,51 @@
+import { AutomationRunner } from "../index.js";
+import { Kafka } from "kafkajs";
+const kafka = new Kafka({
+    clientId: "automation-service",
+    brokers: ["127.0.0.1:9092"],
+});
+const producer = kafka.producer();
+const runner = new AutomationRunner();
+runner.run({
+    userStory: [
+        ["Open browser"],
+        ["Navigate to https://www.google.com/"],
+        ["Maximize the browser"],
+        ["wait for 5 seconds"],
+        ["enter asdfdsas in search field"],
+        ["Close browser"]
+    ],
+    platform: "web",
+    pageDetails: {
+        Web: {
+            pageId: "PAG73a7a0ad-c092-4351-8a93-68647f60e343",
+            pageName: "ai-Page"
+        }
+    },
+    service_accounts: "",
+    serverHost: "https://test3.fireflink.com",
+    webSocketId: "",
+    generatedBy: "",
+    licenseType: "C-Professional",
+    licenseId: "LIC3985",
+    userId: "USR26935",
+    topic: "Topic-FIREFLINK-aiAutomation-Updates-test3",
+    projectType: "Web",
+    browser: {
+        browserName: "chrome",
+    },
+    serverData: {},
+    version: "asdfg",
+    type: "sdfg",
+    scriptName: "url",
+    scriptType: "android",
+    projectId: "PJT1116",
+    testCaseId: "SCR1208",
+    promptId: "3f6e123c-8ec6-47c1-90e1-1a2f53b49251",
+    userName: "default-user",
+    appiumPort: 0,
+    platform_version: "",
+    realDeviceId: "",
+    kafkaProducerInstance: producer,
+    token: "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJRUFRfTnFuMkxxdDVmN09tOElWaW53dUJlR3ZVUUVBUkdxZkFuRHJxZU9NIn0.eyJleHAiOjE3NzM3MjU1NTYsImlhdCI6MTc3MzYzOTE1NiwianRpIjoib25ydHJvOmExZWI0NmMxLTQ0YTctNDAxZi1hZTZhLTYxZmQwNWMyZmYzOSIsImlzcyI6Imh0dHA6Ly8xMDMuMTgyLjIxMC4yMjY6MzAxMDcvcmVhbG1zL0ZpcmVGbGluay10ZXN0MyIsImF1ZCI6InRhcmdldC1jbGllbnQiLCJzdWIiOiJmOmNhMzBmNDk3LTY1Y2YtNGU4Zi1iZGE3LTE0ZjM1NTNiYzZmNTpqYWlha2FzaEB5b3BtYWlsLmNvbSIsInR5cCI6IkJlYXJlciIsImF6cCI6ImZsaW5rLXNlcnZpY2UiLCJzaWQiOiJhYWI4N2M3NS1hZjMwLTRhNTUtOWVkMi00Y2ZmYTU1NjBjZjYiLCJhY3IiOiIxIiwiYWxsb3dlZC1vcmlnaW5zIjpbIioiXSwicmVhbG1fYWNjZXNzIjp7InJvbGVzIjpbIm9mZmxpbmVfYWNjZXNzIiwidW1hX2F1dGhvcml6YXRpb24iXX0sInNjb3BlIjoiZW1haWwgcHJvZmlsZSIsImN1cnJlbnRMaWNlbnNlSWQiOiJMSUMzOTg1IiwiZW1haWxfdmVyaWZpZWQiOmZhbHNlLCJjdXJyZW50UHJpdmlsZWdlIjoiU3VwZXIgQWRtaW4iLCJmdWxsTmFtZSI6ImphaSIsImFjdGl2YXRpb25TdGF0dXMiOiJBQ1RJVkUiLCJwcml2aWxlZ2UiOiJTdXBlciBBZG1pbiIsImxpY2Vuc2VOYW1lIjoiRmlyZUZsaW5rIC0gTElDMzk4NSIsInByZWZlcnJlZF91c2VybmFtZSI6ImphaSIsInVzZXJOYW1lIjoiamFpYWthc2hAeW9wbWFpbC5jb20iLCJiaWxsaW5nQ3ljbGUiOiJRdWFydGVybHkiLCJpZCI6IlVTUjI2OTM1IiwibGljZW5zZUlkIjoiTElDMzk4NSIsImVtYWlsIjoiamFpYWthc2hAeW9wbWFpbC5jb20ifQ.VoP_odtWkk1OCsmiQerH6ehAAmgLuf6pDQSYCgjcqP9u-lFzLVEZk-N2ebveHpN-eT9HPycbEsyObo12JC2tfoTq1d4lba01vrHHVvpWlM0R07UNIys_D02zrIFRN2FOLpPt4DvfT4HEL5bD5vPHth3D1EqYVcmyfrser_CubwmSk7UQNkO9TJKT2boSY_a3ft1CC53bt1vmG6noygkth-jJH7cO2KZLPOi4M3yswpdTudJ7-LXmffZf_mHAaU_D_kcPpTox_ZCB9lKRgb0jW7cm09oVVdpYE305dRL_AyzOtEx5cDKwnWIAZCiPEf62yqyDD_9Oy8h1PFB-WvFagQ"
+});

package/dist/tests/test3.d.ts

@@ -0,0 +1,2 @@
+declare function task(): void;
+declare function task1(): Promise<void>;

package/dist/tests/test3.js

@@ -0,0 +1,19 @@
+"use strict";
+// import { ScriptRunner } from "../service/scriptRunner.service.js";
+// import { FireFlinkApiService } from "../service/fireflinkApi.service.js";
+// let v = new FireFlinkApiService()
+// let a = new ScriptRunner(v);
+// a.runGetInstancesDetails("PJT1116", "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJEeE5VelJXSGhLTUVkSTVKQnV6eERFM3NsczVHRkV5cmJNeHVHNWtmNnRZIn0.eyJleHAiOjE3NzQ2MTAyMTgsImlhdCI6MTc3MjAxODIxOCwianRpIjoib25ydHJvOmQ4Njg5NDg2LTFkZmMtNDAyMy05NTU1LTRkODFjOThhMTEwOCIsImlzcyI6Imh0dHA6Ly8xMDMuMTgyLjIxMC4yMjY6MzAxMDcvcmVhbG1zL0ZpcmVGbGluay10ZXN0MyIsImF1ZCI6InRhcmdldC1jbGllbnQiLCJzdWIiOiJmOmNhMzBmNDk3LTY1Y2YtNGU4Zi1iZGE3LTE0ZjM1NTNiYzZmNTpqYWlha2FzaEB5b3BtYWlsLmNvbSIsInR5cCI6IkJlYXJlciIsImF6cCI6ImZsaW5rLXNlcnZpY2UiLCJzaWQiOiI3YjU0MTQyOC04ZGZiLTQ0NTQtOTUyYy03YWY5OGYwZGQ0ZjIiLCJhY3IiOiIxIiwiYWxsb3dlZC1vcmlnaW5zIjpbIioiXSwicmVhbG1fYWNjZXNzIjp7InJvbGVzIjpbIm9mZmxpbmVfYWNjZXNzIiwidW1hX2F1dGhvcml6YXRpb24iXX0sInNjb3BlIjoiZW1haWwgcHJvZmlsZSIsImN1cnJlbnRMaWNlbnNlSWQiOiJMSUMzOTg1IiwiZW1haWxfdmVyaWZpZWQiOmZhbHNlLCJjdXJyZW50UHJpdmlsZWdlIjoiU3VwZXIgQWRtaW4iLCJmdWxsTmFtZSI6ImphaSIsImFjdGl2YXRpb25TdGF0dXMiOiJBQ1RJVkUiLCJwcml2aWxlZ2UiOiJTdXBlciBBZG1pbiIsImxpY2Vuc2VOYW1lIjoiRmlyZUZsaW5rIC0gTElDMzk4NSIsInByZWZlcnJlZF91c2VybmFtZSI6ImphaSIsInVzZXJOYW1lIjoiamFpYWthc2hAeW9wbWFpbC5jb20iLCJiaWxsaW5nQ3ljbGUiOiJRdWFydGVybHkiLCJpZCI6IlVTUjI2OTM1IiwibGljZW5zZUlkIjoiTElDMzk4NSIsImVtYWlsIjoiamFpYWthc2hAeW9wbWFpbC5jb20ifQ.OqMunPwFxmsDTq9m2HXv8h5uHv-nhLXJdJlka2BMG4Vajr1gsxL7q_au_9z3m8GemWyKk_y1nDBJEcY7z-MZKGyavMjaw6YViUtYWqa-NXB3TLtF1YVN8tT6WjA-apprewwkt1fJ39Gzrqq0ZNwDH-ik_Ujx1Zghk650e2wd2HvRgarLlI08G__BE4qiTWU_KBn87wXChsjn_FPTGP-EZLnxsv9QtEaQRmpza03RYy2EBaJBf66U3sNkhRjcJJV1kdLPKhMxb_Z7nJc0Ou4UpMaCiVeeN4vEADiWnj8HD0hke6kdA-mqUuZxGVg3_SaMzCHlbaP2T3eazDVAJvnBag", "https://test3.fireflink.com")
+function task() {
+    const start = Date.now();
+    while (Date.now() - start < 1000) { } // simulate 1 sec work
+}
+console.log("start");
+task();
+console.log("end");
+async function task1() {
+    await new Promise(r => setTimeout(r, 1000));
+}
+console.log("start");
+task1();
+console.log("end");

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

@@ -0,0 +1,5 @@
+export interface AnnotatedDOMResult {
+    dom: string;
+}
+export declare function getAnnotatedDOM(browser: WebdriverIO.Browser): Promise<AnnotatedDOMResult>;
+export declare function getAnnotatedDOMForMobile(driver: WebdriverIO.Browser): Promise<AnnotatedDOMResult>;