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

package/bin/client/codemod/locators_array/fix_misstructured_elements.js

@@ -0,0 +1,144 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+import * as t from "@babel/types";
+// Normalize babel traverse to handle both CJS (callable export) and ESM (default export)
+const traverse = typeof traverseImport === "function"
+    ? traverseImport
+    : (traverseImport.default ?? traverseImport);
+function isNumericKey(key) {
+    return typeof key === "string" && /^\d+$/.test(key);
+}
+function propName(prop) {
+    if (!t.isObjectProperty(prop))
+        return undefined;
+    const k = prop.key;
+    if (t.isIdentifier(k))
+        return k.name;
+    if (t.isStringLiteral(k))
+        return k.value;
+    if (t.isNumericLiteral(k))
+        return String(k.value);
+    return undefined;
+}
+function stringifyValue(node, source) {
+    if (typeof node.start === "number" && typeof node.end === "number") {
+        return source.slice(node.start, node.end);
+    }
+    return JSON.stringify(null);
+}
+function leadingWhitespace(text, index) {
+    const lineStart = text.lastIndexOf("\n", index - 1) + 1;
+    const match = text.slice(lineStart, index).match(/^[ \t]*/);
+    return match ? match[0] : "";
+}
+function buildLocatorsArray(numericProps, source, indent) {
+    const elements = numericProps
+        .sort((a, b) => Number(propName(a)) - Number(propName(b)))
+        .map((p) => `${indent}  ${stringifyValue(p.value, source)}`);
+    if (elements.length === 0)
+        return "locators: []";
+    return [indent + "locators: [", elements.join(",\n"), indent + "]"].join("\n");
+}
+function fixJsPreserveFormat(code, logger) {
+    let touched = false;
+    const replacements = [];
+    const ast = parse(code, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript", "classProperties", "optionalChaining", "nullishCoalescingOperator", "topLevelAwait"],
+        ranges: true,
+    });
+    traverse(ast, {
+        ObjectExpression(pathObj) {
+            const props = pathObj.node.properties.filter(t.isObjectProperty);
+            if (!props.length)
+                return;
+            const names = props.map(propName).filter(Boolean);
+            const hasElementMeta = names.some((n) => n === "element_name" || n === "element_key");
+            if (!hasElementMeta)
+                return;
+            const hasLocators = names.includes("locators");
+            const numericProps = props.filter((p) => isNumericKey(propName(p)));
+            if (hasLocators || numericProps.length === 0)
+                return;
+            if (typeof pathObj.node.start !== "number" || typeof pathObj.node.end !== "number")
+                return;
+            const leading = leadingWhitespace(code, pathObj.node.start);
+            const otherProps = props.filter((p) => !numericProps.includes(p));
+            const otherTexts = otherProps.map((p) => code.slice(p.start ?? 0, p.end ?? 0));
+            const locatorsText = buildLocatorsArray(numericProps, code, `${leading}  `);
+            const pieces = [locatorsText, ...otherTexts];
+            const baseIndent = `${leading}  `;
+            const normalized = pieces.map((p) => (p.startsWith(baseIndent) ? p : baseIndent + p));
+            const newObjectText = "{\n" + normalized.join(",\n") + "\n" + leading + "}";
+            replacements.push({ start: pathObj.node.start, end: pathObj.node.end, text: newObjectText });
+            touched = true;
+        },
+    });
+    if (!touched)
+        return code;
+    let out = code;
+    replacements
+        .sort((a, b) => b.start - a.start)
+        .forEach(({ start, end, text }) => {
+        out = out.slice(0, start) + text + out.slice(end);
+    });
+    return out;
+}
+function fixJson(content, logger) {
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch {
+        return content;
+    }
+    let touched = false;
+    const visit = (node, logger) => {
+        if (!node || typeof node !== "object")
+            return;
+        if (Array.isArray(node))
+            return node.forEach((n) => visit(n, logger));
+        const record = node;
+        const keys = Object.keys(record);
+        const hasMeta = "element_name" in record || "element_key" in record;
+        const hasLoc = "locators" in record;
+        const nums = keys.filter(isNumericKey);
+        if (hasMeta && !hasLoc && nums.length) {
+            record.locators = nums.sort((a, b) => Number(a) - Number(b)).map((k) => record[k]);
+            nums.forEach((k) => delete record[k]);
+            touched = true;
+        }
+        Object.values(record).forEach((v) => visit(v, logger));
+    };
+    visit(data, logger);
+    return touched ? `${JSON.stringify(data, null, 2)}\n` : content;
+}
+/**
+ * Fixes all files referenced in `issues` under `root`.
+ * `issues` is the array returned by findIssues().
+ * Returns an array of { filePath, original, fixed } for files that changed.
+ */
+export async function fixIssues(issues, root, logger) {
+    // Deduplicate — multiple issues can point to the same file
+    const filePaths = [...new Set(issues.map((i) => i.file))];
+    const changes = [];
+    for (const filePath of filePaths) {
+        const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(root, filePath);
+        const ext = path.extname(absolutePath).toLowerCase();
+        const original = await fs.readFile(absolutePath, "utf8");
+        let fixed = original;
+        if (ext === ".json") {
+            fixed = fixJson(original, logger);
+        }
+        else if (ext === ".mjs" || ext === ".js") {
+            fixed = fixJsPreserveFormat(original, logger);
+        }
+        if (fixed === original)
+            continue;
+        await fs.writeFile(absolutePath, fixed, "utf8");
+        changes.push({ filePath: absolutePath, original, fixed });
+    }
+    return changes;
+}

