ff-automationv2 2.2.14 → 2.2.15

package/dist/core/main/actionHandlerFactory.js

@@ -907,8 +907,14 @@ export function createActionHandlers(context) {
         MOB_PressBackKey: withExecutor(async (executor) => {
             await executor.MOB_PressBackKey();
         }),
-        WaitTillPresenceOfElement: withExecutor(async (executor, result) => {
-            await executor.WaitTillPresenceOfElement(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
+        MOB_PressBackSpaceKey: withExecutor(async (executor) => {
+            await executor.MOB_PressBackSpaceKey();
+        }),
+        MOB_PressSpaceKey: withExecutor(async (executor) => {
+            await executor.MOB_PressSpaceKey();
+        }),
+        WaitTillPresenceOfElement: withExecutor(async (executor, args) => {
+            await executor.WaitTillPresenceOfElement(args.pageDOM, args.selector, args.value, args.fireflinkIndex, args.elementName, args.elementType);
         }),
         WaitTillPresenceOfAllElements: withExecutor(async (executor, result) => {
             await executor.WaitTillPresenceOfAllElements(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
@@ -928,6 +934,9 @@ export function createActionHandlers(context) {
         FindElements: withExecutor(async (executor, result) => {
             await executor.FindElements(result.pageDOM, result.selector, result.value, result.fireflinkIndex, result.elementName, result.elementType);
         }),
+        MOB_FindElement: withExecutor(async (executor, result) => {
+            await executor.MOB_FindElement(result.selector, result.elementName, result.elementType);
+        }),
         WaitTillElementIsClickable: withExecutor(async (executor, result) => {
             await executor.WaitTillElementIsClickable(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
         }),
@@ -937,6 +946,9 @@ export function createActionHandlers(context) {
         PressAnyKey: withExecutor(async (executor, result) => {
             await executor.PressAnyKey(result.value);
         }),
+        MOB_WaitTillPresenceOfElement: withExecutor(async (executor, args) => {
+            await executor.WaitTillPresenceOfElement(args.pageDOM, args.selector, args.value, args.fireflinkIndex, args.elementName, args.elementType);
+        }),
         WaitTillElementHasText: withExecutor(async (executor, result) => {
             await executor.WaitTillElementHasText(result.pageDOM, result.selector, result.fireflinkIndex, result.elementName, result.elementType);
         }),
@@ -1108,5 +1120,53 @@ export function createActionHandlers(context) {
         MOB_SetEmulatorPowerPercentage: withExecutor(async (executor, result) => {
             await executor.MOB_SetEmulatorPowerPercentage(result.value);
         }),
+        MOB_SwipeToElement: withExecutor(async (executor, result) => {
+            await executor.swipeToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeUpToElement: withExecutor(async (executor, result) => {
+            await executor.swipeUpToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeDownToElement: withExecutor(async (executor, result) => {
+            await executor.swipeDownToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeLeftToElement: withExecutor(async (executor, result) => {
+            await executor.swipeLeftToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeRightToElement: withExecutor(async (executor, result) => {
+            await executor.swipeRightToElement(result.value, result.elementName, result.elementType, result.num_of_scrolls);
+        }),
+        MOB_SwipeNTimes: withExecutor(async (executor, result) => {
+            await executor.swipeNTimes(result.num_of_scrolls, result.direction);
+        }),
+        MOB_Builtin_Swipe: withExecutor(async (executor, result) => {
+            await executor.swipeDirectionNTimes(result.num_of_scrolls, result.direction);
+        }),
+        MOB_SwipeDirectionNTimes: withExecutor(async (executor, result) => {
+            await executor.swipeDirectionNTimes(result.num_of_scrolls, result.direction);
+        }),
+        MOB_SwipeToElementForMWeb: withExecutor(async (executor, result) => {
+            await executor.swipeToElementForMWeb(result.value, result.elementName, result.elementType);
+        }),
+        MOB_SwipeUsingReferenceElement: withExecutor(async (executor, result) => {
+            await executor.swipeUsingReferenceElement(result.value, result.elementName, result.elementType, result.num_of_scrolls, result.direction);
+        }),
+        MOB_EnterInputIntoElementFromClipBoard: withExecutor(async (executor, result) => {
+            await executor.MOB_EnterInputIntoElementFromClipBoard(result.selector, result.elementName, result.elementType);
+        }),
+        MOB_CheckIfAppIsClosed: withExecutor(async (executor) => {
+            await executor.MOB_CheckIfAppIsClosed();
+        }),
+        MOB_RunAppInBackground: withExecutor(async (executor, result) => {
+            await executor.MOB_RunAppInBackground(result.value);
+        }),
+        MOB_PinchInByPercent: withExecutor(async (executor, result) => {
+            await executor.MOB_PinchInByPercent(result.selector, result.value, result.elementName, result.elementType);
+        }),
+        MOB_PinchOutByPercent: withExecutor(async (executor, result) => {
+            await executor.MOB_PinchOutByPercent(result.selector, result.value, result.elementName, result.elementType);
+        }),
+        MOB_DoubleTapAtSpecifiedLocation: withExecutor(async (executor, result) => {
+            await executor.MOB_DoubleTapAtSpecifiedLocation(result.value, result.elementName, result.elementType);
+        }),
     };
 }

package/dist/core/main/runAutomationScript.d.ts

@@ -2,7 +2,6 @@ import { IAutomationRunner } from "../interfaces/automationRunnerInterface.js";
 import { AutomationRequest } from "../../core/interfaces/executionDetails.js";
 export declare class AutomationRunner implements IAutomationRunner {
     static sessionTerminationDetails: Record<string, boolean>;
-    private usedElementNames;
     private KafkaPayload;
     static getSessionTerminationInfo(testCaseId: string): boolean;
     static updateSessionTerminationInfo(testCaseId: string): void;

package/dist/core/main/runAutomationScript.js

@@ -19,13 +19,12 @@ import { isAlertPresent } from "../../utils/alertPopup/isAlertPresent.js";
 import { TOAST_WATCHER_JS } from "../../utils/javascript/jsForToaster.js";
 import { Find_element_by_ff_js_script } from "../../utils/javascript/jsFindElement.js";
 import { getFFIndexAndXPath } from "../../utils/helpers/xpathcreation.js";
-import { logger } from "../../utils/logger/logData.js";
+import { initLogger, logger } from "../../utils/logger/logData.js";
 import { sameActionHelper } from "../../utils/helpers/sameActionsHelper.js";
 import { error } from "node:console";
 import { annotateScreenshot } from "../../imageAnalysisMobile/annotatedScreenshotMobile.js";
 export class AutomationRunner {
     constructor() {
-        this.usedElementNames = [];
         this.KafkaPayload = {};
     }
     static getSessionTerminationInfo(testCaseId) {
@@ -50,7 +49,9 @@ export class AutomationRunner {
                         },
                         web: async () => {
                             if (request.isCloud) {
-                                await driver.deleteSession();
+                                if (driver?.sessionId) {
+                                    await driver.deleteSession();
+                                }
                                 logger.info("Cloud session closed");
                             }
                             if (driver?.sessionId) {
@@ -79,13 +80,14 @@ export class AutomationRunner {
         }
     }
     async run(request) {
-        this.usedElementNames = [];
+        const usedElementNames = [];
+        initLogger(request.sessionPath);
         if (request.isTerminate)
             return AutomationRunner.updateSessionTerminationInfo(request.testCaseId);
         AutomationRunner.sessionTerminationDetails[request.testCaseId] = request.isTerminate;
         const apiService = new FireFlinkApiService();
-        const fireflinkServiceInstance = new fireflinkService(apiService, request.kafkaProducerInstance);
-        const instanceDetails = await fireflinkServiceInstance.runGetInstancesDetails(request.projectId, request.token, request.serverHost);
+        const fireflinkServiceInstance = new fireflinkService(apiService);
+        const instanceDetails = await fireflinkServiceInstance.runGetInstancesDetails(request.projectId, request.token, request.serverData);
         const aiInfo = getAiInstanceInfo(instanceDetails.responseObject);
         const context = new ExecutionContext(request);
         const configProvider = new ServiceProviderBaseUrlProvider();
@@ -139,13 +141,13 @@ export class AutomationRunner {
                     const baseName = elementName;
                     let newName = baseName;
                     let count = 0;
-                    while (this.usedElementNames.includes(newName)) {
+                    while (usedElementNames.includes(newName)) {
                         count++;
                         newName = `${baseName}_${count}`;
                     }
                     elementName = newName;
                     result.response.elementName = elementName;
-                    this.usedElementNames.push(elementName);
+                    usedElementNames.push(elementName);
                 }
                 if (!allKeywordAction.includes(action)) {
                     throw new Error(`Unsupported action at action or keyword exracter: ${action}`);
@@ -551,26 +553,28 @@ export class AutomationRunner {
             licenseType: request.licenseType,
             licenseId: request.licenseId,
             userId: request.userId,
-            topic: request.topic,
             projectType: request.projectType,
             tokensConsumed: (await stepProcessor.getResultTokenUsage()).totalTokens,
-            errorInfo: errorInfo
+            ...(errorInfo && Object.keys(errorInfo).length > 0 && { errorInfo })
         };
         try {
             await context.scriptAppender.waitForAllSteps();
-            this.KafkaPayload.topic = request.topic;
+            // logger.info(context.scriptAppender.getData(), payload)
+            this.KafkaPayload.topic = `Topic-FIREFLINK-api-requests-${request.serverHost}`;
             this.KafkaPayload.message = {
                 ...payload,
                 scriptGenerationData: context.scriptAppender.getData(),
                 serverHost: request.serverHost
             };
+            logger.info(this.KafkaPayload);
             await fireflinkServiceInstance.produceMessageToKafka(this.KafkaPayload);
         }
         catch (error) {
-            throw new Error("Failed to send payload to FireFlink API:", { cause: error });
+            throw new Error("Failed to produce message :", { cause: error });
         }
         finally {
-            await this.cleanup(context, domInfo, extractedRelevantDom, stepProcessor, fireflinkServiceInstance, request, platform, await context.session.getCurrentDriver() ?? await context.androidSession.getCurrentDriver());
+            await this.cleanup(context, domInfo, extractedRelevantDom, stepProcessor, fireflinkServiceInstance, request, platform, (await context.session.getCurrentDriver().catch(() => null)) ??
+                (await context.androidSession.getCurrentDriver().catch(() => null)));
         }
     }
 }

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

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

package/dist/service/fireflink.service.js

@@ -1,12 +1,11 @@
 import { KafkaProducerService } from "./kafka/fireflinkKafka.service.js";
 import { logger } from "../utils/logger/logData.js";
 export class fireflinkService {
-    constructor(apiService, kafkaProducerInstance) {
+    constructor(apiService) {
         this.apiService = apiService;
-        this.kafkaProducerInstance = kafkaProducerInstance;
-        this.kafkaProducer = new KafkaProducerService(this.kafkaProducerInstance);
+        this.kafkaProducer = new KafkaProducerService();
     }
-    async runGetInstancesDetails(projectId, token, serverHost) {
+    async runGetInstancesDetails(projectId, token, serverData) {
         const headers = {
             Accept: "*/*",
             "Accept-Language": "en-US,en;q=0.9",
@@ -14,7 +13,7 @@ export class fireflinkService {
             projectId: projectId || "",
             Authorization: `Bearer ${token}`,
         };
-        const url = `${serverHost}/project/optimize/v3/ai-service-provider/selected-instance?projectId=${projectId}`;
+        const url = `${serverData}/project/optimize/v3/ai-service-provider/selected-instance?projectId=${projectId}`;
         try {
             const finalResult = await this.apiService.getInstancesDetailsApi(headers, url);
             if (finalResult) {

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

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

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

@@ -1,7 +1,21 @@
+import { Kafka } from "kafkajs";
 import { logger } from "../../utils/logger/logData.js";
+import fs from "fs";
+import dotenv from "dotenv";
+dotenv.config();
 export class KafkaProducerService {
-    constructor(kafkaProducer) {
-        this.kafkaProducer = kafkaProducer;
+    constructor() {
+        this.kafka = new Kafka({
+            clientId: process.env.KAFKA_CLIENT_ID,
+            brokers: process.env.KAFKA_BROKERS.split(","),
+            ssl: {
+                ca: [fs.readFileSync(process.env.KAFKA_SSL_CA, "utf-8")],
+                key: fs.readFileSync(process.env.KAFKA_SSL_KEY, "utf-8"),
+                cert: fs.readFileSync(process.env.KAFKA_SSL_CERT, "utf-8"),
+                rejectUnauthorized: true,
+            },
+        });
+        this.kafkaProducer = this.kafka.producer();
     }
     async produceMessage(kafkaArgs) {
         try {
@@ -12,7 +26,7 @@ export class KafkaProducerService {
                 messages: [{ value: JSON.stringify(kafkaArgs.message) }],
             });
             await this.kafkaProducer.disconnect();
-            logger.info("Kafka produced message successfully and Kafka produced disconnected successfully");
+            logger.info("Kafka produced message successfully and Kafka producer disconnected successfully");
         }
         catch (error) {
             await this.kafkaProducer.disconnect();

package/dist/utils/logger/logData.d.ts

@@ -1,3 +1,4 @@
+export declare function initLogger(basePath: string): void;
 export declare const logger: {
     info: (...args: any[]) => Promise<void>;
     error: (...args: any[]) => Promise<void>;

package/dist/utils/logger/logData.js

@@ -1,37 +1,53 @@
 import fs from "fs/promises";
 import path from "path";
 import beautify from "js-beautify";
-const logsDir = path.resolve(process.cwd(), "logs");
-const domDir = path.resolve(process.cwd(), "dom");
-const screenshotsDir = path.resolve(process.cwd(), "screenshots");
-const now = new Date();
-const istDate = new Intl.DateTimeFormat("sv-SE", {
-    timeZone: "Asia/Kolkata",
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    fractionalSecondDigits: 3,
-    hour12: false,
-})
-    .format(now)
-    .replace(" ", "T");
-const logFilePath = path.join(logsDir, "ai-execution-logs.txt");
+let sessionPath;
+let logsDir;
+let domDir;
+let screenshotsDir;
+let logFilePath;
+export function initLogger(basePath) {
+    sessionPath = basePath;
+    logsDir = path.resolve(sessionPath, "logs");
+    domDir = path.resolve(sessionPath, "dom");
+    screenshotsDir = path.resolve(sessionPath, "screenshots");
+    logFilePath = path.join(logsDir, "ai-execution-logs.txt");
+}
 async function ensureDirs() {
+    if (!logsDir)
+        throw new Error("Logger not initialized");
     await fs.mkdir(logsDir, { recursive: true });
     await fs.mkdir(domDir, { recursive: true });
     await fs.mkdir(screenshotsDir, { recursive: true });
 }
-ensureDirs();
+function getISTDate() {
+    return new Intl.DateTimeFormat("sv-SE", {
+        timeZone: "Asia/Kolkata",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        fractionalSecondDigits: 3,
+        hour12: false,
+    })
+        .format(new Date())
+        .replace(" ", "T");
+}
 export const logger = {
     info: async (...args) => {
+        if (!logFilePath)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const formattedArgs = args.map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : arg);
-        const message = `[INFO] ${istDate}+05:30 - ${formattedArgs.join(" ")}\n`;
+        const message = `[INFO] ${getISTDate()}+05:30 - ${formattedArgs.join(" ")}\n`;
         await fs.appendFile(logFilePath, message, "utf-8");
     },
     error: async (...args) => {
+        if (!logFilePath)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const formatted = args.map((arg) => {
             if (arg instanceof Error) {
                 let output = arg.stack || `${arg.name}: ${arg.message}`;
@@ -71,6 +87,9 @@ export const logger = {
         return formatted.join(" ");
     },
     saveDOM: async (domContent, fileName) => {
+        if (!domDir)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const timestamp = new Date().toLocaleString().replace(/[:.]/g, "-");
         let finalFileName;
         let formattedContent;
@@ -90,17 +109,25 @@ export const logger = {
         await fs.writeFile(filePath, formattedContent, "utf-8");
     },
     saveJSON: async (data, fileName) => {
+        if (!domDir)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const timestamp = new Date().toLocaleString().replace(/[:.]/g, "-");
-        const finalFileName = fileName ? `${fileName}.json` : `data-${timestamp}.json`;
+        const finalFileName = fileName
+            ? `${fileName}.json`
+            : `data-${timestamp}.json`;
         const filePath = path.join(domDir, finalFileName);
         const safeData = JSON.stringify(data, (key, value) => {
             if (key === "element")
-                return undefined; // remove DOM node
+                return undefined;
             return value;
         }, 2);
         await fs.writeFile(filePath, safeData, "utf-8");
     },
     saveImage: async (imageBuffer, fileName) => {
+        if (!screenshotsDir)
+            throw new Error("Logger not initialized");
+        await ensureDirs();
         const filePath = path.join(screenshotsDir, fileName);
         await fs.writeFile(filePath, imageBuffer);
     },

package/dist/utils/swipe/domSearchHelper.d.ts

@@ -0,0 +1,5 @@
+export declare function findElementInDom(driver: WebdriverIO.Browser, text: string): Promise<{
+    element: import("webdriverio").ChainablePromiseElement;
+    xpath: string;
+    annotatedDom: string;
+} | null>;

package/dist/utils/swipe/domSearchHelper.js

@@ -0,0 +1,42 @@
+import { getAnnotatedDOMForMobile } from "../DomExtraction/jsForAttributeInjection.js";
+import { DomSimplifier } from "../../domAnalysis/simplifyAndFlatten.js";
+import { getFFIndexAndXPath } from "../helpers/xpathcreation.js";
+export async function findElementInDom(driver, text) {
+    const simplifier = new DomSimplifier();
+    const keywords = text
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+    const { dom: annotatedDom } = await getAnnotatedDOMForMobile(driver);
+    const { flatNodes } = simplifier.simplifyMobile(annotatedDom);
+    const sequenceMatch = (value, words) => {
+        const v = value.toLowerCase();
+        const pattern = new RegExp("\\b" + words.join("\\s*") + "\\b", "i");
+        return pattern.test(v);
+    };
+    for (const nodeObj of flatNodes) {
+        const node = nodeObj.node;
+        const textVal = (node["text"] || "").toLowerCase();
+        const descVal = (node["content-desc"] || "").toLowerCase();
+        const ridVal = (node["resource-id"] || "").toLowerCase();
+        if (sequenceMatch(textVal, keywords) ||
+            sequenceMatch(descVal, keywords) ||
+            sequenceMatch(ridVal, keywords)) {
+            const ffIndex = node["FF-inspecter"];
+            if (!ffIndex)
+                continue;
+            const xpath = getFFIndexAndXPath(annotatedDom, ffIndex);
+            if (!xpath)
+                continue;
+            const element = await driver.$(xpath.xpathPath);
+            if (await element.isExisting()) {
+                return {
+                    element,
+                    xpath: xpath.xpathPath,
+                    annotatedDom
+                };
+            }
+        }
+    }
+    return null;
+}

package/dist/utils/swipe/swipeMovement.d.ts

@@ -0,0 +1 @@
+export declare function executeSwipeMovement(driver: WebdriverIO.Browser, direction: string): Promise<void>;

package/dist/utils/swipe/swipeMovement.js

@@ -0,0 +1,81 @@
+export async function executeSwipeMovement(driver, direction) {
+    if (direction === 'left' || direction === 'right') {
+        const horizontalContainers = [
+            '//android.widget.HorizontalScrollView',
+            '//androidx.recyclerview.widget.RecyclerView'
+        ];
+        let hsv = null;
+        for (const selector of horizontalContainers) {
+            const el = await driver.$(selector);
+            if (await el.isExisting()) {
+                hsv = el;
+                break;
+            }
+        }
+        if (hsv && typeof hsv.getRect === "function") {
+            const rect = await hsv.getRect();
+            const y = rect.y + Math.floor(rect.height / 2);
+            let startX, endX;
+            if (direction === 'left') {
+                startX = rect.x + Math.floor(rect.width * 0.8);
+                endX = rect.x + Math.floor(rect.width * 0.2);
+            }
+            else {
+                startX = rect.x + Math.floor(rect.width * 0.2);
+                endX = rect.x + Math.floor(rect.width * 0.8);
+            }
+            await performW3CSwipe(driver, startX, y, endX, y);
+            return;
+        }
+    }
+    const size = await driver.getWindowSize();
+    const midX = size.width / 2;
+    let startX, startY, endX, endY;
+    if (direction === 'up') {
+        startX = midX;
+        startY = size.height * 0.6;
+        endX = midX;
+        endY = size.height * 0.1;
+    }
+    else if (direction === 'down') {
+        startX = midX;
+        startY = size.height * 0.4;
+        endX = midX;
+        endY = size.height * 0.8;
+    }
+    else if (direction === 'left') {
+        startX = size.width * 0.8;
+        startY = size.height * 0.5;
+        endX = size.width * 0.2;
+        endY = size.height * 0.5;
+    }
+    else if (direction === 'right') {
+        startX = size.width * 0.2;
+        startY = size.height * 0.5;
+        endX = size.width * 0.8;
+        endY = size.height * 0.5;
+    }
+    else {
+        startX = midX;
+        startY = size.height * 0.8;
+        endX = midX;
+        endY = size.height * 0.2;
+    }
+    await performW3CSwipe(driver, startX, startY, endX, endY);
+}
+async function performW3CSwipe(driver, startX, startY, endX, endY) {
+    await driver.performActions([
+        {
+            type: 'pointer',
+            id: 'finger1',
+            parameters: { pointerType: 'touch' },
+            actions: [
+                { type: 'pointerMove', duration: 0, x: Math.floor(startX), y: Math.floor(startY) },
+                { type: 'pointerDown', button: 0 },
+                { type: 'pointerMove', duration: 800, x: Math.floor(endX), y: Math.floor(endY) },
+                { type: 'pointerUp', button: 0 }
+            ]
+        }
+    ]);
+    await driver.pause(1000);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ff-automationv2",
-  "version": "2.2.14",
+  "version": "2.2.15",
   "private": false,
   "type": "module",
   "description": "This lib is used to automate the manual testcase",
@@ -23,7 +23,6 @@
     "prepare": "husky",
     "lint": "eslint src --max-warnings=0",
     "test": "npm run build && node dist/tests/test12.js",
-    "test1": "npm run build && node dist/tests/test.js",
     "llm": "npm run build && node dist/tests/testllm.js",
     "dev": "npm run build && node dist/index.js",
     "start": "node dist/index.js",
@@ -50,8 +49,8 @@
     "nodemon": "3.1.11",
     "ts-node": "10.9.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "8.56.0",
-    "webdriverio": "9.26.1"
+    "webdriverio": "9.26.1",
+    "typescript-eslint": "8.56.0"
   },
   "dependencies": {
     "@xmldom/xmldom": "^0.8.11",

package/dist/tests/Framework.js

@@ -1,62 +0,0 @@
-"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/test1.d.ts

@@ -1,7 +0,0 @@
-type SessionState = {
-    testCase: string;
-    env: "local" | "cloud";
-    isTerminate: boolean;
-};
-declare let sessionList: SessionState[];
-declare const founds1: boolean;

package/dist/tests/test1.js

@@ -1,13 +0,0 @@
-"use strict";
-let sessionList = [
-    { testCase: "A", env: "local", isTerminate: false },
-    { testCase: "B", env: "cloud", isTerminate: false },
-    { testCase: "B", env: "cloud", isTerminate: true },
-    { testCase: "C", env: "local", isTerminate: false }
-];
-sessionList = sessionList.filter(item => !(item.testCase === "B" && item.env === "cloud" && item.isTerminate === true));
-const founds1 = sessionList.some(item => item.testCase === "A" &&
-    item.env === "local" &&
-    item.isTerminate === false);
-// console.log(founds); // undefined
-console.log(sessionList);