@dev-blinq/cucumber_client 1.0.1690-dev → 1.0.1692-dev

package/bin/client/recorderv3/bvt_recorder.js

@@ -1,22 +1,33 @@
 // define the jsdoc type for the input
 import { closeContext, initContext, _getDataFile, resetTestData } from "automation_model";
 import { existsSync, readdirSync, readFileSync, rmSync } from "fs";
+import { rm } from "fs/promises";
 import path from "path";
 import url from "url";
 import { getImplementedSteps, parseRouteFiles } from "./implemented_steps.js";
 import { NamesService, RemoteBrowserService, PublishService } from "./services.js";
 import { BVTStepRunner } from "./step_runner.js";
 import { readFile, writeFile } from "fs/promises";
-import { loadStepDefinitions, getCommandsForImplementedStep } from "./step_utils.js";
+import {
+  loadStepDefinitions,
+  getCommandsForImplementedStep,
+  getCodePage,
+  getCucumberStep,
+  _toRecordingStep,
+  toMethodName,
+} from "./step_utils.js";
 import { parseStepTextParameters } from "../cucumber/utils.js";
 import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
 import chokidar from "chokidar";
 import { unEscapeNonPrintables } from "../cucumber/utils.js";
-import { findAvailablePort } from "../utils/index.js";
-import socketLogger from "../utils/socket_logger.js";
+import { findAvailablePort, getRunsServiceBaseURL } from "../utils/index.js";
+import socketLogger, { getErrorMessage } from "../utils/socket_logger.js";
 import { tmpdir } from "os";
 import { faker } from "@faker-js/faker/locale/en_US";
 import { chromium } from "playwright-core";
