testdriverai 5.3.7 → 5.3.9

package/README.md

@@ -153,4 +153,5 @@ gh pr create --web
 ```
 
 Your test will run on every commit and the results will be posted as a Dashcam.io video within your GitHub summary! Learn more about deploying on CI [here](https://docs.testdriver.ai/continuous-integration/overview).
+
 # vscode

package/agent.js

@@ -353,8 +353,6 @@ const check = async () => {
 const runCommand = async (command, depth) => {
   let yml = await yaml.dump(command);
 
-  await save({});
-
   logger.debug(`running command: \n\n${yml}`);
 
   try {
@@ -600,8 +598,6 @@ const exploratoryLoop = async (
     logger.debug("showing prompt from exploratoryLoop response check");
   }
 
-  await save({ silent: false });
-
   return;
 };
 
@@ -996,11 +992,6 @@ let summarize = async (error = null) => {
 let save = async ({ filepath = thisFile, silent = false } = {}) => {
   analytics.track("save", { silent });
 
-  if (!silent) {
-    logger.info(chalk.dim(`saving as ${filepath}...`), true);
-    logger.info("");
-  }
-
   if (!executionHistory.length) {
     return;
   }
@@ -1026,7 +1017,7 @@ ${regression}
 
     const fileName = filepath.split("/").pop();
     if (!silent) {
-      logger.info(chalk.dim(`saved as ${fileName}`));
+      logger.info(chalk.dim(`saved as ${filepath}`));
     }
   }
 
@@ -1114,10 +1105,14 @@ ${yaml.dump(step)}
 
     lastPrompt = step.prompt;
     await actOnMarkdown(markdown, 0, true);
+
+    if (shouldSave) {
+      await save({ silent: true });
+    }
   }
 
   if (shouldSave) {
-    await save({ filepath: file });
+    await save({ filepath: file, silent: false });
   }
 
   setTerminalWindowTransparency(false);
@@ -1280,6 +1275,7 @@ const makeSandbox = async () => {
       await new Promise((resolve) => setTimeout(resolve, 3000));
       logger.info(chalk.green(``));
       logger.info(chalk.green(`sandbox runner ready!`));
+      logger.info(chalk.green(``));
     } catch (e) {
       logger.error(e);
       logger.error(chalk.red(`sandbox runner failed to start`));

package/docs/commands/if.mdx

@@ -42,3 +42,4 @@ else:
 - The `if` command is useful for creating conditional logic in your tests, allowing for more dynamic and flexible workflows.
 - Both the `then` and `else` blocks are optional, but at least one must be provided.
 ```
+

package/docs/getting-started/vscode.mdx

@@ -5,7 +5,17 @@ description: "Comprehensive guide to installing and setting up TestDriver.ai for
 icon: "file-code"
 ---
 
