@dev-blinq/cucumber_client 1.0.1437-stage → 1.0.1438-stage

package/bin/client/recorderv3/step_utils.js

@@ -1,7 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import path from "path";
-import url from "url";
-import logger from "../../logger.js";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import url from "node:url";
 import { CodePage, getAiConfig } from "../code_gen/page_reflection.js";
 import { generateCode, generatePageName } from "../code_gen/playwright_codeget.js";
 import { invertCodeToCommand } from "../code_gen/code_inversion.js";
@@ -9,8 +8,9 @@ import { Step } from "../cucumber/feature.js";
 import { locateDefinitionPath, StepsDefinitions } from "../cucumber/steps_definitions.js";
 import { Recording } from "../recording.js";
 import { generateApiCode } from "../code_gen/api_codegen.js";
-import { tmpdir } from "os";
-import { createHash } from "crypto";
+import { tmpdir } from "node:os";
+import { createHash } from "node:crypto";
+import { getErrorMessage } from "../utils/socket_logger.js";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -495,7 +495,15 @@ function makeStepTextUnique(step, stepsDefinitions) {
   step.text = stepText;
 }
 
-export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions, parametersMap }) {
+export async function saveRecording({
+  step,
+  cucumberStep,
+  codePage,
+  projectDir,
+  stepsDefinitions,
+  parametersMap,
+  logger,
+}) {
   if (step.commands && Array.isArray(step.commands)) {
     step.commands = step.commands.map((cmd) => toRecordingStep(cmd, parametersMap, step.text));
   }
@@ -506,21 +514,19 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       rmSync(routesPath, { recursive: true });
     }
     mkdirSync(routesPath, { recursive: true });
-    saveRoutes({ step, folderPath: routesPath });
+    saveRoutes({ step, folderPath: routesPath }, logger);
   } else {
     if (existsSync(routesPath)) {
-      // remove the folder
       try {
         rmSync(routesPath, { recursive: true });
-        //
       } catch (error) {
-        //
+        logger.error(`Error removing temp routes folder: ${getErrorMessage(error)}`);
       }
       routesPath = path.join(projectDir, "data", "routes");
       if (!existsSync(routesPath)) {
         mkdirSync(routesPath, { recursive: true });
       }
-      saveRoutes({ step, folderPath: routesPath });
+      saveRoutes({ step, folderPath: routesPath }, logger);
     }
   }
 
@@ -529,7 +535,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
   }
 
   if (step.isImplemented && step.shouldOverride) {
-    let stepDef = stepsDefinitions.findMatchingStep(step.text);
+    const stepDef = stepsDefinitions.findMatchingStep(step.text);
     codePage = getCodePage(stepDef.file);
   } else {
     const isUtilStep = makeStepTextUnique(step, stepsDefinitions);
@@ -555,21 +561,20 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       rmSync(routesPath, { recursive: true });
     }
     mkdirSync(routesPath, { recursive: true });
-    saveRoutes({ step, folderPath: routesPath });
+    saveRoutes({ step, folderPath: routesPath }, logger);
   } else {
     if (existsSync(routesPath)) {
-      // remove the folder
       try {
         rmSync(routesPath, { recursive: true });
       } catch (error) {
-        //
+        logger.error(`Error removing temp routes folder: ${getErrorMessage(error)}`);
       }
     }
     routesPath = path.join(projectDir, "data", "routes");
     if (!existsSync(routesPath)) {
       mkdirSync(routesPath, { recursive: true });
     }
-    saveRoutes({ step, folderPath: routesPath });
+    saveRoutes({ step, folderPath: routesPath }, logger);
   }
 
   cucumberStep.text = step.text;
