@dev-blinq/cucumber_client 1.0.1180-dev → 1.0.1180-stage

package/bin/client/recording.js

@@ -5,9 +5,14 @@ import { Step } from "../client/cucumber/feature.js";
 This list need to be in sync with the list exist in the commands.js file
 */
 const Types = {
+  API: "api",
   CLICK: "click_element",
   CLICK_SIMPLE: "click_simple",
+  PARAMETERIZED_CLICK: "parameterized_click",
+  CONTEXT_CLICK: "context_click",
   NAVIGATE: "navigate",
+  GO_BACK: "browser_go_back",
+  GO_FORWARD: "browser_go_forward",
   FILL: "fill_element",
   FILL_SIMPLE: "fill_simple",
   EXECUTE: "execute_page_method",
@@ -29,6 +34,7 @@ const Types = {
   SET_COMBO: "set_combo",
   HOVER: "hover_element",
   EXTRACT_ATTRIBUTE: "extract_attribute",
+  EXTRACT_PROPERTY: "extract_property",
   CLOSE_PAGE: "close_page",
   SET_DATE_TIME: "set_date_time",
   SET_VIEWPORT: "set_viewport",
@@ -40,11 +46,13 @@ const Types = {
   SET_INPUT: "set_input",
   WAIT_FOR_USER_INPUT: "wait_for_user_input",
   VERIFY_ATTRIBUTE: "verify_element_attribute",
+  VERIFY_PROPERTY: "verify_element_property",
   FILL_UNKNOWN: "fill_unknown",
   VERIFY_TEXT_RELATED_TO_TEXT: "verify_text_in_relation",
   VERIFY_FILE_EXISTS: "verify_file_exists",
   SET_INPUT_FILES: "set_input_files",
   VERIFY_PAGE_SNAPSHOT: "verify_page_snapshot",
+  CONDITIONAL_WAIT: "conditional_wait",
 };
 class Recording {
   steps = [];

package/bin/client/run_cucumber.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
 import logger from "../logger.js";
 import path from "path";
 import { scenarioResolution } from "./cucumber/feature.js";
@@ -13,6 +13,77 @@ import crypto from "crypto";
 //import debug from "debug";
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = 0;
 
+// Initialize the editorLogs array to collect all logs
+const editorLogs = [];
+
+// Store original console methods
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+
+// Store original process stdout and stderr write methods
+const originalStdoutWrite = process.stdout.write;
+const originalStderrWrite = process.stderr.write;
+
+// Override console.log
+console.log = function (...args) {
+  const logEntry = {
+    message: args.map((arg) => (typeof arg === "object" ? JSON.stringify(arg) : String(arg))).join(" "),
+  };
+
+  editorLogs.push(logEntry);
+  originalConsoleLog.apply(console, args);
+};
+
+// Override console.error
+console.error = function (...args) {
+  const logEntry = {
+    message: args.map((arg) => (typeof arg === "object" ? JSON.stringify(arg) : String(arg))).join(" "),
+  };
+
+  editorLogs.push(logEntry);
+  originalConsoleError.apply(console, args);
+};
+
+// Override process.stdout.write
+process.stdout.write = function (chunk, encoding, callback) {
+  const logEntry = {
+    message: chunk.toString(),
+  };
+
+  editorLogs.push(logEntry);
+  return originalStdoutWrite.apply(process.stdout, arguments);
+};
+
+// Override process.stderr.write
+process.stderr.write = function (chunk, encoding, callback) {
+  const logEntry = {
+    message: chunk.toString(),
+  };
+
+  editorLogs.push(logEntry);
+  return originalStderrWrite.apply(process.stderr, arguments);
+};
+
+// Function to write logs to file
+const writeLogsToFile = (filePath) => {
+  try {
+    const dirPath = path.dirname(filePath);
+
+    // Create directory if it doesn't exist
+    if (!existsSync(dirPath)) {
+      mkdirSync(dirPath, { recursive: true });
+    }
+
+    // Format logs as plain message on each line
+    const logText = editorLogs.map((log) => `${log.message}`).join("\n");
+
+    // Write logs to plain text file
+    writeFileSync(filePath, logText, { encoding: "utf8" });
+  } catch (error) {
+    logger.error(`Failed to write logs to file: ${error.message}`);
+  }
+};
+
 //do something when app is closing
 
 const runCucumber = async (
@@ -60,6 +131,10 @@ const runCucumber = async (
   } else if (!process.env.NODE_ENV_BLINQ) {
     serviceUrl = "https://logic.blinq.io";
     logger.info("Running in prod mode");
+  } else if (process.env.WHITELABEL === "true") {
+    // if it's a whitelabel it will use "api" instead of "logic"
+    serviceUrl = process.env.NODE_ENV_BLINQ;
+    logger.info("Running in custom mode: " + serviceUrl);
   } else {
     serviceUrl = process.env.NODE_ENV_BLINQ.replace("api", "logic");
     logger.info("Running in custom mode: " + serviceUrl);
@@ -93,7 +168,14 @@ const runCucumber = async (
       }
       return true;
     });
-    process.on("exit", async () => await aiAgent.endScenario());
+    process.on("exit", async () => {
+      // Write logs to file before exiting
+      if (result.scenarioPath) {
+        const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+        writeLogsToFile(logsFilePath);
+      }
+      await aiAgent.endScenario();
+    });
     const context = {};
     result.context = context;
     if (process.env.E2E === "true") {
@@ -105,6 +187,9 @@ const runCucumber = async (
       envFile = await aiAgent.initProjectAndEnvironment(context);
     } catch (e) {
       logger.error(e.message);
+      // Write logs to file before exiting due to error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       if (exit) {
         process.exit(1);
       }
@@ -118,6 +203,9 @@ const runCucumber = async (
     }
     if (!existsSync(fullFeatureFilePath)) {
       logger.error("Feature file not found: " + fullFeatureFilePath);
+      // Write logs to file before exiting due to error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       if (exit) {
         process.exit(1);
       }
@@ -128,6 +216,9 @@ const runCucumber = async (
       feature = await scenarioResolution(fullFeatureFilePath);
     } catch (e) {
       logger.error("Error parsing feature file: " + fullFeatureFilePath);
+      // Write logs to file before exiting due to error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       if (exit) {
         process.exit(1);
       }
@@ -136,6 +227,9 @@ const runCucumber = async (
     const scenario = feature.getScenario(scenarioName);
     if (!scenario) {
       logger.error("Scenario not found: " + scenarioName);
+      // Write logs to file before exiting due to error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       if (exit) {
         process.exit(1);
       }
@@ -146,6 +240,15 @@ const runCucumber = async (
 
     let scenarioId = findNextIdInFolder("./reports");
     let scenarioPath = "./reports" + "/" + scenarioId;
+    const dataFilePath = path.join(scenarioPath, "data.json");
+    mkdirSync(path.dirname(dataFilePath), { recursive: true });
+    if (process.env.NODE_ENV_BLINQ === "local") {
+      let dataPath = aiAgent.project.rootFolder + "/data/data.json";
+      if (existsSync(dataPath)) {
+        const poolData = JSON.parse(readFileSync(dataPath, "utf-8"));
+        writeFileSync(dataFilePath, JSON.stringify(poolData, null, 2), "utf-8");
+      }
+    }
     result.scenarioPath = scenarioPath;
     aiAgent.initTestData(envFile, path.join(scenarioPath, "data.json"));
     let featureFileRelative = path.relative(projectDir, fullFeatureFilePath);
@@ -256,7 +359,7 @@ const runCucumber = async (
           await aiAgent.createNewStepLocal(
             featureName,
             cucumberStep,
-            feature,
+            feature.comments,
             userData,
             first,
             previousTasks,
@@ -283,6 +386,9 @@ const runCucumber = async (
       ) {
         aiAgent.evaluateScenario();
       }
+      // Write logs to file on successful completion
+      const logsFilePath = path.join(scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       await aiAgent.endScenario();
     } catch (e) {
       if (reconnect) {
@@ -303,7 +409,12 @@ const runCucumber = async (
         logger.error(e.stack);
         message = e.message + "\n" + e.stack;
       }
+      aiAgent.scenarioReport.updateLastCommand({ status: false, error: message });
+      // Write logs to file on error
+      const logsFilePath = path.join(result.scenarioPath, "editorLogs.log");
+      writeLogsToFile(logsFilePath);
       await aiAgent.endScenario();
+
       if (exit) {
         process.exit(1);
       }
@@ -316,4 +427,5 @@ const runCucumber = async (
     return result;
   }
 };
-export { runCucumber };
+
+export { runCucumber, editorLogs, writeLogsToFile };

package/bin/client/scenario_report.js

@@ -7,6 +7,8 @@ import { getJsonReport } from "./bvt_json_report.js";
 import axios from "axios";
 import { getRunsServiceBaseURL } from "./utils/index.js";
 import { axiosClient } from "./utils/axiosClient.js";
+import { promisify } from "util";
+import { exec } from "child_process";
 
 const BATCH_SIZE = 10;
 const MAX_RETRIES = 3;
@@ -31,17 +33,12 @@ const findNextIdInFolder = (folder) => {
 // get temp file path from --temp-file arg
 const getTempFilePath = () => {
   let tempFilePath = null;
-
   for (const arg of process.argv) {
     const [key, path] = arg.split("=");
     if (key === "--temp-file" && !!path) {
       tempFilePath = path;
     }
   }
-
-  if (tempFilePath === null) {
-    tempFilePath = process.env.TEMP_FILE_PATH;
-  }
   return tempFilePath;
 };
 
@@ -193,64 +190,114 @@ class ScenarioReport {
     fs.writeFileSync(path, zipBlob);
     return path;
   }
-
+  // Note to future self:
+  // Increased the max retries to 3 and added exponential backoff to increase consistency but traded off availability :)
   async _uploadScenario() {
     try {
-      const scenarioDoc = await this.scenarioUploadService.createScenarioDocument(this.name);
+      let scenarioDoc;
+      let attempts = 1;
+      while (attempts < MAX_RETRIES) {
+        try {
+          scenarioDoc = await this.scenarioUploadService.createScenarioDocument(this.name);
+
+          break; // exit loop if successful
+        } catch (err) {
+          attempts++;
+          await this._delay(2 ** attempts * 1000);
+          if (attempts >= MAX_RETRIES) {
+            logger.error(`Failed to upload scenario document (Attempt ${attempts})`);
+            return;
+          }
+        }
+      }
       const scenarioDocId = scenarioDoc._id;
       const projectId = scenarioDoc.project_id;
       this.scenario_id = scenarioDocId;
       this._saveToFile();
-
-      // console.log("scenarioDocId", scenarioDocId);
       await this.sendRetrainStats(scenarioDocId);
-      // create zip file
       if (process.env.NODE_ENV_BLINQ === "local") {
-        const zipFilePath = await this.createScenarioZip();
-        // upload to server
-        const formData = new FormData();
-        // const file = File(zipFileBlob, "report.zip");
-        formData.append(scenarioDocId, fs.readFileSync(zipFilePath), "report.zip");
-        await this.scenarioUploadService.upload(formData);
+        await this._uploadLocalBundle(scenarioDocId);
       } else {
-        const report = getJsonReport(this);
-        fs.writeFileSync(path.join(this.scenarioPath, "scenario.json"), JSON.stringify(report, null, 2));
-        const fileUris = [...this.getFileUrisScreenShotDir(this.scenarioPath), "scenario.json", "network.json"];
-        const networkJsonPath = path.join(this.scenarioPath, "network.json");
-        if (!fs.existsSync(networkJsonPath)) {
-          fs.writeFileSync(networkJsonPath, JSON.stringify({}), "utf-8");
-        }
-        const presignedUrls = await this.scenarioUploadService.getPresignedUrls(fileUris, scenarioDocId);
-        for (let i = 0; i < fileUris.length; i += BATCH_SIZE) {
-          const batch = fileUris.slice(i, Math.min(i + BATCH_SIZE, fileUris.length));
-          await Promise.all(
-            batch
-              .filter((fileUrl) => presignedUrls[fileUrl] !== undefined)
-              .map(async (fileUrl) => {
-                const filePath = path.join(this.scenarioPath, fileUrl);
-                for (let j = 0; j < MAX_RETRIES; j++) {
-                  const success = await this.scenarioUploadService.uploadFile(filePath, presignedUrls[fileUrl]);
-                  if (success) {
-                    return;
-                  }
-                }
-                console.error("Failed to upload file", fileUrl);
-              })
-          );
-        }
-        await this.scenarioUploadService.uploadComplete(scenarioDocId, projectId);
+        await this._uploadRemoteBundle(scenarioDocId, projectId);
       }
       logger.info("Scenario uploaded successfully");
-
       this.logReportLink(projectId, scenarioDocId);
-
-      // delete zip file
-      // fs.unlinkSync(this.scenarioPath + '/example.zip');
     } catch (err) {
-      logger.info("Failed to upload scenario - ignored");
-      logger.debug(err);
-      //console.error(err);
+      logger.error("Scenario upload failed");
+      logger.debug("Error while uploading : ", err);
+    }
+  }
+  // Local environment uploader decomposed the function for better readability
+  async _uploadLocalBundle(scenarioDocId) {
+    const zipFilePath = await this.createScenarioZip();
+    const formData = new FormData();
+    formData.append("scenarioId", scenarioDocId);
+    formData.append("file", fs.createReadStream(zipFilePath));
+
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await this.scenarioUploadService.upload(formData);
+        fs.unlinkSync(zipFilePath);
+        return;
+      } catch (err) {
+        logger.debug("Local upload attempt failed", { attempt, error: err });
+        // added delays between retries for better consistency over availability
+        await this._delay(2 ** attempt * 1000);
+      }
+    }
+    throw new Error(`Local upload failed after ${MAX_RETRIES} attempts`);
+  }
+
+  // decomposed the function for better readability  this function is used to upload
+  async _uploadRemoteBundle(scenarioDocId, projectId) {
+    const report = getJsonReport(this);
+    fs.writeFileSync(path.join(this.scenarioPath, "scenario.json"), JSON.stringify(report, null, 2));
+
+    const fileUris = [
+      ...this.getFileUrisScreenShotDir(this.scenarioPath),
+      "scenario.json",
+      "network.json",
+      "editorLogs.log",
+    ];
+    const networkJsonPath = path.join(this.scenarioPath, "network.json");
+    if (!fs.existsSync(networkJsonPath)) {
+      fs.writeFileSync(networkJsonPath, JSON.stringify({}), "utf-8");
+    }
+
+    const presignedUrls = await this.scenarioUploadService.getPresignedUrls(fileUris, scenarioDocId);
+    const missing = fileUris.filter((uri) => !presignedUrls[uri]);
+    if (missing.length) {
+      throw new Error(`Missing presigned URLs for: ${missing.join(", ")}`);
+    }
+
+    // Upload files in batches with retries
+    for (let i = 0; i < fileUris.length; i += BATCH_SIZE) {
+      const batch = fileUris.slice(i, i + BATCH_SIZE);
+      await Promise.all(batch.map((uri) => this._retryUploadFile(uri, presignedUrls[uri])));
     }
+
+    await this.scenarioUploadService.uploadComplete(scenarioDocId, projectId);
+  }
+
+  // Retry helper it will retry the upload of a file if it fails given file uri and url here Max_retires is and each retiry wait time  : 2secs ,4secs, 8 secs
+  // Note to self : if the still upload fails a lot we have to investigate the file formats too
+  async _retryUploadFile(fileUri, url) {
+    const filePath = path.join(this.scenarioPath, fileUri);
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await this.scenarioUploadService.uploadFile(filePath, url);
+        return;
+      } catch (err) {
+        logger.debug("Upload file attempt failed ", { fileUri, attempt, error: err });
+        await this._delay(2 ** attempt * 1000);
+      }
+    }
+    throw new Error(`Failed to upload file ${fileUri} after ${MAX_RETRIES} attempts`);
+  }
+
+  // Utility delay can be used to delay anything  (Note to self : Replace it with the built in delay function later)
+  _delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
   logReportLink(projectId, scenarioId) {
@@ -269,6 +316,12 @@ class ScenarioReport {
       baseUrl = process.env.NODE_ENV_BLINQ.replace("api", "app");
     }
     const reportLink = baseUrl + "/" + projectId + "/scenario-report/" + scenarioId;
+    try {
+      const status = getJsonReport(this).result.status;
+      publishReportLinkToGuacServer(reportLink, status === "PASSED");
+    } catch (err) {
+      logger.error(`Failed to publish report link to guac server: ${err}`);
+    }
     logger.info(`Report link :- ${reportLink}`);
   }
 
@@ -424,5 +477,14 @@ class ScenarioReport {
     }
   }
 }
-
+function publishReportLinkToGuacServer(reportLink, status) {
+  try {
+    if (existsSync('/tmp/report_publish.sh')) {
+      const execAsync = promisify(exec);
+      execAsync("sh /tmp/report_publish.sh " + reportLink + " " + status);
+    }
+  } catch (error) {
+    logger.error("Error while publishing report link to Guac server: " + error);
+  }
+}
 export { ScenarioReport, findNextIdInFolder };

package/bin/client/test_scenario.js

@@ -267,7 +267,6 @@ try {
     }
     if (validatePath !== "null") {
       await prevrunResult.context.stable.verifyPagePath(validatePath);
-
     }
     //finalCompare = true;
   } catch (e) {

package/bin/index.js

@@ -13,4 +13,5 @@ export * from "./client/cucumber/feature_data.js";
 export * from "./client/cucumber/steps_definitions.js";
 export * from "./client/profiler.js";
 export * from "./client/code_cleanup/utils.js";
+
 export * from "./client/code_cleanup/find_step_definition_references.js";

package/package.json

@@ -1,22 +1,26 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1180-dev",
-  "description": "",
+  "version": "1.0.1180-stage",
+  "description": " ",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",
   "type": "module",
   "scripts": {
-    "pack": "mkdir build && mkdir build/bin && cp -R ./src/* ./build/bin && cp ./package.json ./build",
+    "pack": "npm run bundle && mkdir build && mkdir build/bin && cp -R ./src/* ./build/bin && cp ./package.json ./build",
     "test": "node ./test/test.js",
     "tests_prod": "rm -rf results.json && cross-env NODE_ENV_BLINQ=prod TOKEN=xxx npx mocha --parallel --jobs=10 ./tests",
     "tests": "node ./multi_test_runner.js",
     "lint": "eslint ./src/**/*.js",
     "clean": "rm -rf ./build",
     "build": "npm run clean && npm run pack",
+    "build:watch": "npx nodemon --watch src/client --exec 'npm run build'",
     "update_logic": "rm -rf ../logic/node_modules/@dev-blinq && mkdir ../logic/node_modules/@dev-blinq && mkdir ../logic/node_modules/@dev-blinq/cucumber_client && mkdir ../logic/node_modules/@dev-blinq/cucumber_client/bin && mkdir ../logic/node_modules/@dev-blinq/cucumber_client/node_modules && cp -R ./build/* ../logic/node_modules/@dev-blinq/cucumber_client/bin && cp -R ./node_modules/* ../logic/node_modules/@dev-blinq/cucumber_client/node_modules && cp ./package.json ../logic/node_modules/@dev-blinq/cucumber_client/",
     "version-bump": "npm version prepatch --preid=dev",
-    "scripts_regression": "cross-env HEADLESS=true npx mocha --bail --parallel --jobs=12 ./scripts_regression/ --timeout 120000",
-    "runtime_reg": "cross-env HEADLESS=true npx mocha --bail --parallel --jobs=12 ./runtime_regression/ --timeout 4800000"
+    "scripts_regression": "npm run bundle && cross-env HEADLESS=true npx mocha --bail --parallel --jobs=12 ./scripts_regression/ --timeout 120000",
+    "runtime_reg": "npm run bundle && cross-env HEADLESS=true npx mocha --bail --parallel --jobs=12 ./runtime_regression/ --timeout 4800000",
+    "bundle": "npx tsup",
+    "bundle:watch": "npx tsup --watch",
+    "regenerate_baselines": "rm -rf ./scripts_regression/locators_baseline/*  ./scripts_regression/commands_baseline/* && npm run scripts_regression && npm run scripts_regression"
   },
   "author": "",
   "license": "ISC",
@@ -26,9 +30,9 @@
     "@babel/traverse": "^7.27.1",
     "@babel/types": "^7.27.1",
     "@cucumber/tag-expressions": "^6.1.1",
-    "@dev-blinq/cucumber-js": "1.0.171-dev",
+    "@dev-blinq/cucumber-js": "1.0.91-stage",
     "@faker-js/faker": "^8.1.0",
-    "automation_model": "1.0.715-dev",
+    "automation_model": "1.0.691-stage",
     "axios": "^1.7.4",
     "chokidar": "^3.6.0",
     "create-require": "^1.1.1",
@@ -43,6 +47,7 @@
     "patch-package": "^8.0.0",
     "playwright-core": "1.52.0",
     "prettier": "^3.2.5",
+    "prettier-plugin-gherkin": "^3.1.2",
     "pureimage": "0.4.9",
     "socket.io": "^4.7.5",
     "socket.io-client": "^4.7.5",
@@ -59,6 +64,8 @@
     "eslint": "^8.50.0",
     "http-server": "^14.1.1",
     "mocha": "^10.2.0",
-    "readline-sync": "^1.4.10"
+    "readline-sync": "^1.4.10",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
   }
 }

package/bin/client/code_gen/get_implemented_steps.js

@@ -1,27 +0,0 @@
-import { StepsDefinitions } from "../cucumber/steps_definitions.js";
-import fs from "fs";
-const getImplementedSteps = (projectDir) => {
-  try {
-    const stepsDefinitions = new StepsDefinitions(projectDir);
-    stepsDefinitions.load(false);
-    const keys = Object.keys(stepsDefinitions.steps).filter((key) => key !== "Before" && key !== "After");
-    return keys;
-  } catch (error) {
-    console.log(error);
-    process.exit(1);
-  }
-};
-const args = process.argv.slice(2);
-if (args.length < 1 || args.length > 2) {
-  console.log("Usage: node get_implemented_steps.js <projectDir> [<outputFilePath>]");
-  process.exit(1);
-}
-const projectDir = args[0];
-const implementedSteps = getImplementedSteps(projectDir);
-const output = JSON.stringify(implementedSteps, null, 2);
-if (args.length === 2) {
-  const outputFilePath = args[1];
-  fs.writeFileSync(outputFilePath, output);
-} else {
-  console.log(output);
-}