-[Download VSCode Extension](https://github.com/testdriverai/vscode/actions/runs/14458583961)
+# Download the VSCode Extension
+
+The TestDriver.ai VSCode extension is available for download on our GitHub releases page. This extension integrates seamlessly with Visual Studio Code, allowing you to leverage the power of TestDriver.ai directly within your development environment.
+
+<Card
+  title="Download the VSCode Extension"
+  icon="download"
+  href="https://github.com/testdriverai/vscode/releases"
+>
+  Get the latest version of the TestDriver.ai VSCode extension from our GitHub releases page. 
+</Card>
 
 # Install the extension
 
@@ -18,7 +28,7 @@ icon: "file-code"
 
 # Try the Walkthrough
 
-The extension should launch a walkthrough. If it does not, you can manually start it by running the command `TestDriver: Start Walkthrough` from the Command Palette (`Ctrl+Shift+P`).
+The extension should launch a walkthrough. If it does not, you can manually start it by running the command `TestDriver: Start Setup Walkthrough` from the Command Palette (`Ctrl+Shift+P`).
 
 ![](/images/content/vscode-walkthrough.png)
 

package/electron/overlay.js

@@ -1,8 +1,15 @@
 const { default: nodeIPC } = require("node-ipc");
-const { app: electronApp, remote, screen, BrowserWindow, Tray, Menu } = require("electron");
+const {
+  app: electronApp,
+  remote,
+  screen,
+  BrowserWindow,
+  Tray,
+  Menu,
+} = require("electron");
 const { eventsArray } = require("../lib/events.js");
 const config = require("../lib/config.js");
-const path = require('path');
+const path = require("path");
 
 let tray = null;
 
@@ -22,22 +29,21 @@ ipc.config.retry = 0;
 ipc.config.silent = true;
 
 app.whenReady().then(() => {
-
   // Path to tray icon (must be .ico on Windows, .png on Mac/Linux)
-  const iconPath = path.join(__dirname, 'tray.png');
+  const iconPath = path.join(__dirname, "tray.png");
 
   tray = new Tray(iconPath);
 
   const contextMenu = Menu.buildFromTemplate([
     {
-      label: 'Quit',
+      label: "Quit",
       click: () => {
         app.quit();
       },
     },
   ]);
 
-  tray.setToolTip('TestDriver.ai');
+  tray.setToolTip("TestDriver.ai");
   tray.setContextMenu(contextMenu);
 
   app.dock?.hide();
@@ -92,8 +98,11 @@ app.whenReady().then(() => {
       visibleOnFullScreen: true,
     });
   } else {
-    window.setContentSize(config.TD_VM_RESOLUTION[0], config.TD_VM_RESOLUTION[1]);
-    window.setBackgroundColor('#000')
+    window.setContentSize(
+      config.TD_VM_RESOLUTION[0],
+      config.TD_VM_RESOLUTION[1],
+    );
+    window.setBackgroundColor("#000");
   }
 
   window.loadFile("overlay.html");

package/lib/commands.js

@@ -1,6 +1,6 @@
 // the actual commands to interact with the system
 const sdk = require("./sdk");
-const vm = require('vm');
+const vm = require("vm");
 const chalk = require("chalk");
 const server = require("./ipc").server;
 const {
@@ -21,8 +21,8 @@ const cliProgress = require("cli-progress");
 const redraw = require("./redraw");
 const sandbox = require("./sandbox.js");
 const config = require("./config.js");
-const util = require('util');
-const exec = util.promisify(require('child_process').exec);
+const util = require("util");
+const exec = util.promisify(require("child_process").exec);
 let robot;
 
 let keymap;
@@ -191,26 +191,38 @@ const scroll = async (direction = "down", amount = 300, method = "mouse") => {
   switch (direction) {
     case "up":
       if (method === "mouse") {
-        config.TD_VM ? await sandbox.send({type: "scroll", amount }) : await robot.scrollMouse(0, amount );
+        config.TD_VM
+          ? await sandbox.send({ type: "scroll", amount })
+          : await robot.scrollMouse(0, amount);
       } else {
-        config.TD_VM ? await sandbox.send({type: "press", keys: ["pageup"]}) : await robot.keyTap("pageup");
+        config.TD_VM
+          ? await sandbox.send({ type: "press", keys: ["pageup"] })
+          : await robot.keyTap("pageup");
       }
       await redraw.wait(2500);
       break;
     case "down":
       if (method === "mouse") {
-        config.TD_VM ? await sandbox.send({type: "scroll", amount: amount * -1}) : await robot.scrollMouse(0, amount * -1);
+        config.TD_VM
+          ? await sandbox.send({ type: "scroll", amount: amount * -1 })
+          : await robot.scrollMouse(0, amount * -1);
       } else {
-        config.TD_VM ? await sandbox.send({type: "press", keys: ["pagedown"] }) : await robot.keyTap("pagedown"); 
+        config.TD_VM
+          ? await sandbox.send({ type: "press", keys: ["pagedown"] })
+          : await robot.keyTap("pagedown");
       }
       await redraw.wait(2500);
       break;
     case "left":
-      config.TD_VM ? console.log('Not Supported') : await robot.scrollMouse(amount * -1, 0);
+      config.TD_VM
+        ? console.log("Not Supported")
+        : await robot.scrollMouse(amount * -1, 0);
       await redraw.wait(2500);
       break;
     case "right":
-      config.TD_VM ? console.log('Not Supported') : await robot.scrollMouse(amount, 0);
+      config.TD_VM
+        ? console.log("Not Supported")
+        : await robot.scrollMouse(amount, 0);
       await redraw.wait(2500);
       break;
     default:
@@ -223,65 +235,67 @@ const scroll = async (direction = "down", amount = 300, method = "mouse") => {
 const click = async (x, y, action = "click") => {
   await redraw.start();
 
-  let button = 'left';
+  let button = "left";
   let double = false;
 
-  if (action === "right-click" && platform !== "darwin" ) {
+  if (action === "right-click" && platform !== "darwin") {
     button = "right";
   }
   if (action === "double-click") {
     double = true;
   }
 
-  logger.debug(chalk.dim(`${action} ${button} clicking at ${x}, ${y}...`), true);
+  logger.debug(
+    chalk.dim(`${action} ${button} clicking at ${x}, ${y}...`),
+    true,
+  );
 
   x = parseInt(x);
   y = parseInt(y);
 
-  config.TD_VM ? await sandbox.send({type: "moveMouse", x, y }) : await robot.moveMouseSmooth(x, y, 0.1);
+  config.TD_VM
+    ? await sandbox.send({ type: "moveMouse", x, y })
+    : await robot.moveMouseSmooth(x, y, 0.1);
   emitter.emit(events.mouseMove, { x, y });
 
   await delay(1000); // wait for the mouse to move
 
-  if (!config.TD_VM && platform()== "darwin" && action === "right-click") {
-    robot.keyToggle('control', 'down', 'control');
+  if (!config.TD_VM && platform() == "darwin" && action === "right-click") {
+    robot.keyToggle("control", "down", "control");
     await delay(250);
   }
 
   if (action !== "hover") {
     if (config.TD_VM) {
       if (action === "click" || action === "left-click") {
-        await sandbox.send({type: "leftClick" })
+        await sandbox.send({ type: "leftClick" });
       } else if (action === "right-click") {
-        await sandbox.send({type: "rightClick" })
+        await sandbox.send({ type: "rightClick" });
       } else if (action === "middle-click") {
-        await sandbox.send({type: "middleClick" })
+        await sandbox.send({ type: "middleClick" });
       } else if (action === "double-click") {
-        await sandbox.send({type: "doubleClick" })
-      }else if (action === "drag-start") {
-        await sandbox.send({type: "mousePress", button: "left" })
-      }else if (action === "drag-end") {
-        await sandbox.send({type: "mouseRelease", button: "left" })
+        await sandbox.send({ type: "doubleClick" });
+      } else if (action === "drag-start") {
+        await sandbox.send({ type: "mousePress", button: "left" });
+      } else if (action === "drag-end") {
+        await sandbox.send({ type: "mouseRelease", button: "left" });
       }
     } else {
-
       if (action === "drag-start") {
         robot.mouseToggle("down", button);
-      } else if( action === "drag-end") {
+      } else if (action === "drag-end") {
         robot.mouseToggle("up", button);
       } else {
         robot.mouseClick(button, double);
       }
-
     }
 
     emitter.emit(events.mouseClick, { x, y, button, click });
-
   }
 
-  if (!config.TD_VM && platform()== "darwin" && action === "right-click") {
+  if (!config.TD_VM && platform() == "darwin" && action === "right-click") {
     await delay(250);
-    robot.keyToggle('control', 'up', 'control');
+    robot.keyToggle("control", "up", "control");
   }
 
   await redraw.wait(5000);
@@ -294,7 +308,7 @@ const hover = async (x, y) => {
   x = parseInt(x);
   y = parseInt(y);
 
-  await sandbox.send({type: "moveMouse", x, y });
+  await sandbox.send({ type: "moveMouse", x, y });
 
   await redraw.wait(2500);
 
@@ -350,10 +364,7 @@ let commands = {
     }
   },
   // uses our api to find all images on screen
-  "hover-image": async (
-    description,
-    action = "click",
-  ) => {
+  "hover-image": async (description, action = "click") => {
     // take a screenshot
     logger.info("");
     logger.info(chalk.dim("thinking..."), true);
@@ -384,10 +395,7 @@ let commands = {
       return response.data;
     }
   },
-  "match-image": async (
-    relativePath,
-    action = "click"
-  ) => {
+  "match-image": async (relativePath, action = "click") => {
     let image = await captureScreenPNG();
 
     let result = await findImageOnScreen(relativePath, image);
@@ -405,20 +413,18 @@ let commands = {
   // type a string
   type: async (string, delay = 500) => {
     await redraw.start();
-    
+
     string = string.toString();
 
     if (config.TD_VM) {
-      await sandbox.send({type: "write", text: string });
+      await sandbox.send({ type: "write", text: string });
     } else {
-
-    // there is a bug in robotjs that causes repeated characters to only be typed once
-    // so we need to check for repeated characters and type them slowly if so
-    const hasRepeatedChars = /(.)\1/.test(string);
-    if (delay > 0 && hasRepeatedChars)
-      await robot.typeStringDelayed(string, delay);
-    else
-      await robot.typeString(string);
+      // there is a bug in robotjs that causes repeated characters to only be typed once
+      // so we need to check for repeated characters and type them slowly if so
+      const hasRepeatedChars = /(.)\1/.test(string);
+      if (delay > 0 && hasRepeatedChars)
+        await robot.typeStringDelayed(string, delay);
+      else await robot.typeString(string);
     }
     // await redraw.wait(5000);
     return;
@@ -439,7 +445,7 @@ let commands = {
     // remove any modifier keys from the inputKeys array and put them in a new array
     inputKeys.forEach((key) => {
       // change command to control on windows
-      if (key === "command" && platform()== "win32") {
+      if (key === "command" && platform() == "win32") {
         key = "control";
       }
 
@@ -467,7 +473,7 @@ let commands = {
 
     // make sure modifier keys are valid, multiple are allowed
     let modsToPress = [];
-    
+
     if (!config.TD_VM) {
       modifierKeysPressed.map((key) => {
         if (keymap[key] === undefined) {
@@ -476,10 +482,10 @@ let commands = {
         } else {
           return keymap[key];
         }
-      }); 
+      });
       robot.keyTap(keysPressed[0], modsToPress);
     } else {
-      await sandbox.send({type: "press", keys: keysPressed });
+      await sandbox.send({ type: "press", keys: keysPressed });
     }
 
     // finally, press the keys
@@ -514,8 +520,11 @@ let commands = {
     let passed = false;
 
     while (durationPassed < timeout && !passed) {
-
-      passed = await assert(`An image matching the description "${description}" appears on screen.`, false, false);
+      passed = await assert(
+        `An image matching the description "${description}" appears on screen.`,
+        false,
+        false,
+      );
 
       durationPassed = new Date().getTime() - startTime;
       if (!passed) {
@@ -525,6 +534,7 @@ let commands = {
           ),
           true,
         );
+        await delay(2500);
       }
     }
 
@@ -568,14 +578,14 @@ let commands = {
 
       passed = response.data;
       durationPassed = new Date().getTime() - startTime;
-      if (!passed && durationPassed > timeout) {
+      if (!passed) {
         logger.info(
           chalk.dim(
             `${niceSeconds(durationPassed)} seconds have passed without finding "${text}"`,
           ),
           true,
         );
-        await redraw.wait(5000);
+        await delay(2500);
       }
     }
 
@@ -594,7 +604,7 @@ let commands = {
     direction = "down",
     maxDistance = 1200,
     textMatchMethod = "turbo",
-    method = "keyboard"
+    method = "keyboard",
   ) => {
     await redraw.start();
 
@@ -602,18 +612,16 @@ let commands = {
 
     if (method === "keyboard") {
       try {
-
         if (!config.TD_VM) {
-          await robot.keyTap("f", commandOrControl);;
+          await robot.keyTap("f", commandOrControl);
           robot.keyToggle(commandOrControl, "up");
           await robot.typeStringDelayed(text, 500);
         } else {
-          await sandbox.send({type: "press", keys: ["f", commandOrControl] })
-          await sandbox.send({type: "write", text });
+          await sandbox.send({ type: "press", keys: ["f", commandOrControl] });
+          await sandbox.send({ type: "write", text });
           await redraw.wait(5000);
-          await sandbox.send({type: "press", keys: ["escape"] });
+          await sandbox.send({ type: "press", keys: ["escape"] });
         }
-
       } catch (e) {
         logger.error("%s", e);
         throw new AiError(
@@ -684,8 +692,11 @@ let commands = {
     let passed = false;
 
     while (scrollDistance <= maxDistance && !passed) {
-
-      passed = await assert(`An image matching the description "${description}" appears on screen.`, false, false);
+      passed = await assert(
+        `An image matching the description "${description}" appears on screen.`,
+        false,
+        false,
+      );
 
       if (!passed) {
         logger.info(
@@ -724,90 +735,99 @@ let commands = {
     return await assert(assertion, true, async);
   },
   exec: async (language, mac_code, windows_code, linux_code) => {
-
-    logger.info(chalk.dim(`calling exec...`), true,);
+    logger.info(chalk.dim(`calling exec...`), true);
 
     let plat = platform();
-    
-    const scriptCode = plat == "linux" ? linux_code : plat == "windows" ? windows_code : plat == "mac" ? mac_code : (() => { throw new AiError(`Unsupported plat: ${plat}`); })();
+
+    const scriptCode =
+      plat == "linux"
+        ? linux_code
+        : plat == "windows"
+          ? windows_code
+          : plat == "mac"
+            ? mac_code
+            : (() => {
+                throw new AiError(`Unsupported plat: ${plat}`);
+              })();
 
     if (!scriptCode) {
       logger.warn(`No code provided for ${plat}`);
       return;
     }
 
-    if (language == 'shell') {
-
-      logger.info(chalk.dim(`running in shell...`), true,);
+    if (language == "shell") {
+      logger.info(chalk.dim(`running in shell...`), true);
 
       if (plat == "linux") {
-
         if (config.TD_VM) {
-
-          logger.info(chalk.dim(`sending value of \`linux\` to vm...`), true,);
+          logger.info(chalk.dim(`sending value of \`linux\` to vm...`), true);
 
           return await sandbox.send({
             type: "commands.run",
             command: linux_code,
           });
-          
         } else {
-
           if (!linux_code) {
             throw new AiError(`No code provided for linux`, true);
           }
 
-          logger.info(chalk.dim(`running value of \`${plat}\` on this machine...`), true);
+          logger.info(
+            chalk.dim(`running value of \`${plat}\` on this machine...`),
+            true,
+          );
           return await exec(mac_code, { cwd: cwd() });
         }
       } else if (plat == "windows") {
-        logger.info(chalk.dim(`running value of \`${plat}\` on this machine...`), true);
+        logger.info(
+          chalk.dim(`running value of \`${plat}\` on this machine...`),
+          true,
+        );
         return await exec(windows_code, { cwd: cwd() });
       } else if (plat == "mac") {
-        logger.info(chalk.dim(`running value of \`${plat}\` on this machine...`), true);
+        logger.info(
+          chalk.dim(`running value of \`${plat}\` on this machine...`),
+          true,
+        );
         return await exec(mac_code, { cwd: cwd() });
-        
       }
+    } else if (language == "js") {
+      logger.info(chalk.dim(`running js...`), true);
 
-    } else if (language == 'js') {
-
-      logger.info(chalk.dim(`running js...`), true,);
-  
       // must be assigned to `result`
       // do not overwrite `result`
       // must install locally via npm install
 
-      if (config.TD_VM) {
-        logger.info(chalk.dim(`running value of \`linux\` on vm...`), true);
-        return await sandbox.send({
-          type: "js.run",
-          js: linux_code,
-        });
-      } else {
-
-        logger.info(chalk.dim(`running value of \`${plat}\` in local JS vm...`), true);
+      // if (config.TD_VM) {
+      //   logger.info(chalk.dim(`running value of \`linux\` on vm...`), true);
+      //   return await sandbox.send({
+      //     type: "js.run",
+      //     js: linux_code,
+      //   });
+      // } else {
+      logger.info(
+        chalk.dim(`running value of \`${plat}\` in local JS vm...`),
+        true,
+      );
 
-        const context = vm.createContext({ require, console, fs, process });
+      const context = vm.createContext({ require, console, fs, process });
 
-        const script = new vm.Script(`
+      const script = new vm.Script(`
           (async () => {
             ${scriptCode}
           })();
         `);
 
-        await script.runInContext(context);
-
-        // wait for context.result to resolve
-        const stepResult = await context.result;
+      await script.runInContext(context);
 
-        return stepResult;
-      }
+      // wait for context.result to resolve
+      const stepResult = await context.result;
 
+      return stepResult;
+      // }
     } else {
       throw new AiError(`Language not supported: ${language}`);
     }
-    
-  }
+  },
 };
 
 module.exports = { commands, assert };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testdriverai",
-  "version": "5.3.7",
+  "version": "5.3.9",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "index.js",
   "bin": {