package/bin/client/codemod/locators_array/index.js

@@ -0,0 +1,114 @@
+import { findIssues } from "./find_misstructured_elements.js";
+import { fixIssues } from "./fix_misstructured_elements.js";
+/**
+ * Converts legacy locator objects that use numeric keys (e.g., `{ 0: {...}, 1: {...} }`)
+ * into a `locators` array, across all JS/MJS/JSON files under a codebase root.
+ * The codemod is idempotent, preserves formatting where possible, and reports timing metrics.
+ *
+ * @param clonedRoot Absolute path to the cloned project directory to scan and fix.
+ * @param logger Logger instance used for progress, issue, and summary output.
+ * @returns Structured codemod run result containing issues found, file changes written, and metrics.
+ *
+ * @example Running the codemod standalone:
+ * ```ts
+ * import { locatorObjectToArray } from "./code_cleanup/codemod/locators_array";
+ * import { consoleLogger } from "./logger";
+ *
+ * const result = await locatorObjectToArray("/tmp/repo", consoleLogger);
+ * console.log(result.message); // e.g., "Fixed 3 file(s)"
+ * ```
+ *
+ * @example Running multiple codemods in sequence:
+ * ```ts
+ * const codemods = [locatorObjectToArray]; // add other codemods as needed
+ * for (const mod of codemods) {
+ *   const outcome = await mod("/tmp/repo", consoleLogger);
+ *   if (!outcome.success) throw new Error(outcome.message);
+ * }
+ * ```
+ */
+async function locatorObjectToArray(clonedRoot, logger) {
+    const start = Date.now();
+    logger.info(`Scanning ${clonedRoot} for misstructured locator objects...`);
+    const findStart = Date.now();
+    const issues = [];
+    try {
+        issues.push(...(await findIssues(clonedRoot, logger)));
+    }
+    catch (error) {
+        const metricsOnFindError = {
+            issueCount: 0,
+            affectedFiles: 0,
+            findDurationMs: Date.now() - findStart,
+            fixDurationMs: 0,
+            filesFixed: 0,
+            wasAffected: false,
+            totalDurationMs: Date.now() - start,
+        };
+        logger.error(`Error during issue finding: ${error.message}`);
+        return {
+            name: "Locator Object to Array",
+            description: "Converts locator objects with numeric keys to arrays.",
+            success: false,
+            message: `Failed to find issues: ${error.message}`,
+            details: { issues: [], changes: [], metrics: metricsOnFindError },
+        };
+    }
+    const metricsBase = {
+        issueCount: issues.length,
+        affectedFiles: [...new Set(issues.map((i) => i.file))].length,
+        findDurationMs: Date.now() - findStart,
+        fixDurationMs: 0,
+        filesFixed: 0,
+        wasAffected: issues.length > 0,
+        totalDurationMs: 0,
+    };
+    if (issues.length === 0) {
+        metricsBase.totalDurationMs = Date.now() - start;
+        logger.info("No issues — nothing to fix");
+        logger.info(`Summary: issues=0 files=0 fixed=0 find=${metricsBase.findDurationMs}ms ` +
+            `fix=${metricsBase.fixDurationMs}ms total=${metricsBase.totalDurationMs}ms`);
+        return {
+            name: "Locator Object to Array",
+            description: "Converts locator objects with numeric keys to arrays.",
+            success: true,
+            message: "No issues found",
+            details: { issues: [], changes: [], metrics: metricsBase },
+        };
+    }
+    logger.info(`Found ${issues.length} issue(s) across ${metricsBase.affectedFiles} file(s)`);
+    issues.forEach((i) => logger.info(`  issue: ${i.file}:${i.line} — ${i.element} (${i.numericCount} numeric keys)`));
+    const fixStart = Date.now();
+    const changes = [];
+    try {
+        changes.push(...(await fixIssues(issues, clonedRoot, logger)));
+    }
+    catch (error) {
+        metricsBase.fixDurationMs = Date.now() - fixStart;
+        metricsBase.totalDurationMs = Date.now() - start;
+        logger.error(`Error during issue fixing: ${error.message}`);
+        return {
+            name: "Locator Object to Array",
+            description: "Converts locator objects with numeric keys to arrays.",
+            success: false,
+            message: `Failed to fix issues: ${error.message}`,
+            details: { issues, changes: [], metrics: metricsBase },
+        };
+    }
+    metricsBase.fixDurationMs = Date.now() - fixStart;
+    metricsBase.filesFixed = changes.length;
+    metricsBase.totalDurationMs = Date.now() - start;
+    logger.info(`Fixed ${changes.length} file(s) in ${metricsBase.fixDurationMs}ms`);
+    changes.forEach((c) => logger.info(`  fixed: ${c.filePath}`));
+    logger.info(`Summary: issues=${metricsBase.issueCount} files=${metricsBase.affectedFiles} ` +
+        `fixed=${metricsBase.filesFixed} find=${metricsBase.findDurationMs}ms ` +
+        `fix=${metricsBase.fixDurationMs}ms total=${metricsBase.totalDurationMs}ms`);
+    return {
+        name: "Locator Object to Array",
+        description: "Converts locator objects with numeric keys to arrays.",
+        success: true,
+        message: `Fixed ${changes.length} file(s)`,
+        details: { issues, changes, metrics: metricsBase },
+    };
+}
+export { locatorObjectToArray };