+import { axiosClient } from "../utils/axiosClient.js";
+import { _generateCodeFromCommand } from "../code_gen/playwright_codeget.js";
+import { Recording } from "../recording.js";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -361,8 +372,7 @@ async function findNestedFrameSelector(frame, obj) {
     }, frameElement);
     return findNestedFrameSelector(parent, { children: obj, selectors });
   } catch (e) {
-    socketLogger.error(`Error in findNestedFrameSelector: ${e}`);
-    console.error(e);
+    socketLogger.error(`Error in script evaluation: ${getErrorMessage(e)}`, undefined, "findNestedFrameSelector");
   }
 }
 const transformFillAction = (action, el) => {
@@ -507,7 +517,7 @@ export class BVTRecorder {
     this.workspaceService = new PublishService(this.TOKEN);
     this.pageSet = new Set();
     this.lastKnownUrlPath = "";
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
     this.networkEventsFolder = path.join(tmpdir(), "blinq_network_events");
@@ -650,7 +660,7 @@ export class BVTRecorder {
     }
 
     // this.stepRunner.setRemoteDebugPort(this.#remoteDebuggerPort);
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
 
     const ai_config_file = path.join(this.projectDir, "ai_config.json");
     let ai_config = {};
@@ -702,17 +712,6 @@ export class BVTRecorder {
     this.web.tryAllStrategies = true;
     this.page = bvtContext.page;
     this.pageSet.add(this.page);
-    if (process.env.REMOTE_RECORDER === "true") {
-      this.browserEmitter = new RemoteBrowserService({
-        CDP_CONNECT_URL: `http://localhost:${this.#remoteDebuggerPort}`,
-        context: this.context,
-      });
-      this.browserEmitter.on(this.events.browserStateSync, (state) => {
-        this.page = this.browserEmitter.getSelectedPage();
-        this.sendEvent(this.events.browserStateSync, state);
-      });
-    }
-
     this.lastKnownUrlPath = this._updateUrlPath();
     const browser = await this.context.browser();
     this.browser = browser;
@@ -722,8 +721,10 @@ export class BVTRecorder {
       await this.context.exposeBinding(name, handler);
     }
     this._watchTestData();
-    this.web.onRestoreSaveState = (url) => {
-      this._initBrowser({ url });
+    this.web.onRestoreSaveState = async (url) => {
+      await this._initBrowser({ url });
+      this._addPagelisteners(this.context);
+      this._addFrameNavigateListener(this.page);
     };
 
     // create a second browser for locator generation
@@ -1154,7 +1155,7 @@ export class BVTRecorder {
   }
   async closeBrowser() {
     delete process.env.TEMP_RUN;
-    await this.watcher.close().then(() => { });
+    await this.watcher.close().then(() => {});
     this.watcher = null;
     this.previousIndex = null;
     this.previousHistoryLength = null;
@@ -1252,7 +1253,7 @@ export class BVTRecorder {
     }, 100);
     this.timerId = timerId;
   }
-  async runStep({ step, parametersMap, tags, isFirstStep, listenNetwork }, options) {
+  async runStep({ step, parametersMap, tags, isFirstStep, listenNetwork, AICode }, options) {
     const { skipAfter = true, skipBefore = !isFirstStep } = options || {};
 
     const env = path.basename(this.envName, ".json");
@@ -1294,6 +1295,7 @@ export class BVTRecorder {
           envPath: this.envName,
           tags,
           config: this.config,
+          AICode,
         },
         this.bvtContext,
         {
@@ -1313,9 +1315,7 @@ export class BVTRecorder {
       this.bvtContext.navigate = false;
     }
   }
-  async saveScenario({ scenario, featureName, override, isSingleStep, branch, isEditing, env }) {
-    // await updateStepDefinitions({ scenario, featureName, projectDir: this.projectDir }); // updates mjs files
-    // if (!isSingleStep) await updateFeatureFile({ featureName, scenario, override, projectDir: this.projectDir }); // updates gherkin files
+  async saveScenario({ scenario, featureName, override, isSingleStep, branch, isEditing, env, AICode }) {
     const res = await this.workspaceService.saveScenario({
       scenario,
       featureName,
@@ -1325,6 +1325,7 @@ export class BVTRecorder {
       isEditing,
       projectId: path.basename(this.projectDir),
       env: env ?? this.envName,
+      AICode,
     });
     if (res.success) {
       await this.cleanup({ tags: scenario.tags });
@@ -1499,7 +1500,7 @@ export class BVTRecorder {
 
     const steps = [];
     const parameters = [];
-    const datasets = []
+    const datasets = [];
     if (scenario.examples && scenario.examples.length > 0) {
       const example = scenario.examples[0];
       example?.tableHeader?.cells.forEach((cell, index) => {
@@ -1507,7 +1508,7 @@ export class BVTRecorder {
           key: cell.value,
           value: unEscapeNonPrintables(example.tableBody[0].cells[index].value),
         });
-        // datasets.push({ 
+        // datasets.push({
         //   data: example.tableBody[]
         // })
       });
@@ -1580,6 +1581,266 @@ export class BVTRecorder {
     }
     return result;
   }
+  async setStepCodeByScenario({
+    function_name,
+    mjs_file_content,
+    user_request,
+    selectedTarget,
+    page_context,
+    AIMemory,
+  }) {
+    const runsURL = getRunsServiceBaseURL();
+    const url = `${runsURL}/process-user-request/generate-code-with-context`;
+    try {
+      const result = await axiosClient({
+        url,
+        method: "POST",
+        data: {
+          function_name,
+          mjs_file_content,
+          user_request,
+          selectedTarget,
+          page_context,
+          AIMemory,
+        },
+        headers: {
+          Authorization: `Bearer ${this.TOKEN}`,
+          "X-Source": "recorder",
+        },
+      });
+      if (result.status !== 200) {
+        return { success: false, message: "Error while fetching code changes" };
+      }
+      return { success: true, data: result.data };
+    } catch (error) {
+      // @ts-ignore
+      const reason = error?.response?.data?.error || "";
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to fetch code changes: ${errorMessage} \n ${reason}`);
+    }
+  }
+
+  async getStepCodeByScenario({ featureName, scenarioName, projectId, branch }) {
+    try {
+      const runsURL = getRunsServiceBaseURL();
+      const ssoURL = runsURL.replace("/runs", "/auth");
+      const privateRepoURL = `${ssoURL}/isRepoPrivate?project_id=${projectId}`;
+
+      const isPrivateRepoReq = await axiosClient({
+        url: privateRepoURL,
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.TOKEN}`,
+          "X-Source": "recorder",
+        },
+      });
+
+      if (isPrivateRepoReq.status !== 200) {
+        return { success: false, message: "Error while checking repo privacy" };
+      }
+
+      const isPrivateRepo = isPrivateRepoReq.data.isPrivate ? isPrivateRepoReq.data.isPrivate : false;
+
+      const workspaceURL = runsURL.replace("/runs", "/workspace");
+      const url = `${workspaceURL}/get-step-code-by-scenario`;
+
+      const result = await axiosClient({
+        url,
+        method: "POST",
+        data: {
+          scenarioName,
+          featureName,
+          projectId,
+          isPrivateRepo,
+          branch,
+        },
+        headers: {
+          Authorization: `Bearer ${this.TOKEN}`,
+          "X-Source": "recorder",
+        },
+      });
+      if (result.status !== 200) {
+        return { success: false, message: "Error while getting step code" };
+      }
+      return { success: true, data: result.data.stepInfo };
+    } catch (error) {
+      const reason = error?.response?.data?.error || "";
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to get step code: ${errorMessage} \n ${reason}`);
+    }
+  }
+  async getContext() {
+    return await this.page.evaluate(() => {
+      return document.documentElement.outerHTML;
+    });
+  }
+  async deleteCommandFromStepCode({ scenario, AICode, command }) {
+    if (!AICode || AICode.length === 0) {
+      console.log("No AI code available to delete.");
+      return;
+    }
+
+    const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
+    const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+    process.env.tempFeaturesFolderPath = __temp_features_FolderName;
+    process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
+
+    try {
+      await this.stepRunner.copyCodetoTempFolder({ tempFolderPath, AICode });
+      await this.stepRunner.writeWrapperCode(tempFolderPath);
+      const codeView = AICode.find((f) => f.stepName === scenario.step.text);
+
+      if (!codeView) {
+        throw new Error("Step code not found for step: " + scenario.step.text);
+      }
+
+      const functionName = codeView.functionName;
+      const mjsPath = path
+        .normalize(codeView.mjsFile)
+        .split(path.sep)
+        .filter((part) => part !== "features")
+        .join(path.sep);
+      const codePath = path.join(tempFolderPath, mjsPath);
+
+      if (!existsSync(codePath)) {
+        throw new Error("Step code file not found: " + codePath);
+      }
+
+      const codePage = getCodePage(codePath);
+
+      const elements = codePage.getVariableDeclarationAsObject("elements");
+
+      const cucumberStep = getCucumberStep({ step: scenario.step });
+      cucumberStep.text = scenario.step.text;
+      const stepCommands = scenario.step.commands;
+      const cmd = _toRecordingStep(command, scenario.step.name);
+
+      const recording = new Recording();
+      recording.loadFromObject({ steps: stepCommands, step: cucumberStep });
+      const step = { ...recording.steps[0], ...cmd };
+      const result = _generateCodeFromCommand(step, elements, {});
+
+      codePage._removeCommands(functionName, result.codeLines);
+      codePage.removeUnusedElements();
+      codePage.save();
+
+      await rm(tempFolderPath, { recursive: true, force: true });
+
+      return { code: codePage.fileContent, mjsFile: codeView.mjsFile };
+    } catch (error) {
+      await rm(tempFolderPath, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  async addCommandToStepCode({ scenario, AICode }) {
+    if (!AICode || AICode.length === 0) {
+      console.log("No AI code available to add.");
+      return;
+    }
+
+    const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
+    const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+    process.env.tempFeaturesFolderPath = __temp_features_FolderName;
+    process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
+
+    try {
+      await this.stepRunner.copyCodetoTempFolder({ tempFolderPath, AICode });
+      await this.stepRunner.writeWrapperCode(tempFolderPath);
+
+      let codeView = AICode.find((f) => f.stepName === scenario.step.text);
+
+      if (codeView) {
+        scenario.step.commands = [scenario.step.commands.pop()];
+        const functionName = codeView.functionName;
+        const mjsPath = path
+          .normalize(codeView.mjsFile)
+          .split(path.sep)
+          .filter((part) => part !== "features")
+          .join(path.sep);
+        const codePath = path.join(tempFolderPath, mjsPath);
+
+        if (!existsSync(codePath)) {
+          throw new Error("Step code file not found: " + codePath);
+        }
+
+        const codePage = getCodePage(codePath);
+        const elements = codePage.getVariableDeclarationAsObject("elements");
+
+        const cucumberStep = getCucumberStep({ step: scenario.step });
+        cucumberStep.text = scenario.step.text;
+        const stepCommands = scenario.step.commands;
+        const cmd = _toRecordingStep(scenario.step.commands[0], scenario.step.name);
+
+        const recording = new Recording();
+        recording.loadFromObject({ steps: stepCommands, step: cucumberStep });
+        const step = { ...recording.steps[0], ...cmd };
+
+        const result = _generateCodeFromCommand(step, elements, {});
+        codePage.insertElements(result.elements);
+
+        codePage._injectOneCommand(functionName, result.codeLines.join("\n"));
+        codePage.save();
+
+        await rm(tempFolderPath, { recursive: true, force: true });
+
+        return { code: codePage.fileContent, newStep: false, mjsFile: codeView.mjsFile };
+      }
+      console.log("Step code not found for step: ", scenario.step.text);
+
+      codeView = AICode[0];
+      const functionName = toMethodName(scenario.step.text);
+      const codeLines = [];
+      const mjsPath = path
+        .normalize(codeView.mjsFile)
+        .split(path.sep)
+        .filter((part) => part !== "features")
+        .join(path.sep);
+      const codePath = path.join(tempFolderPath, mjsPath);
+
+      if (!existsSync(codePath)) {
+        throw new Error("Step code file not found: " + codePath);
+      }
+
+      const codePage = getCodePage(codePath);
+      const elements = codePage.getVariableDeclarationAsObject("elements");
+      let newElements = { ...elements };
+
+      const cucumberStep = getCucumberStep({ step: scenario.step });
+      cucumberStep.text = scenario.step.text;
+      const stepCommands = scenario.step.commands;
+      stepCommands.forEach((command) => {
+        const cmd = _toRecordingStep(command, scenario.step.name);
+
+        const recording = new Recording();
+        recording.loadFromObject({ steps: stepCommands, step: cucumberStep });
+        const step = { ...recording.steps[0], ...cmd };
+        const result = _generateCodeFromCommand(step, elements, {});
+        newElements = { ...result.elements };
+        codeLines.push(...result.codeLines);
+      });
+
+      codePage.insertElements(newElements);
+      codePage.addInfraCommand(
+        functionName,
+        cucumberStep.text,
+        cucumberStep.getVariablesList(),
+        codeLines,
+        false,
+        "recorder"
+      );
+
+      const keyword = (cucumberStep.keywordAlias ?? cucumberStep.keyword).trim();
+      codePage.addCucumberStep(keyword, cucumberStep.getTemplate(), functionName, stepCommands.length);
+      codePage.save();
+
+      await rm(tempFolderPath, { recursive: true, force: true });
+
+      return { code: codePage.fileContent, newStep: true, functionName, mjsFile: codeView.mjsFile };
+    } catch (error) {
+      await rm(tempFolderPath, { recursive: true, force: true });
+      throw error;
+    }
+  }
   async cleanup({ tags }) {
     const noopStep = {
       text: "Noop",
@@ -1951,7 +2212,7 @@ export class BVTRecorder {
       await page
         .context()
         .grantPermissions(["clipboard-read", "clipboard-write"])
-        .catch(() => { });
+        .catch(() => {});
       await page.evaluate(async (clipboardPayload) => {
         console.log("Injecting clipboard payload", clipboardPayload);
         const toArrayBuffer = (base64) => {

package/bin/client/recorderv3/services.js

@@ -153,7 +153,7 @@ export class PublishService {
     constructor(TOKEN) {
         this.TOKEN = TOKEN;
     }
-    async saveScenario({ scenario, featureName, override, branch, isEditing, projectId, env }) {
+    async saveScenario({ scenario, featureName, override, branch, isEditing, projectId, env, AICode }) {
         const runsURL = getRunsServiceBaseURL();
         const workspaceURL = runsURL.replace("/runs", "/workspace");
         const url = `${workspaceURL}/publish-recording`;
@@ -166,6 +166,7 @@ export class PublishService {
                     featureName,
                     override,
                     env,
+                    AICode,
                 },
                 params: {
                     branch,

package/bin/client/recorderv3/step_runner.js

@@ -67,13 +67,12 @@ export class BVTStepRunner {
           resolve();
         }
       } else {
-        console.warn(`No paused command found for cmdId: ${cmdId}`);
-        socketLogger.error(`No paused command found for cmdId: ${cmdId}`);
+        socketLogger.error(`No paused command found for cmdId: ${cmdId}`, undefined, "BVTStepRunner.resumeExecution");
       }
     }
   }
 
-  async copyCodetoTempFolder({ step, parametersMap, tempFolderPath }) {
+  async copyCodetoTempFolder({ step, parametersMap, tempFolderPath, AICode }) {
     if (!fs.existsSync(tempFolderPath)) {
       fs.mkdirSync(tempFolderPath);
     }
@@ -84,6 +83,18 @@ export class BVTStepRunner {
       overwrite: true,
       recursive: true,
     });
+
+    // If AICode is provided, save it as well
+    if (AICode) {
+      for (const { mjsFileContent, mjsFile } of AICode) {
+        const mjsPath = path
+          .normalize(mjsFile)
+          .split(path.sep)
+          .filter((part) => part !== "features")
+          .join(path.sep);
+        writeFileSync(path.join(tempFolderPath, mjsPath), mjsFileContent);
+      }
+    }
   }
 
   async writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags }) {
@@ -250,7 +261,7 @@ export class BVTStepRunner {
     return { result, info };
   }
 
-  async runStep({ step, parametersMap, envPath, tags, config }, bvtContext, options) {
+  async runStep({ step, parametersMap, envPath, tags, config, AICode }, bvtContext, options) {
     // Create a new AbortController for this specific step execution
     this.#currentStepController = new AbortController();
     const { signal } = this.#currentStepController;
@@ -304,7 +315,7 @@ export class BVTStepRunner {
       process.env.tempFeaturesFolderPath = __temp_features_FolderName;
       process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
 
-      await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath });
+      await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath, AICode });
 
       // Write abort wrapper code with this step's signal
       await this.writeWrapperCode(tempFolderPath, signal);
@@ -335,6 +346,7 @@ export class BVTStepRunner {
           projectDir: this.projectDir,
           stepsDefinitions,
           parametersMap,
+          logger: socketLogger,
         });
         if (codePage) {
           await codePage.save(stepDefsFilePath);