@@ -638,7 +643,6 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
   } else {
     const generateCodeResult = generateCode(recording, codePage, userData, projectDir, methodName);
     if (generateCodeResult.noCode === true) {
-      logger.log("No code generated for step: " + step.text);
       return generateCodeResult.page;
     }
     codePage = generateCodeResult.page;
@@ -747,7 +751,7 @@ export const getCommandsForImplementedStep = (stepName, stepsDefinitions, stepPa
     const file = step?.file;
     const locatorsJson = getLocatorsJson(file);
     if (!step) {
-      throw new Error("Step definition not found" + stepName);
+      throw new Error(`Step definition not found: ${stepName}`);
     }
     isImplemented = true;
     const { codeCommands, codePage, elements, parametersNames, error } =
@@ -831,7 +835,7 @@ export async function executeStep({ stepsDefinitions, cucumberStep, context, cod
   }
 }
 
-export async function updateStepDefinitions({ scenario, featureName, projectDir }) {
+export async function updateStepDefinitions({ scenario, featureName, projectDir, logger }) {
   // set the candidate step definition file name
   // set the utils file path
   const utilsFilePath = path.join(projectDir, "features", "step_definitions", "utils.mjs");
@@ -865,32 +869,25 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
     if ((step.isImplemented && !step.shouldOverride) || step.commands.length === 0) {
       let routesPath = path.join(tmpdir(), `blinq_temp_routes`);
       if (process.env.TEMP_RUN === "true") {
-        console.log("Save routes in temp folder for running:", routesPath);
         if (existsSync(routesPath)) {
-          console.log("Removing existing temp_routes_folder:", routesPath);
           routesPath = path.join(tmpdir(), `blinq_temp_routes`);
           rmSync(routesPath, { recursive: true });
         }
         mkdirSync(routesPath, { recursive: true });
-        console.log("Created temp_routes_folder:", routesPath);
-        saveRoutes({ step, folderPath: routesPath });
+        saveRoutes({ step, folderPath: routesPath }, logger);
       } else {
-        console.log("Saving routes in project directory:", projectDir);
         if (existsSync(routesPath)) {
-          // remove the folder
           try {
             rmSync(routesPath, { recursive: true });
-            console.log("Removed temp_routes_folder:", routesPath);
           } catch (error) {
-            console.error("Error removing temp_routes folder", error);
+            logger.error(`Error removing temp routes folder: ${getErrorMessage(error)}`);
           }
         }
         routesPath = path.join(projectDir, "data", "routes");
-        console.log("Saving routes to:", routesPath);
         if (!existsSync(routesPath)) {
           mkdirSync(routesPath, { recursive: true });
         }
-        saveRoutes({ step, folderPath: routesPath });
+        saveRoutes({ step, folderPath: routesPath }, logger);
       }
       if (step.commands && Array.isArray(step.commands)) {
         step.commands = step.commands.map((cmd) => toRecordingStep(cmd, scenario.parametersMap));
@@ -900,7 +897,6 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
     const cucumberStep = getCucumberStep({ step });
     const pageName = generatePageName(step.startFrame?.url ?? "default");
     const stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
-    // path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
     let codePage = getCodePage(stepDefsFilePath);
     codePage = await saveRecording({
       step,
@@ -921,7 +917,7 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   writeFileSync(utilsFilePath, utilsContent, "utf8");
 }
 
-export function saveRoutes({ step, folderPath }) {
+export function saveRoutes({ step, folderPath }, logger) {
   const routeItems = step.routeItems;
   if (!routeItems || routeItems.length === 0) {
     return;
@@ -944,21 +940,18 @@ export function saveRoutes({ step, folderPath }) {
     };
   });
 
-  const routesFilePath = path.join(folderPath, stepNameHash + ".json");
-  console.log("Routes file path:", routesFilePath);
+  const routesFilePath = path.join(folderPath, `${stepNameHash}.json`);
   const routesData = {
     template,
     routes: routeItemsWithFilters,
   };
-  console.log("Routes data to save:", routesData);
 
   if (!existsSync(folderPath)) {
     mkdirSync(folderPath, { recursive: true });
   }
   try {
     writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2), "utf8");
-    console.log("Saved routes to", routesFilePath);
   } catch (error) {
-    console.error("Failed to save routes to", routesFilePath, "Error:", error);
+    logger.error(`Error saving routes to ${routesFilePath}: ${getErrorMessage(error)}`);
   }
 }

package/bin/client/recorderv3/update_feature.js

@@ -1,8 +1,9 @@
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import path from "path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
 import { getDefaultPrettierConfig } from "../code_cleanup/utils.js";
 import prettier from "prettier";
-export function containsScenario({ featureFileContent, scenarioName }) {
+
+function containsScenario({ featureFileContent, scenarioName }) {
   const lines = featureFileContent.split("\n");
   for (const line of lines) {
     const trimmedLine = line.trim();
@@ -14,7 +15,7 @@ export function containsScenario({ featureFileContent, scenarioName }) {
   }
 }
 
-export function testStringForRegex(text) {
+function testStringForRegex(text) {
   const regexEndPattern = /\/([gimuy]*)$/;
   if (text.startsWith("/")) {
     const match = regexEndPattern.test(text);
@@ -31,7 +32,7 @@ export function testStringForRegex(text) {
   return false;
 }
 
-const escapeNonPrintables = (text) => {
+function escapeNonPrintables(text) {
   const t = text.replace(/\n/g, "\\n").replace(/\t/g, "\\t"); // .replace(/\|/g, "\\|");
   let result = "";
   // replace \ with \\ and | with \|
@@ -60,8 +61,9 @@ const escapeNonPrintables = (text) => {
     }
   }
   return result;
-};
-export function getCommandContent(command) {
+}
+
+function getCommandContent(command) {
   switch (command.type) {
     case "click_element": {
       return `${command.count === 2 ? "Double click" : "Click"} on ${escapeNonPrintables(command.element.name)}`;
@@ -108,15 +110,15 @@ export function getCommandContent(command) {
   }
 }
 
-export function getExamplesContent(parametersMap, datasets) {
+function getExamplesContent(parametersMap, datasets) {
   if (datasets && datasets.length > 0) {
-    let result = ''
+    let result = "";
     const keys = Object.keys(parametersMap);
     result += "\t\tExamples:\n";
 
     result += `\t\t| ${keys.join(" | ")} |\n`;
     for (const dataset of datasets) {
-      result += `\t\t| ${dataset.data.map(d => escapeNonPrintables(d.value)).join(" | ")} |\n`;
+      result += `\t\t| ${dataset.data.map((d) => escapeNonPrintables(d.value)).join(" | ")} |\n`;
     }
     return result;
   }
@@ -155,19 +157,19 @@ function getTagsContent(scenario, featureFileObject) {
   return tagsContent;
 }
 
-export function getScenarioContent({ scenario }, featureFileObject) {
+function getScenarioContent({ scenario }, featureFileObject) {
   const prametersMap = scenario.parametersMap ?? {};
   const isParmatersMapEmpty = Object.keys(prametersMap).length === 0;
   let scenarioContent = isParmatersMapEmpty ? `Scenario: ${scenario.name}\n` : `Scenario Outline: ${scenario.name}\n`;
 
-  let tagsContent = getTagsContent(scenario, featureFileObject);
+  const tagsContent = getTagsContent(scenario, featureFileObject);
 
-  scenarioContent = "\t" + tagsContent + "\n" + scenarioContent;
+  scenarioContent = `\t${tagsContent}\n${scenarioContent}`;
 
   for (const step of scenario.steps) {
     const commands = step.commands ?? [];
-    let commentContents = commands.map(getCommandContent).map(escapeNonPrintables);
-    let commentContent = commentContents.filter((content) => content.length > 0).join(", ");
+    const commentContents = commands.map(getCommandContent).map(escapeNonPrintables);
+    const commentContent = commentContents.filter((content) => content.length > 0).join(", ");
 
     if (commentContent) {
       scenarioContent += `\t# ${commentContent}\n`;
@@ -179,14 +181,15 @@ export function getScenarioContent({ scenario }, featureFileObject) {
   }
   return scenarioContent;
 }
-export const escapeString = (str) => {
+
+function escapeString(str) {
   // Step 1: Replace all literal newline characters with a temporary placeholder
   const placeholder = "\\n";
   str = str.replace(/\n/g, placeholder);
   return str;
-};
+}
 
-const GherkinToObject = (gherkin) => {
+function GherkinToObject(gherkin) {
   const obj = {
     featureName: "",
     scenarios: [],
@@ -222,7 +225,7 @@ const GherkinToObject = (gherkin) => {
   }
 
   const getScenario = () => {
-    let scenario = {
+    const scenario = {
       name: "",
       tags: [],
       steps: [],
@@ -299,7 +302,7 @@ const GherkinToObject = (gherkin) => {
     skipEmptyLines();
   }
   return obj;
-};
+}
 
 // remove lines starting with "Scenario:" or "Scenario Outline:" that contain the scenario name until the next scenario and then append the new scenario content
 // assumes that there are no multiple scenarios with the same name and having comments and tags in each scenario
@@ -333,14 +336,14 @@ function updateExistingScenario({
       continue;
     }
 
-    let scenarioHeader = `${scenario.hasParams ? "Scenario Outline" : "Scenario"}: ${scenario.name}`;
+    const scenarioHeader = `${scenario.hasParams ? "Scenario Outline" : "Scenario"}: ${scenario.name}`;
     let tagsLine;
 
     if (scenario.tags?.length > 0) {
       tagsLine = scenario.tags.map((t) => `@${t}`).join(" ");
     }
 
-    if (tagsLine) results.push("\t" + tagsLine);
+    if (tagsLine) results.push(`\t${tagsLine}`);
     results.push(`\t${scenarioHeader}`);
 
     for (const step of scenario.steps) {
@@ -359,8 +362,8 @@ function updateExistingScenario({
   return results.join("\n");
 }
 
-export async function updateFeatureFile({ featureName, scenario, override, projectDir }) {
-  const featureFilePath = path.join(projectDir, "features", featureName + ".feature");
+async function updateFeatureFile({ featureName, scenario, override, projectDir, logger }) {
+  const featureFilePath = path.join(projectDir, "features", `${featureName}.feature`);
   const isFeatureFileExists = existsSync(featureFilePath);
   const scenarioContent = getScenarioContent(
     { scenario },
@@ -391,13 +394,13 @@ export async function updateFeatureFile({ featureName, scenario, override, proje
             plugins: ["prettier-plugin-gherkin"],
           });
         } catch (error) {
-          console.error("Error formatting feature file content with Prettier:", error);
+          logger.error("Error formatting feature file content with Prettier:", error);
         }
         writeFileSync(featureFilePath, updatedFeatureFileContent);
         return;
       }
     }
-    let updatedFeatureFileContent = featureFileContent + "\n" + scenarioContent;
+    let updatedFeatureFileContent = `${featureFileContent}\n${scenarioContent}`;
     try {
       updatedFeatureFileContent = await prettier.format(updatedFeatureFileContent, {
         ...prettierConfig,
@@ -405,7 +408,7 @@ export async function updateFeatureFile({ featureName, scenario, override, proje
         plugins: ["prettier-plugin-gherkin"],
       });
     } catch (error) {
-      console.error("Error formatting feature file content with Prettier:", error);
+      logger.error("Error formatting feature file content with Prettier:", error);
     }
     writeFileSync(featureFilePath, updatedFeatureFileContent);
   } else {
@@ -417,8 +420,22 @@ export async function updateFeatureFile({ featureName, scenario, override, proje
         plugins: ["prettier-plugin-gherkin"],
       });
     } catch (error) {
-      console.error("Error formatting feature file content with Prettier:", error);
+      logger.error("Error formatting feature file content with Prettier:", error);
     }
     writeFileSync(featureFilePath, featureFileContent);
   }
 }
+
+export {
+  containsScenario,
+  testStringForRegex,
+  escapeNonPrintables,
+  getCommandContent,
+  getExamplesContent,
+  getTagsContent,
+  getScenarioContent,
+  escapeString,
+  GherkinToObject,
+  updateExistingScenario,
+  updateFeatureFile,
+};

package/bin/client/utils/app_dir.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+import os from "node:os";
+function getAppDataDir(project_id) {
+    if (process.env.BLINQ_APPDATA_DIR) {
+        return path.join(process.env.BLINQ_APPDATA_DIR, "blinq.io", project_id);
+    }
+    let appDataDir;
+    switch (process.platform) {
+        case "win32":
+            appDataDir = path.join(process.env.APPDATA, "blinq.io", project_id);
+            break;
+        case "darwin":
+            appDataDir = path.join(os.homedir(), "Library", "Application Support", "blinq.io", project_id);
+            break;
+        default:
+            appDataDir = path.join(os.homedir(), ".config", "blinq.io", project_id);
+            break;
+    }
+    return appDataDir;
+}
+export { getAppDataDir };

package/bin/client/utils/socket_logger.js

@@ -1,132 +1,94 @@
-/**
- * @typedef {Object} SocketLoggerEventPayload
- * @property {string} level        Log level (e.g. "info", "warn", "error", "debug")
- * @property {string} context      Log context/subsystem (e.g. "BVTRecorder")
- * @property {*}      data         The log message payload (string, object, etc)
- * @property {string} timestamp    ISO string when the log was emitted
- * @property {number} dataSize     Size of data in bytes (-1 if unknown)
- */
-
-/**
- * @typedef {Object} SocketLoggerInitOptions
- * @property {string=} context     Default context for all logs (optional)
- * @property {string=} eventName   Default event name (default: "recorder.log")
- */
-
+function getErrorMessage(err) {
+    if (typeof err === "string") {
+        return err;
+    }
+    else if (err instanceof Error) {
+        return err.message;
+    }
+    else {
+        try {
+            return JSON.stringify(err);
+        }
+        catch {
+            return String(err);
+        }
+    }
+}
 /**
  * SocketLogger - Singleton for structured socket-based logging.
  *
- * @namespace SocketLogger
- * @property {function(import('socket.io-client').Socket|import('socket.io').Socket, SocketLoggerInitOptions=):void} init
- * @property {function(string, (string|*), Object=, string=, string=):void} log
- * @property {function((string|*), Object=):void} info
- * @property {function((string|*), Object=):void} warn
- * @property {function((string|*), Object=):void} debug
- * @property {function((string|*), Object=):void} error
- *
  * @example
- *   import logger from "./socket_logger.js";
- *   logger.init(socket, { context: "BVTRecorder" });
- *   logger.info("Step started", { step: 2 });
- *   logger.error("Failed!", { error: "bad stuff" });
+ *   import SocketLogger from "./socket_logger";
+ *   SocketLogger.getInstance().init(socket, { context: "BVTRecorder" });
+ *   SocketLogger.getInstance().info("Step started", { step: 2 });
+ *   SocketLogger.getInstance().error("Failed!", { error: "bad stuff" });
  */
-const SocketLogger = (function () {
-  /** @type {import('socket.io-client').Socket|import('socket.io').Socket|null} */
-  let socket = null;
-  /** @type {string} */
-  let defaultContext = "";
-  /** @type {string} */
-  let defaultEventName = "recorder.log";
-
-  /**
-   * Initialize the logger (call once).
-   * @param {import('socket.io-client').Socket|import('socket.io').Socket} sock
-   * @param {SocketLoggerInitOptions=} opts
-   */
-  function init(sock, opts) {
-    socket = sock;
-    defaultContext = (opts && opts.context) || "";
-    defaultEventName = (opts && opts.eventName) || "recorder.log";
-  }
-
-  /**
-   * Low-level log method (most users use info/warn/debug/error).
-   * @param {string} level         Log level ("info", "warn", "debug", "error")
-   * @param {string|*} message     The log message or object
-   * @param {Object=} extra        Extra fields (will be merged into log payload)
-   * @param {string=} eventName    Override event name for this log (default: "recorder.log")
-   * @param {string=} context      Override log context for this log (default: set in init)
-   */
-  function log(level, message, extra, eventName, context) {
-    if (!socket || typeof socket.emit !== "function") return;
-    /** @type {*} */
-    var data = typeof message === "object" ? message : { message: message };
-    /** @type {number} */
-    var dataSize = 0;
-    try {
-      dataSize = Buffer.byteLength(JSON.stringify(data || ""), "utf8");
-    } catch (e) {
-      dataSize = -1;
+export class SocketLogger {
+    static instance;
+    socket = null;
+    defaultContext = "BVTRecorder";
+    defaultEventName = "BVTRecorder.log";
+    constructor() { }
+    static getInstance() {
+        if (!SocketLogger.instance) {
+            SocketLogger.instance = new SocketLogger();
+        }
+        return SocketLogger.instance;
+    }
+    init(sock, opts) {
+        this.socket = sock;
+        this.defaultContext = opts?.context || "";
+        this.defaultEventName = opts?.eventName || "recorder.log";
+    }
+    log(level, message, extra, context) {
+        if (!this.socket || typeof this.socket.emit !== "function")
+            return;
+        const data = typeof message === "object" ? message : { message };
+        let dataSize = 0;
+        try {
+            dataSize = Buffer.byteLength(JSON.stringify(data || ""), "utf8");
+        }
+        catch {
+            dataSize = -1;
+        }
+        const eventPayload = {
+            level,
+            context: context || this.defaultContext,
+            data: JSON.stringify({
+                ...data,
+                errorMessage: level === "error" && data ? getErrorMessage(data) : undefined,
+            }),
+            timestamp: new Date().toISOString(),
+            dataSize,
+            ...extra,
+        };
+        try {
+            if (this.socket) {
+                this.socket.emit(this.defaultEventName, eventPayload);
+            }
+            console.log(`${context ?? this.defaultContext} [${level.toUpperCase()}]:`, {
+                ...data,
+                ...extra,
+            });
+        }
+        catch (e) {
+            console.error("Socket logging error:", e);
+            console.log("Socket event payload:", eventPayload);
+        }
+    }
+    info(msg, ext, ctx) {
+        this.log("info", msg, ext, ctx);
+    }
+    warn(msg, ext, ctx) {
+        this.log("warn", msg, ext, ctx);
+    }
+    debug(msg, ext, ctx) {
+        this.log("debug", msg, ext, ctx);
     }
-    /** @type {SocketLoggerEventPayload} */
-    var eventPayload = Object.assign(
-      {
-        level: level,
-        context: context || defaultContext,
-        data: JSON.stringify(data),
-        timestamp: new Date().toISOString(),
-        dataSize: dataSize,
-      },
-      extra || {}
-    );
-    // @ts-ignore
-    try {
-      if (socket) {
-        socket.emit(eventName || defaultEventName, eventPayload);
-      }
-    } catch (e) {
-      console.error("Socket logging error:", e);
-      console.log("Socket event payload:", eventPayload);
+    error(msg, ext, ctx) {
+        this.log("error", msg, ext, ctx);
     }
-  }
-
-  /**
-   * Write an info-level log event.
-   * @param {string|*} msg      The message or object
-   * @param {Object=} ext       Any extra fields/metadata
-   */
-  function info(msg, ext) {
-    log("info", msg, ext);
-  }
-
-  /**
-   * Write a warn-level log event.
-   * @param {string|*} msg      The message or object
-   * @param {Object=} ext       Any extra fields/metadata
-   */
-  function warn(msg, ext) {
-    log("warn", msg, ext);
-  }
-
-  /**
-   * Write a debug-level log event.
-   * @param {string|*} msg      The message or object
-   * @param {Object=} ext       Any extra fields/metadata
-   */
-  function debug(msg, ext) {
-    log("debug", msg, ext);
-  }
-
-  /**
-   * Write an error-level log event.
-   * @param {string|*} msg      The message or object
-   * @param {Object=} ext       Any extra fields/metadata
-   */
-  function error(msg, ext) {
-    log("error", msg, ext);
-  }
-
-  return { init, log, info, warn, debug, error };
-})();
-
-export default SocketLogger;
+}
+const socketLoggerInstance = SocketLogger.getInstance();
+export default socketLoggerInstance;
+export { getErrorMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1437-stage",
+  "version": "1.0.1438-stage",
   "description": " ",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",
@@ -14,6 +14,8 @@
     "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",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest watch",
     "clean_old": "rimraf -g build1 && rimraf -g types1",
     "clean": "rimraf -g build && rimraf -g types",
     "build_old": "npm run clean_old && npm run pack_old",
@@ -77,6 +79,8 @@
     "readline-sync": "^1.4.10",
     "ts-node": "^10.9.2",
     "tsup": "^8.5.0",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.2",
+    "vite-tsconfig-paths": "^6.0.4",
+    "vitest": "^2.1.4"
   }
 }