@devassure/tpp-engine 0.0.0-stage → 1.8.0

package/src/utils/log-utils.js

@@ -0,0 +1,10 @@
+const ansiRegex = ({onlyFirst = false} = {}) => {
+	const pattern = [
+	    '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
+	].join('|');
+
+	return new RegExp(pattern, onlyFirst ? undefined : 'g');
+}
+
+exports.ansiRegex = ansiRegex;

package/src/utils/logger.js

@@ -0,0 +1,76 @@
+const LOG_PREFIX = '[[TPP]] ';
+
+class Logger {
+
+    constructor(caller, blacklistedLogs) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    action_log(log) {
+        this.blacklistedLogs?.forEach(text => {
+            if(log?.includes(log)) log = log.replaceAll(text, '************');
+        })
+        console.log(log);
+    }
+
+    log(stepName, msg) {
+        if(!!stepName) {
+            this.action_log(`${LOG_PREFIX}${this.caller} :: ${stepName} :: ${msg}`);
+        } else {
+            this.action_log(`${LOG_PREFIX}${this.caller} :: ${msg}`);
+        }
+    }
+
+    logWithoutMasking(stepName, msg) {
+        if(!!stepName) {
+            console.log(`${LOG_PREFIX}${this.caller} :: ${stepName} :: ${msg}`);
+        } else {
+            console.log(`${LOG_PREFIX}${this.caller} :: ${msg}`);
+        }
+    }
+
+    startLog(stepName) {
+        if(!!stepName) {
+            this.action_log(`${LOG_PREFIX}${this.caller} :: ${stepName} :: [BEGIN]`);
+        } else {
+            this.action_log(`${LOG_PREFIX}${this.caller} :: [BEGIN]`);
+        }
+    }
+
+    endLog(stepName) {
+        if(!!stepName) {
+            this.action_log(`${LOG_PREFIX}${this.caller} :: ${stepName} :: [END]`);
+        } else {
+            this.action_log(`${LOG_PREFIX}${this.caller} :: [END]`);
+        }
+    }
+
+    failureLog(stepName) {
+        if(!!stepName) {
+            this.action_log(`${LOG_PREFIX}${this.caller} :: ${stepName} :: [ERROR]`);
+        } else {
+            this.action_log(`${LOG_PREFIX}${this.caller} :: [ERROR]`);
+        }
+    }
+
+    elementBackupRetryLog(tppElement, backupIndex, label) {
+        const backup = tppElement.element.backupLocators[backupIndex]
+        this.log(label, `Unable to find element : ${tppElement.element.label} : ${tppElement.getSelector()}${this.getIndexLog(tppElement)}, retrying with fallback locator: ${backup.locatorType} - ${backup.locator}`);
+    }
+
+    logBackupLocatorUsed(tppElement) {
+        const backupData = {
+          element: tppElement.element.label,
+          locatorType: tppElement.element.locatorType,
+          locator: tppElement.element.locator,
+        };
+        console.log(`${LOG_PREFIX}${this.caller} :: [backup-locator-used] ${JSON.stringify(backupData)}`);
+    }
+
+    getIndexLog = (tppElement) => tppElement.element.index != null ? ` : element index = ${tppElement.element.index}` : '';
+
+}
+
+exports.Logger = Logger;
+exports.LOG_PREFIX = LOG_PREFIX;

package/src/utils/screenshot-utils.js