package/bin/client/codemod/types.js

@@ -0,0 +1 @@
+export {};

package/bin/client/cucumber/feature.js

@@ -6,7 +6,6 @@ import os from "os";
 import path from "path";
 import { parseStepTextParameters, toCucumberExpression, unEscapeNonPrintables } from "./utils.js";
 import stream from "stream";
-import { testStringForRegex } from "../recorderv3/update_feature.js";
 import { generateTestData } from "./feature_data.js";
 import socketLogger from "../utils/socket_logger.js";
 class DataTable {
@@ -490,8 +489,8 @@ const scenarioResolution = async (featureFilePath) => {
     let result = generateTestData(featureFilePath);
     if (result.changed) {
       fs.writeFileSync(tmpFeatureFilePath, result.newContent);
-      console.log("Fake data was generated for this scenario");
-      console.log("Variables:");
+      socketLogger.info("Generated fake data for feature", undefined, "scenarioResolution");
+      socketLogger.info("Variables generated:", result.variables, "scenarioResolution");
       for (let key in result.variables) {
         console.log(`${key}: ${result.variables[key].fake}`);
       }
@@ -503,8 +502,7 @@ const scenarioResolution = async (featureFilePath) => {
       fs.copyFileSync(featureFilePath, tmpFeatureFilePath);
     }
     const writable = new stream.Writable({
-      write: function (chunk, encoding, next) {
-        //console.log(chunk.toString());
+      write: (chunk, encoding, next) => {
         next();
       },
     });
@@ -521,23 +519,12 @@ const scenarioResolution = async (featureFilePath) => {
     // load the support code upfront
     const support = await loadSupport(runConfiguration, environment);
     // run cucumber, using the support code we loaded already
-    await runCucumber({ ...runConfiguration, support }, environment, function (event) {
-      // if (event.source) {
-      //   scenarioInfo.source = event.source.data;
-      // }
-      // if (event.pickle && event.pickle.name === scenarioName) {
-      //   scenarioInfo.pickle = event.pickle;
-      // }
+    await runCucumber({ ...runConfiguration, support }, environment, (event) => {
       if (event.gherkinDocument) {
         gherkinDocument = event.gherkinDocument;
       }
-      //console.log(event);
-      //console.log(JSON.stringify(event, null, 2));
-      // console.log("");
     });
     const feature = new Feature(gherkinDocument, featureFileContent);
-    //const scenario = feature.getScenario(scenarioName);
-    //return scenario;
     return feature;
   } finally {
     try {

package/bin/client/cucumber/steps_definitions.js

@@ -36,6 +36,19 @@ class StepsDefinitions {
     //   }
     // });
     const { expressions, methods } = codePage;
+
+    if (codePage.fileContent.includes('from "./utils.mjs"')) {
+      const filePath = path.join(
+        this.baseFolder,
+        this.isTemp ? (process.env.tempFeaturesFolderPath ?? "__temp_features") : "features",
+        "step_definitions",
+        "utils.mjs"
+      );
+      const utilsCodePage = new CodePage(filePath);
+      utilsCodePage.generateModel();
+      methods.push(...utilsCodePage.methods);
+    }
+
     for (let i = 0; i < expressions.length; i++) {
       const expression = expressions[i];
       const pattern = expression.pattern;
@@ -87,18 +100,10 @@ class StepsDefinitions {
       this.initPage(codePage, mjsFile);
     }
     let stepCount = Object.keys(this.steps).length;
-    if (this.steps["Before"]) {
-      stepCount--;
-    }
-    if (this.steps["After"]) {
-      stepCount--;
-    }
-    if (this.steps["BeforeAll"]) {
-      stepCount--;
-    }
-    if (this.steps["AfterAll"]) {
-      stepCount--;
-    }
+    if (this.steps["Before"]) stepCount--;
+    if (this.steps["After"]) stepCount--;
+    if (this.steps["BeforeAll"]) stepCount--;
+    if (this.steps["AfterAll"]) stepCount--;
     if (print) {
       logger.info("total steps definitions found", stepCount);
     }

package/bin/client/recorderv3/bvt_init.js

@@ -0,0 +1,310 @@
+import { io } from "socket.io-client";
+import { BVTRecorder } from "./bvt_recorder.js";
+import { compareWithScenario } from "../code_gen/duplication_analysis.js";
+import { getAppDataDir } from "../utils/app_dir.js";
+import { readdir } from "fs/promises";
+import socketLogger, { getErrorMessage, responseSize } from "../utils/socket_logger.js";
+import { MIXPANEL_EVENTS, mixpanelTrackEvent } from "./mixpanel.js";
+const port = process.env.EDITOR_PORT || 3003;
+const WS_URL = process.env.WORKER_WS_SERVER_URL || "http://localhost:" + port;
+const userId = process.env.USER_ID || "";
+const SocketIOEvents = {
+    REQUEST: "request",
+    RESPONSE: "response",
+    CONNECT: "connect",
+    DISCONNECT: "disconnect",
+    CREATE_ROOM: "createRoom",
+    JOIN_ROOM: "joinRoom",
+};
+class PromisifiedSocketServer {
+    socket;
+    routes;
+    constructor(socket, routes) {
+        this.socket = socket;
+        this.routes = routes;
+    }
+    init() {
+        this.socket.on(SocketIOEvents.REQUEST, async (data) => {
+            const { event, input, id, roomId, socketId } = data;
+            if (event !== "recorderWindow.getCurrentChromiumPath") {
+                socketLogger.info("Received request", { event, input, id, roomId, socketId });
+            }
+            try {
+                const handler = this.routes[event];
+                if (!handler) {
+                    socketLogger.error(`No handler found for event: ${event}`, undefined, event);
+                    return;
+                }
+                const response = await handler(input);
+                if (event !== "recorderWindow.getCurrentChromiumPath") {
+                    socketLogger.info(`Sending response for ${event}, ${responseSize(response)} bytes`);
+                }
+                this.socket.emit(SocketIOEvents.RESPONSE, { id, value: response, roomId, socketId });
+            }
+            catch (error) {
+                socketLogger.error("Error handling request", {
+                    input,
+                    id,
+                    roomId,
+                    socketId,
+                    error: error instanceof Error ? `${error.message}\n${error.stack}` : error,
+                }, event);
+                this.socket.emit(SocketIOEvents.RESPONSE, {
+                    id,
+                    error: {
+                        message: error?.message,
+                        code: error?.code,
+                        info: error?.info,
+                        stack: error?.stack,
+                    },
+                    roomId,
+                    socketId,
+                });
+            }
+        });
+    }
+}
+const timeOutForFunction = async (promise, timeout = 5000) => {
+    const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(), timeout));
+    try {
+        const res = await Promise.race([promise, timeoutPromise]);
+        return res;
+    }
+    catch (error) {
+        socketLogger.error(error, undefined, "timeOutForFunction");
+        throw error;
+    }
+};
+const CLIENT_IDENTIFIER = "cucumber_client/bvt_recorder";
+async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = null }) {
+    console.log(`Connecting to ${WS_URL}`);
+    socket = socket || io(WS_URL);
+    socketLogger.init(socket, { context: "BVTRecorder", eventName: "BVTRecorder.log" });
+    socket.on(SocketIOEvents.CONNECT, () => {
+        socketLogger.info(`${roomId} Connected to BVTRecorder server`);
+    });
+    socket.on(SocketIOEvents.DISCONNECT, (reason) => {
+        socketLogger.info(`${roomId} Disconnected from server: ${reason}`);
+    });
+    socket.emit(SocketIOEvents.JOIN_ROOM, { id: roomId, window: CLIENT_IDENTIFIER });
+    const recorder = new BVTRecorder({
+        envName,
+        projectDir,
+        TOKEN,
+        sendEvent: (event, data) => {
+            socketLogger.info("Sending event", { event, data, roomId });
+            socket.emit(event, data, roomId);
+        },
+        logger: socketLogger,
+        userId,
+    });
+    // emit connected event for every 50 ms until connection_ack message is recieved
+    let connected = false;
+    const interval = setInterval(() => {
+        if (connected) {
+            clearInterval(interval);
+            return;
+        }
+        socket.emit("BVTRecorder.connected", { roomId, window: "cucumber_client/bvt_recorder" }, roomId);
+    }, 50);
+    const promisifiedSocketServer = new PromisifiedSocketServer(socket, {
+        "recorderWindow.connectionAck": async (input) => {
+            mixpanelTrackEvent(MIXPANEL_EVENTS.RECORDER_CONNECTED, userId);
+            connected = true;
+            clearInterval(interval);
+        },
+        "recorderWindow.openBrowser": async (input) => {
+            return recorder
+                .openBrowser(input)
+                .then(() => {
+                mixpanelTrackEvent(MIXPANEL_EVENTS.CHROMIUM_LOADED, userId);
+                socketLogger.info("BVTRecorder.browserOpened");
+                socket.emit("BVTRecorder.browserOpened", { roomId, window: "cucumber_client/bvt_recorder" });
+            })
+                .catch((e) => {
+                socketLogger.error(`Error opening browser: ${getErrorMessage(e)}`, undefined, "recorderWindow.openBrowser");
+                socket.emit("BVTRecorder.browserLaunchFailed", { roomId, window: "cucumber_client/bvt_recorder" });
+            });
+        },
+        "recorderWindow.closeBrowser": async (input) => {
+            return recorder.closeBrowser(input);
+        },
+        "recorderWindow.reOpenBrowser": async (input) => {
+            return recorder
+                .reOpenBrowser(input)
+                .then(() => {
+                socketLogger.info("BVTRecorder.browserOpened");
+                socket.emit("BVTRecorder.browserOpened", null, roomId);
+            })
+                .catch((e) => {
+                socketLogger.error(`Error reopening browser: ${getErrorMessage(e)}`, undefined, "recorderWindow.reOpenBrowser");
+                socket.emit("BVTRecorder.browserLaunchFailed", null, roomId);
+            });
+        },
+        "recorderWindow.startRecordingInput": async (input) => {
+            return timeOutForFunction(recorder.startRecordingInput(input));
+        },
+        "recorderWindow.stopRecordingInput": async (input) => {
+            return timeOutForFunction(recorder.stopRecordingInput(input));
+        },
+        "recorderWindow.startRecordingText": async (input) => {
+            // console.log("--- {{ }} -- : recorderWindow.startRecordingText", input);
+            return timeOutForFunction(recorder.startRecordingText(input));
+        },
+        "recorderWindow.stopRecordingText": async (input) => {
+            return timeOutForFunction(recorder.stopRecordingText(input));
+        },
+        "recorderWindow.startRecordingContext": async (input) => {
+            return timeOutForFunction(recorder.startRecordingContext(input));
+        },
+        "recorderWindow.stopRecordingContext": async (input) => {
+            return timeOutForFunction(recorder.stopRecordingContext(input));
+        },
+        "recorderWindow.runStep": async (input) => {
+            return recorder.runStep(input);
+        },
+        "recorderWindow.saveScenario": async (input) => {
+            return recorder.saveScenario(input);
+        },
+        "recorderWindow.getImplementedSteps": async (input) => {
+            return (await recorder.getImplementedSteps(input)).implementedSteps;
+        },
+        "recorderWindow.getImplementedScenarios": async (input) => {
+            return (await recorder.getImplementedSteps(input)).scenarios;
+        },
+        "recorderWindow.getCurrentChromiumPath": async () => {
+            return recorder.getCurrentChromiumPath();
+        },
+        "recorderWindow.overwriteTestData": async (input) => {
+            return await recorder.overwriteTestData(input);
+        },
+        "recorderWindow.generateStepName": async (input) => {
+            return recorder.generateStepName(input);
+        },
+        "recorderWindow.getFeatureAndScenario": async (input) => {
+            return recorder.generateScenarioAndFeatureNames(input);
+        },
+        "recorderWindow.generateCommandName": async (input) => {
+            return recorder.generateCommandName(input);
+        },
+        "recorderWindow.loadTestData": async (input) => {
+            return recorder.loadTestData(input);
+        },
+        "recorderWindow.discard": async (input) => {
+            return await recorder.discardTestData(input);
+        },
+        "recorderWindow.addToTestData": async (input) => {
+            return await recorder.addToTestData(input);
+        },
+        "recorderWindow.getScenarios": async () => {
+            return recorder.getScenarios();
+        },
+        "recorderWindow.setShouldTakeScreenshot": async (input) => {
+            return recorder.setShouldTakeScreenshot(input);
+        },
+        "recorderWindow.compareWithScenario": async ({ projectDir, scenario }, roomId) => {
+            return await compareWithScenario(getAppDataDir(projectDir), scenario);
+        },
+        "recorderWindow.getCommandsForImplementedStep": async (input) => {
+            return recorder.getCommandsForImplementedStep(input);
+        },
+        "recorderWindow.getNumberOfOccurrences": async (input) => {
+            return recorder.getNumberOfOccurrences(input);
+        },
+        "recorderWindow.getFakeParams": async ({ parametersMap }) => {
+            return recorder.fakeParams(parametersMap);
+        },
+        "recorderWindow.abortExecution": async (_) => {
+            return recorder.abortExecution();
+        },
+        "recorderWindow.pauseExecution": async (input) => {
+            return recorder.pauseExecution(input);
+        },
+        "recorderWindow.resumeExecution": async (input) => {
+            return recorder.resumeExecution(input);
+        },
+        "recorderWindow.loadExistingScenario": async (input) => {
+            return recorder.loadExistingScenario(input);
+        },
+        "recorderWindow.findRelatedTextInAllFrames": async (input) => {
+            return recorder.findRelatedTextInAllFrames(input);
+        },
+        "recorderWindow.getReportFolder": async (input) => {
+            return recorder.getReportFolder();
+        },
+        "recorderWindow.getSnapshotFiles": async (input) => {
+            const snapshotFolder = recorder.getSnapshotFolder();
+            if (snapshotFolder) {
+                const files = await readdir(snapshotFolder);
+                const ymlFiles = files.filter((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
+                return { folder: snapshotFolder, files: ymlFiles };
+            }
+            else
+                return { folder: null, files: [] };
+        },
+        "recorderWindow.getCurrentPageTitle": async () => {
+            return await recorder.getCurrentPageTitle();
+        },
+        "recorderWindow.getCurrentPageUrl": async () => {
+            return recorder.getCurrentPageUrl();
+        },
+        "recorderWindow.sendAriaSnapshot": async (input) => {
+            const snapshot = input?.snapshot;
+            const deselect = input?.deselect;
+            if (deselect === true) {
+                return await recorder.deselectAriaElements();
+            }
+            if (snapshot !== null) {
+                return await recorder.processAriaSnapshot(snapshot);
+            }
+        },
+        "recorderWindow.revertMode": async () => {
+            await recorder.revertMode();
+        },
+        "recorderWindow.setMode": async (input) => {
+            const mode = input?.mode;
+            return recorder.setMode(mode);
+        },
+        "recorderWindow.getStepsAndCommandsForScenario": async (input) => {
+            return await recorder.getStepsAndCommandsForScenario(input);
+        },
+        "recorderWindow.initExecution": async (input) => {
+            return await recorder.initExecution(input);
+        },
+        "recorderWindow.cleanupExecution": async (input) => {
+            return await recorder.cleanupExecution(input);
+        },
+        "recorderWindow.resetExecution": async (input) => {
+            return await recorder.resetExecution(input);
+        },
+        "recorderWindow.stopRecordingNetwork": async (input) => {
+            return recorder.stopRecordingNetwork(input);
+        },
+        "recorderWindow.cleanup": async (input) => {
+            return recorder.cleanup(input);
+        },
+        "recorderWindow.getStepCodeByScenario": async (input) => {
+            return await recorder.getStepCodeByScenario(input);
+        },
+        "recorderWindow.setStepCodeByScenario": async (input) => {
+            return await recorder.setStepCodeByScenario(input);
+        },
+        "recorderWindow.getRecorderContext": async (input) => {
+            return await recorder.getContext();
+        },
+        "recorderWindow.addCommandToStepCode": async (input) => {
+            return await recorder.addCommandToStepCode(input);
+        },
+        "recorderWindow.deleteCommandFromStepCode": async (input) => {
+            return await recorder.deleteCommandFromStepCode(input);
+        },
+        "recorderWindow.generateLocatorSummaries": async (input) => {
+            return await recorder.generateLocatorSummaries(input);
+        },
+    });
+    socket.on("targetBrowser.command.event", async (input) => {
+        return recorder.onAction(input);
+    });
+    promisifiedSocketServer.init();
+}
+export { BVTRecorderInit };