ff-automationv2 2.1.3-beta.4 → 2.1.3-beta.6

package/RELEASE_GUIDE.md

@@ -3,7 +3,7 @@
 git checkout feature/your-feature-name
 git add .
 git commit -m "feat: new changes"
-git pull --rebase
+git pull 
 npm version prerelease --preid=beta
 git push --follow-tags
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ff-automationv2",
-  "version": "2.1.3-beta.4",
+  "version": "2.1.3-beta.6",
   "private": false,
   "type": "module",
   "description": "This lib is used to automate the manual testcase",
@@ -48,6 +48,6 @@
     "jsdom": "27.4.0",
     "openai": "6.18.0",
     "uuid": "13.0.0",
-    "webdriverio": "9.23.3"
+    "webdriverio": "8.46.0"
   }
 }

package/src/automation/actions/executor.ts

@@ -19,97 +19,141 @@ export class ActionExecutor implements IActionExecutor {
 
 
     async navigate(url: string): Promise<void> {
-        await navigate({
-            driver: this.browser,
-            url,
-            scriptDataAppender: this.scriptDataAppender
-        });
+        try {
+            await navigate({
+                driver: this.browser,
+                url,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            throw error;
+        }
     }
 
     async goBack(): Promise<void> {
-        await goBack({
-            driver: this.browser,
-            scriptDataAppender: this.scriptDataAppender
-        });
+        try {
+            await goBack({
+                driver: this.browser,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            throw error;
+        }
     }
 
     async refresh(): Promise<void> {
-        await pageRefresh({
-            driver: this.browser,
-            scriptDataAppender: this.scriptDataAppender
-        });
+        try {
+            await pageRefresh({
+                driver: this.browser,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            throw error;
+        }
     }
 
 
     async wait(time: string): Promise<void> {
-        await wait({
-            driver: this.browser,
-            time,
-            scriptDataAppender: this.scriptDataAppender
-        });
+        try {
+            await wait({
+                driver: this.browser,
+                time,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            throw error;
+        }
     }
     async click(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
-        await click({
-            driver: this.browser,
-            selector,
-            scriptDataAppender: this.scriptDataAppender,
-            elementGetter: this.elementGetter,
-            fireflinkIndex,
-            pageDOM,
-            elementName,
-            elementType,
-            platform: this.platform
-        });
+        try {
+            await click({
+                driver: this.browser,
+                selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            throw error;
+        }
     }
     async enterInput(selector: string, value: string, fireflinkIndex: string, pageDOM: string, elementName: string, elementType: string): Promise<void> {
-        await enterInput({
-            driver: this.browser,
-            selector: selector,
-            value,
-            scriptDataAppender: this.scriptDataAppender,
-            elementGetter: this.elementGetter,
-            fireflinkIndex,
-            pageDOM,
-            elementName,
-            elementType,
-            platform: this.platform
-        });
+        try {
+            await enterInput({
+                driver: this.browser,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            throw error;
+        }
     }
     async maximize(): Promise<void> {
-        await maximize({
-            driver: this.browser,
-            scriptDataAppender: this.scriptDataAppender
-        });
+        try {
+            await maximize({
+                driver: this.browser,
+                scriptDataAppender: this.scriptDataAppender
+            });
+        }
+        catch (error) {
+            throw error;
+        }
     }
 
     async clear(pageDOM: string, selector: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
-        await clear({
-            driver: this.browser,
-            selector: selector,
-            scriptDataAppender: this.scriptDataAppender,
-            elementGetter: this.elementGetter,
-            fireflinkIndex,
-            pageDOM,
-            elementName,
-            elementType,
-            platform: this.platform
-        });
+        try {
+            await clear({
+                driver: this.browser,
+                selector: selector,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            throw error;
+        }
     }
 
     async clearAndEnter(pageDOM: string, selector: string, value: string, fireflinkIndex: string, elementName: string, elementType: string): Promise<void> {
-        await clearAndEnter({
-            driver: this.browser,
-            selector: selector,
-            value,
-            scriptDataAppender: this.scriptDataAppender,
-            elementGetter: this.elementGetter,
-            fireflinkIndex,
-            pageDOM,
-            elementName,
-            elementType,
-            platform: this.platform
-        });
+        try {
+            await clearAndEnter({
+                driver: this.browser,
+                selector: selector,
+                value,
+                scriptDataAppender: this.scriptDataAppender,
+                elementGetter: this.elementGetter,
+                fireflinkIndex,
+                pageDOM,
+                elementName,
+                elementType,
+                platform: this.platform
+            });
+        }
+        catch (error) {
+            throw error;
+        }
     }
 
-
 }

package/src/automation/actions/interaction/click.ts

@@ -20,6 +20,6 @@ export async function click(args: ClickInterface): Promise<void> {
                 }]
             });
     } catch (error: any) {
-        throw new Error("Click action failed", { cause: error });
+        throw new Error(`Click action failed :`, { cause: error });
     }
 }

package/src/automation/actions/interaction/enterInput.ts

@@ -29,8 +29,7 @@ export async function enterInput(args: EnterInputInterface): Promise<void> {
 
     }
     catch (error: any) {
-        console.log(error);
-        throw new Error("enter action failed", { cause: error });
+        throw new Error(`enter action failed:`, { cause: error });
     }
 
-}
+}

package/src/core/interfaces/automationRunnerInterface.ts

@@ -1,3 +1,4 @@
+import { AutomationRequest } from "../../core/interfaces/executionDetails.js";
 export interface IAutomationRunner {
-  run(): Promise<void>;
+  run(args:AutomationRequest): Promise<void>;
 }

package/src/core/main/actionHandlerFactory.ts

@@ -1,122 +1,135 @@
 import { ExecutionContext } from "../main/executionContext.js";
 import { ActionExecutor } from "../../automation/actions/executor.js";
 
+type ActionHandler = (result?: any) => Promise<void>;
+
 export function createActionHandlers(
     context: ExecutionContext,
     pageLoad: number,
     implicit: number
-): Record<string, (result: any) => Promise<void>> {
-
-    return {
-
-        open: async () => {
-            await context.session.open({
-                browserName: "chrome",
-                pageLoad,
-                implicit
-            });
-
-            context.executor = new ActionExecutor(
-                await context.session.getCurrentBrowser(),
-                context.scriptAppender,
-                context.locator,
-                context.request.platform
-            );
-
-            context.scriptAppender.add({
-                nlpName: "OpenBrowser",
-                elementsData: [],
-                stepInputs: []
-            });
-        },
-        close: async (result: any) => {
-            await context.session.close();
-        },
-
-        navigate: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-
-            await context.executor.navigate(result.response.keywords[0]);
-        },
-        maximize: async () => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-            await context.executor.maximize();
-        },
-        goBack: async () => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-            await context.executor.goBack();
-        },
-        refresh: async () => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-            await context.executor.refresh();
-        },
-        wait: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-            await context.executor.wait(result.value);
-        },
-        click: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-            await context.executor.click(
-                result.pageDOM,
-                result.selector,
-                result.fireflinkIndex,
-                result.elementName,
-                result.elementType
-            );
-        },
-
-        enter: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-            await context.executor.enterInput(
-                result.selector,
-                result.value,
-                result.fireflinkIndex,
-                result.pageDOM,
-                result.elementName,
-                result.elementType
-            );
-        },
-        clear: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-            await context.executor.clear(
-                result.pageDOM,
-                result.selector,
-                result.fireflinkIndex,
-                result.elementName,
-                result.elementType
-            );
-        },
-        clearThenEnterInput: async (result: any) => {
-            if (!context.executor) {
-                throw new Error("Browser not initialized.");
-            }
-            await context.executor.clearAndEnter(
-                result.pageDOM,
-                result.selector,
-                result.value,
-                result.fireflinkIndex,
-                result.elementName,
-                result.elementType
-            );
-        },
+): Record<string, ActionHandler> {
 
+    const requireExecutor = (): ActionExecutor => {
+        if (!context.executor) {
+            throw new Error("Browser not initialized.");
+        }
+        return context.executor;
     };
 
+    const withExecutor =
+        (fn: (executor: ActionExecutor, result?: any) => Promise<void>): ActionHandler =>
+            async (result?: any) => {
+                try {
+                    const executor = requireExecutor();
+                    await fn(executor, result);
+                }
+                catch (error) {
+                    throw error
+                }
+            };
+    try {
+        return {
+
+            open: async () => {
+                try {
+                    await context.session.open({
+                        browserName: "chrome",
+                        pageLoad,
+                        implicit
+                    });
+
+                    context.executor = new ActionExecutor(
+                        await context.session.getCurrentBrowser(),
+                        context.scriptAppender,
+                        context.locator,
+                        context.request.platform
+                    );
+
+                    context.scriptAppender.add({
+                        nlpName: "OpenBrowser",
+                        elementsData: [],
+                        stepInputs: []
+                    });
+                }
+                catch (error) {
+                    throw new Error(`Error occuried in createActionHandlers , error : ${error}`)
+                }
+            },
+
+            close: async () => {
+                try {
+                    await context.session.close();
+                }
+                catch (error) {
+                    throw new Error(`Error occuried in createActionHandlers , error : ${error}`)
+                }
+            },
+
+            navigate: withExecutor(async (executor, result) => {
+                await executor.navigate(result.response.keywords[0]);
+            }),
+
+            maximize: withExecutor(async (executor) => {
+                await executor.maximize();
+            }),
+
+            goBack: withExecutor(async (executor) => {
+                await executor.goBack();
+            }),
+
+            refresh: withExecutor(async (executor) => {
+                await executor.refresh();
+            }),
+
+            wait: withExecutor(async (executor, result) => {
+                await executor.wait(result.value);
+            }),
+
+            click: withExecutor(async (executor, result) => {
+                await executor.click(
+                    result.pageDOM,
+                    result.selector,
+                    result.fireflinkIndex,
+                    result.elementName,
+                    result.elementType
+                );
+            }),
+
+            enter: withExecutor(async (executor, result) => {
+                await executor.enterInput(
+                    result.selector,
+                    result.value,
+                    result.fireflinkIndex,
+                    result.pageDOM,
+                    result.elementName,
+                    result.elementType
+                );
+            }),
+
+            clear: withExecutor(async (executor, result) => {
+                await executor.clear(
+                    result.pageDOM,
+                    result.selector,
+                    result.fireflinkIndex,
+                    result.elementName,
+                    result.elementType
+                );
+            }),
+
+            clearThenEnterInput: withExecutor(async (executor, result) => {
+                await executor.clearAndEnter(
+                    result.pageDOM,
+                    result.selector,
+                    result.value,
+                    result.fireflinkIndex,
+                    result.elementName,
+                    result.elementType
+                );
+            }),
+        };
+    }
+    catch (error) {
+        throw error
+    }
 
-}
+}