@@ -0,0 +1,42 @@
+const path = require('path');
+const { LOG_PREFIX } = require("./logger");
+
+function getScreenshotPath(imageName, caller, retry, isVideo) {
+    let fileName = caller?.replaceAll('>', '___')
+    ?.replaceAll(":", "--")
+    ?.replace(/[\b\f\n\r\t\"\\]/g, '_');
+    if(!fileName || fileName.length > 100) {
+        fileName = Date.now().toString();
+    }
+    if (retry) {
+        fileName += `__retry${retry}`;
+    }
+    if (imageName?.trim()) {
+        fileName += `__${imageName.trim().replaceAll(' ', '_')}`;
+    }
+
+    if(isVideo) {
+        return `screenshots/${fileName}.webm`;
+    }
+
+    return `screenshots/${fileName}.png`;
+}
+
+function getScreenshotLog(imageName, filePath, caller, isVideo) {
+    const screenshotLog = isVideo
+    ? {videoPath: path.resolve(filePath)}
+    : {screenshotPath: path.resolve(filePath)};
+    if(imageName?.trim()) {
+        screenshotLog.label = imageName.trim();
+    }
+    const log = JSON.stringify(screenshotLog);
+    
+    if(isVideo) {
+        return `${LOG_PREFIX}${caller} :: [video] ${log}`
+    }
+
+    return `${LOG_PREFIX}${caller} :: [screenshot] ${log}`
+}
+
+exports.getScreenshotPath = getScreenshotPath;
+exports.getScreenshotLog = getScreenshotLog;

package/src/utils/token-utils.js

@@ -0,0 +1,18 @@
+const { FileUtils } = require('../library/file/file-utils');
+
+function resetTokenFile() {
+    const fileUtils = new FileUtils();
+    const filePath = "toktmp/tmp.json";
+
+    try {
+        if (fileUtils.isExists(filePath)) {
+            fileUtils.writeTextContent(filePath, "{}");
+        } else {
+            console.error(`File '${filePath}' does not exist.`);
+        }
+    } catch (error) {
+        console.error(`An error occurred while resetting the file: ${error.message}`);
+    }
+}
+
+exports.resetTokenFile = resetTokenFile;

package/src/utils/vectordb-utils.js

@@ -0,0 +1,125 @@
+const path = require('path');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const axios = require('axios');
+const os = require('os');
+const config = require('../app-config.json');
+
+const VECTORDB_VERSION = '1.0.5'; 
+
+const downloadAppDependency = async (os, targetDir) => {
+    const baseUrl = config.s3Url;
+    // macos/tpp-vector-db/1.0.4/DevAssure.zip
+    const url = getVectorDbPath(baseUrl);
+    const downloadedFileName = 'tpp-vector-db';
+    const targetFileName = os === 'windows' ? `${downloadedFileName}.exe` : downloadedFileName;    
+    const zipFilePath = path.join(targetDir, 'vectordb.zip');
+    const targetFilePath = path.join(targetDir, targetFileName);
+
+    try {
+
+        console.log(`[[TPP]] Downloading excel library...`);
+        const response = await axios.get(url, { responseType: 'stream' });        
+        const writer = fs.createWriteStream(zipFilePath);
+        response.data.pipe(writer);
+
+        await new Promise((resolve, reject) => {
+            writer.on('finish', resolve);
+            writer.on('error', reject);
+        });
+
+        const unzip = require('unzipper');
+        await fs.createReadStream(zipFilePath).pipe(unzip.Extract({ path: targetDir })).promise();
+
+        const extractedFilePath = path.join(targetDir, downloadedFileName);
+        fs.renameSync(extractedFilePath, targetFilePath);
+
+        fs.chmodSync(targetFilePath, 0o755);
+
+        fs.unlinkSync(zipFilePath);
+
+        console.log(`[[TPP]] Excel library downloaded and prepared successfully.`);
+        return true;
+    } catch (error) {
+        console.error(`[[TPP]] Failed to download dependency: ${error.message}`);
+        return false;
+    }
+};
+
+const processExcel = async (dependenciesPath, filePath) => {
+    return new Promise(async (resolve, reject) => {
+        let vectorDbPath;
+        if (process.platform === 'darwin' || process.platform === 'linux') {
+            vectorDbPath = path.join(dependenciesPath, './tpp-vector-db');
+        } else {
+            vectorDbPath = path.join(dependenciesPath, './tpp-vector-db.exe');
+        }
+
+        // Check if vectorDbPath exists
+        if (!fs.existsSync(vectorDbPath)) {
+            const targetDir = path.dirname(vectorDbPath);
+            const os = process.platform === 'win32' ? 'windows' : process.platform === 'darwin' ? 'macos' : 'linux';
+            const downloadStatus = await downloadAppDependency(os, targetDir);
+            if (!downloadStatus) {
+                return reject(new Error("[[TPP]] Failed to download excel library"));
+            }
+        }
+
+        const args = [
+            '--reqid', 'sdsd',
+            '--action', 'process_excel',
+            '--token', 'excel-token',
+            '--index', 'none',
+            '--sheet', filePath,
+        ];
+
+        const child = spawn(vectorDbPath, args);
+
+        let buffer = '';
+
+        child.stdout.on('data', (data) => {
+            buffer += data.toString();
+            if (data.includes('[[RESULT]]')) {
+                try {
+                    const result = JSON.parse(data.toString().replace('[[RESULT]]', '').trim());
+                    resolve(result); 
+                } catch (err) {
+                    reject(new Error('Failed to parse result from processing excel: ' + err.message));
+                }
+            }
+        });
+
+        child.stdout.on('close', () => {
+            if (!buffer.includes('[[ERROR]]')) {
+                reject(new Error(buffer.replace('[[ERROR]]', '')));
+            }
+        });
+    });
+};
+
+const getVectorDbPath = (baseUrl) => {
+    const platform = process.platform;
+    const arch = os.arch();
+    let osPath;
+
+    if (platform === 'win32') {
+        osPath = `windows/tpp-vector-db/${VECTORDB_VERSION}/DevAssure.zip`;
+    } else if (platform === 'darwin') {
+        osPath = arch === 'arm64' 
+            ? `macos/tpp-vector-db/${VECTORDB_VERSION}/DevAssure.zip` 
+            : `macos_intel/tpp-vector-db/${VECTORDB_VERSION}/DevAssure.zip`;
+    } else if (platform === 'linux') {
+        osPath = arch === 'x64' 
+            ? `linux_latest/tpp-vector-db/${VECTORDB_VERSION}/DevAssure.zip` 
+            : `linux/tpp-vector-db/${VECTORDB_VERSION}/DevAssure.zip`;
+    } else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+
+    return `${baseUrl}/${osPath}`;
+};
+
+module.exports = {
+    processExcel,
+    getVectorDbPath
+};

package/src/visual-test/tpp-visual-test.js

@@ -0,0 +1,122 @@
+const { expect } = require("@playwright/test");
+const { default: matchers } = require("expect-axe-playwright");
+const { ansiRegex } = require("../utils/log-utils");
+
+expect.extend(matchers);
+
+class TppVisualCompare {
+
+  constructor(page, caller, timeouts, softAssert) {
+    this.page = page;
+    this.caller = caller;
+    this.timeouts = timeouts;
+    this.softAssert = softAssert;
+  }
+
+  getPageAndFrame() {
+    let page, frame;
+    if(this.page.page && this.page.page()) {
+      frame = this.page;
+      page = this.page.page();
+    } else {
+      page = this.page;
+    }
+    return {page, frame};
+  }
+
+  async comparePage(label) {
+    const {page, frame} = this.getPageAndFrame();
+    try {
+      await expect(page).toHaveScreenshot(`${label}.png`, {timeout: 10000, });
+    } catch (_e) {
+      try {
+        await page.waitForTimeout(5000);
+        await expect(page).toHaveScreenshot(`${label}.png`, {timeout: (this.timeouts?.actionTimeout || 30) * 1000 });
+      } catch (e) {
+        this.handleException(e, label);
+      }
+    }
+  }
+
+  async compareElement(tppElement, label) {
+    const locator = tppElement.locator();
+    try {
+      await expect(locator).toHaveScreenshot(`${label}.png`, {
+        timeout: (this.timeouts?.actionTimeout || 30) * 1000,
+        fullPage: true,
+      });
+    } catch (e) {
+      this.handleException(e, label);
+    }
+  }
+
+  async advancedCompare(tppElement, data) {
+    const {page, frame} = this.getPageAndFrame();
+    const object = tppElement ? tppElement.locator() : page;
+    if(data?.ignoreFailure) {
+      this.ignoreFailure = true;
+    }
+    try {
+      await expect(object).toHaveScreenshot(`${data.label}.png`, {
+        timeout: data.timeout ? Number(data.timeout) : (this.timeouts?.actionTimeout || 30) * 1000,
+        mask: data.maskLocators?.map(loc => {
+          let sanitisedLoc = loc?.startsWith('/html') ? `/${loc}` : loc;
+          return this.page.locator(sanitisedLoc);
+        }) || [],
+        omitBackground: data.ignoreBackground === 'true',
+        fullPage: !!data.fullPage,
+        threshold: data.threshold != null ? Number(data.threshold) : 0.2,
+      });
+    } catch (e) {
+      this.handleException(e, data.label);
+    }
+  }
+
+  handleException(ex, label) {
+    console.log("Visual test exception: ", ex);
+    const message = ex.message.replace(ansiRegex(), '');
+    if(message.startsWith('Screenshot comparison failed') || message.includes('pixels) are different')) {
+      const failureLog = `[visual-comparison-failure] ${this.transformFailureDetails(message, label)}`;
+      if(this.softAssert?.softAssert || this.ignoreFailure) {
+        if(this.softAssert?.logMessage) {
+          this.softAssert.logMessage(this.ignoreFailure ? "Visual comparison failed!" 
+            : "Soft Assert - Visual comparison failed!");
+          this.softAssert.logMessage(failureLog);
+        } else {
+          console.log(`${LOG_PREFIX} ${failureLog}`);
+        }
+        this.softAssert.softAssert && this.softAssert.softAssert.assertions?.push({ result: false, message: this.softAssert?.assertMessage || 'Visual comparison failed!' });
+      } else {
+        throw {message: 'Visual comparison failed!', logs: [failureLog]};
+      }
+    } else {
+      //TODO handle
+      throw ex;
+    }
+  }
+
+  transformFailureDetails(message, label) {
+    const result = {};
+    message.split('\n').forEach(line => {
+      if(line.startsWith('Expected: ')) {
+        //NOOP
+      } else if(line.startsWith('Received: ')) {
+        result.actual = line.replace('Received: ', '');
+      } else if(line.trim().startsWith('Diff: ')) {
+        result.diff = line.trim().replace('Diff: ', '');
+      } 
+    });
+    result.expected = result.actual.replace('actual.png', 'expected.png');
+    const caller = this.caller.split('::')?.at(0)?.trim()?.split('>');
+    const testLabel = caller?.slice(0, -1)
+    ?.join('>')?.trim();
+    const imageName = label ? `${label}-${caller?.at(-1)?.trim()}-${process.platform}.png`
+    : undefined;
+    result.caller = testLabel || "";
+    result.imageName = imageName;
+    return JSON.stringify(result);
+  }
+
+}
+
+exports.TppVisualCompare = TppVisualCompare;

package/src/web/web-executor-agent.js

@@ -0,0 +1,149 @@
+const fs = require('fs');
+const path = require('path');
+const { FileUtils } = require('../library/file/file-utils');
+const { fetchWebState } = require('./web-executor-data-fetch');
+const { sleep } = require('../utils/common-utils');
+
+const EVENT_TAG = "[[TPP_EVENT_LOG]]";
+
+class WebExecutorAgent {
+
+    constructor(actions) {
+        this.actions = actions;
+    }
+
+    async openWebExecutorAgent() {
+        console.log(`${EVENT_TAG} [[TPP WebExecutorAgent Connected]]`)
+
+        const commandFilePath = `.web-exe-agent-commands/commands_${Date.now()}`;
+        new FileUtils().writeTextContent(commandFilePath, 'ready')
+        console.log(`${EVENT_TAG} [[TPP WebExecutorAgent FILE]] ${path.resolve(commandFilePath)}`);
+
+        async function readCommandFromFile() {
+            return new Promise((resolve) => {
+                const checkInterval = setInterval(() => {
+                    if (fs.existsSync(commandFilePath)) {
+                        const commands = fs.readFileSync(commandFilePath, 'utf-8').trim();
+                        if (commands !== 'ready') {
+                            commands?.trim() && console.log(`Received commands: ${commands}`);
+                            clearInterval(checkInterval);
+                            resolve(commands);
+                        }
+                    } else {
+                        resolve('stop_web_executor_agent');
+                    }
+                }, 500); // Check every 500ms
+            });
+        };
+
+        async function deleteCommandFile() {
+            if (await fs.existsSync(commandFilePath)) {
+                fs.unlinkSync(commandFilePath);
+            }
+        }
+
+        let killAgent = false;
+
+        while (true) {
+            console.log('Waiting for a new command...');
+            const commandText = await readCommandFromFile();
+            if (commandText.trim().length === 0) continue;
+            const commands = commandText.split('\n');
+    
+            for (let i = 0; i < commands.length; i++) {
+                const command = commands[i];
+
+                if (command === 'stop_web_executor_agent') {
+                    console.log('Stopping Executor Agent...');
+                    console.log(`${EVENT_TAG} [[TPP WebExecutorAgent Execution Stop]]`);
+                    killAgent = true;
+                    break;
+                }
+        
+                fs.writeFileSync(commandFilePath, 'ready');
+                try {
+                    if (!this.actions.page) {
+                        throw new Error('Web page is closed/not initialized. Please ensure the page is loaded before executing commands.');
+                    }
+                    await this.processWebExecutorCommand(command, i == commands.length - 1);
+                } catch(error) {
+                    this.actions.log(undefined, `[EXECUTOR-AGENT-ERROR] ${error?.message || 'Error performing action on web page!'}`);
+                    console.log(`${EVENT_TAG} [[TPP WebExecutorAgent Execution Stop]]`);
+                    killAgent = true;
+                    break
+                }
+            }
+
+            if(killAgent) {
+                deleteCommandFile();
+                break;
+            }
+
+        }
+        
+        if (fs.existsSync(commandFilePath)) { fs.unlinkSync(commandFilePath); }
+    }
+
+    async printWebState() {
+        let i = 0;
+        let webState;
+        while(i < 4 && !webState) {
+            try {
+                await this.actions.page?.waitForLoadState();
+                await sleep(1000);
+                webState = await fetchWebState(this.actions.page);
+            } catch (e) {
+                i++;
+                if(i < 4 && (this.actions.isNavigationError(e) || this.isScreenshotTimeout(e))) {
+                    this.actions.log(undefined, `Page reloaded or redirected. Retrying... #${i}`);
+                    await sleep(1000);
+                } else {
+                    throw e;
+                }
+            }
+        }
+        console.log(`${EVENT_TAG} [[TPP WebExecutorAgent State]] ${JSON.stringify(webState)}`);
+    }
+
+    //TODO add try catch and throw appropriate error message
+    async processWebExecutorCommand(command, last) {
+        console.log(`${EVENT_TAG} [[TPP WebExecutorAgent Command Execution]] ${command}`);
+        if(!command?.trim()) {
+            return;
+        } else if(command.trim().startsWith('open_url')) {
+            await this.actions.open_url(command.split('open_url').at(-1).trim());
+        } else if (command.trim().startsWith('right_click')) {
+            const data = JSON.parse(command.replace('validation', '').split('right_click').at(-1).trim());
+            await this.actions.click_on_xy(data.x, data.y, { button: 'right' });
+        } else if(command.trim().startsWith('click_on_element')) {
+            const data = JSON.parse(command.replace('validation', '').split('click_on_element').at(-1).trim());
+            await this.actions.click_on_xy(data.x, data.y);
+        } else if (command.trim().startsWith('hover')) {
+            const data = JSON.parse(command.split('hover').at(-1).trim());
+            await this.actions.hover_xy(data.x, data.y);
+        } else if (command.trim().startsWith('double_click')) {
+            const data = JSON.parse(command.split('double_click').at(-1).trim());
+            await this.actions.click_on_xy(data.x, data.y, {  clickCount: 2 });
+        } else if (command.trim().startsWith('key_down')) {
+            await this.actions.key_down_xy(command.split('key_down').at(-1).trim());
+        } else if(command.trim().startsWith('input_value')) {
+            const data = JSON.parse(command.split('input_value').at(-1).trim());
+            await this.actions.input_on_xy(data.x, data.y, data.value || '');
+        } else if(command.trim().startsWith('print_page_state') && last) {
+            await this.printWebState();
+        } else if(command.trim().startsWith('clear_input')) {
+            const data = JSON.parse(command.split('clear_input').at(-1).trim());
+            await this.actions.clear_input(data.x, data.y);
+        } else {
+            this.actions.log(undefined, `[EXECUTOR-AGENT-ERROR] Invalid command entered by the AI agent`);
+            return;
+        }
+    }
+
+    isScreenshotTimeout(error) {
+        error?.message?.includes("page.screenshot")
+        && error?.message?.includes("Timeout")
+    }
+}
+
+exports.WebExecutorAgent = WebExecutorAgent;