package/src/core/main/runAutomationScript.ts

@@ -16,12 +16,10 @@ import { logger } from "../../utils/logger/logData.js"
 export class AutomationRunner implements IAutomationRunner {
   static sessionTerminationDetails: Record<string, boolean> = {};
   constructor(
-    private readonly request: AutomationRequest,
     private pageLoad: number = 20000,
     private implicit: number = 15000,
-    private tokensConsumed: number = 0
 
-  ) { AutomationRunner.sessionTerminationDetails[request.testCaseId] = false }
+  ) { }
 
   static getSessionTerminationInfo(testCaseId: string): boolean {
     return AutomationRunner.sessionTerminationDetails[testCaseId]
@@ -35,16 +33,14 @@ export class AutomationRunner implements IAutomationRunner {
     domInfo: any,
     extractedRelevantDom: any,
     stepProcessor: StepProcessor,
-    scriptRunner: ScriptRunner
+    scriptRunner: ScriptRunner,
+    request: AutomationRequest
   ) {
     try {
       logger.info("Starting cleanup process...");
       if (context?.session) {
         try {
           const browser = await context.session.getCurrentBrowser();
-          // if (browser) {
-          //   await browser.deleteSession?.();
-          // }
         } catch (e) {
           logger.error("Browser cleanup failed:", e);
         }
@@ -59,7 +55,7 @@ export class AutomationRunner implements IAutomationRunner {
 
       scriptRunner = null as any;
 
-      delete AutomationRunner.sessionTerminationDetails[this.request.testCaseId];
+      delete AutomationRunner.sessionTerminationDetails[request.testCaseId];
 
       if (global.gc) {
         global.gc();
@@ -73,18 +69,19 @@ export class AutomationRunner implements IAutomationRunner {
   }
 
 
-  async run(): Promise<void> {
+  async run(request: AutomationRequest): Promise<void> {
+    AutomationRunner.sessionTerminationDetails[request.testCaseId] = false;
     const apiService = new FireFlinkApiService();
     const scriptRunner = new ScriptRunner(apiService);
-    const context = new ExecutionContext(this.request);
+    const context = new ExecutionContext(request);
     const configProvider = new ServiceProviderBaseUrlProvider();
-    const baseUrl = configProvider.getBaseUrl(this.request.serviceProvider);
+    const baseUrl = configProvider.getBaseUrl(request.serviceProvider);
     let domInfo: any = null;
     let extractedRelevantDom: any = null;
-    const llm = new llmAction(this.request.apiKey, baseUrl, this.request.model, this.request.visionApikey);
+    const llm = new llmAction(request.apiKey, baseUrl, request.model, request.visionApikey);
     const stepProcessor = new StepProcessor(llm);
 
-    const stepResult = await stepProcessor.getLLMResponse({ type: PromptType.USER_STORY_TO_LIST, args: {}, input: { userStory: this.request.userStory } });
+    const stepResult = await stepProcessor.getLLMResponse({ type: PromptType.USER_STORY_TO_LIST, args: {}, input: { userStory: request.userStory } });
 
     const actionHandlers = createActionHandlers(
       context,
@@ -103,7 +100,7 @@ export class AutomationRunner implements IAutomationRunner {
 
     for (const step of listOfSteps) {
       try {
-        if (AutomationRunner.getSessionTerminationInfo(this.request.testCaseId)) { break; }
+        if (AutomationRunner.getSessionTerminationInfo(request.testCaseId)) { break; }
 
         logger.info
           (
@@ -167,7 +164,7 @@ export class AutomationRunner implements IAutomationRunner {
         await logger.saveJSON(extractedRelevantDom, `relevant-dom-${stepCount}`);
         let stepResult: any;
         if (action == "verify") {
-          const stepResult = await stepProcessor.getLLMResponse({
+          stepResult = await stepProcessor.getLLMResponse({
             type: PromptType.VERIFY_PROMPT,
             args: {
               extractedDomJson: JSON.stringify(extractedRelevantDom, null, 2),
@@ -224,35 +221,35 @@ export class AutomationRunner implements IAutomationRunner {
           elementsData: [],
           stepInputs: []
         });
-
-        logger.error(`Error executing step "${step}":`, error.message);
+        logger.error(`Error executing step "${step}":`, error);
         break;
       }
     }
     const payload: IPayload = {
-      scriptName: this.request.scriptName,
-      scriptType: this.request.scriptType,
-      projectId: this.request.projectId,
-      testCaseId: this.request.testCaseId,
-      promptId: this.request.promptId,
-      pageDetails: this.request.pageDetails,
-      generatedBy: this.request.generatedBy,
-      webSocketId: this.request.webSocketId,
-      licenseType: this.request.licenseType,
-      licenseId: this.request.licenseId,
-      userId: this.request.userId,
-      topic: this.request.topic,
-      projectType: this.request.projectType,
+      scriptName: request.scriptName,
+      scriptType: request.scriptType,
+      projectId: request.projectId,
+      testCaseId: request.testCaseId,
+      promptId: request.promptId,
+      pageDetails: request.pageDetails,
+      generatedBy: request.generatedBy,
+      webSocketId: request.webSocketId,
+      licenseType: request.licenseType,
+      licenseId: request.licenseId,
+      userId: request.userId,
+      topic: request.topic,
+      projectType: request.projectType,
       tokensConsumed: (await stepProcessor.getResultTokenUsage()).totalTokens,
     }
     try {
       await scriptRunner.runScriptFromPayload(
         context.scriptAppender.getData(),
         payload,
-        this.request.token,
-        this.request.serverHost
+        request.token,
+        request.serverHost
       );
     } catch (error: any) {
+
       throw new Error(
         "Failed to send payload to FireFlink API:", { cause: error }
       );
@@ -263,7 +260,8 @@ export class AutomationRunner implements IAutomationRunner {
         domInfo,
         extractedRelevantDom,
         stepProcessor,
-        scriptRunner
+        scriptRunner,
+        request
       );
     }
   }

package/src/utils/logger/logData.ts

@@ -4,6 +4,19 @@ import beautify from "js-beautify";
 
 const logsDir = path.resolve(process.cwd(), "logs");
 const domDir = path.resolve(process.cwd(), "dom");
+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");
 
 if (!fs.existsSync(logsDir)) {
     fs.mkdirSync(logsDir, { recursive: true });
@@ -23,26 +36,49 @@ export const logger = {
                 : arg
         );
 
-        const message = `[INFO] ${new Date().toISOString()} - ${formattedArgs.join(" ")}\n`;
+        const message = `[INFO] ${istDate}+05:30 - ${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 formatted = args.map(arg => {
+            if (arg instanceof Error) {
+                let output = arg.stack || `${arg.name}: ${arg.message}`;
+                output = output.replace(
+                    /invalid session id:\s*invalid session id:/gi,
+                    "invalid session id:"
+                );
+
+                if (arg.cause instanceof Error) {
+                    let causeStack = arg.cause.stack || "";
+
+                    causeStack = causeStack.replace(
+                        /invalid session id:\s*invalid session id:/gi,
+                        "invalid session id:"
+                    );
+
+                    output += `\nCaused by: ${causeStack}`;
+                }
+
+                return output;
+            }
+
+            if (typeof arg === "object") {
+                return JSON.stringify(arg, null, 2);
+            }
+
+            return String(arg);
+        });
 
-        const message = `[ERROR] ${new Date().toISOString()} - ${formattedArgs.join(" ")}\n`;
+        const message =
+            `[ERROR] ${new Date().toISOString()} - ${formatted.join(" ")}\n`;
 
         fs.appendFileSync(logFilePath, message, "utf-8");
     },
 
     saveDOM: (domContent: string, fileName?: string) => {
 
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const timestamp = new Date().toLocaleString().replace(/[:.]/g, "-");
         const finalFileName = fileName
             ? `${fileName}.html`
             : `dom-${timestamp}.html`;
@@ -59,7 +95,7 @@ export const logger = {
     },
 
     saveJSON: (data: unknown, fileName?: string) => {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const timestamp = new Date().toLocaleString().replace(/[:.]/g, "-");
 
         const finalFileName = fileName
             ? `${fileName}.json`