testdriverai 4.2.19 → 5.0.0-beta-8

package/lib/commands.js

@@ -7,7 +7,7 @@ const {
   platform,
   activeWin,
 } = require("./system");
-const keymap = require("./keymap");
+
 const { focusApplication } = require("./focus-application");
 const fs = require("fs").promises; // Using the promises version for async operations
 const robot = require("robotjs");
@@ -18,6 +18,16 @@ const Jimp = require("jimp");
 const os = require("os");
 const cliProgress = require("cli-progress");
 const redraw = require("./redraw");
+const sandbox = require("./sandbox.js");
+const config = require("./config.js");
+
+let keymap;
+if (config.TD_VM) {
+  keymap = require("./keymaps/sandbox.js");
+} else {
+  keymap = require("./keymaps/robot.js");
+}
+
 const {
   logger,
   prettyMarkdown,
@@ -177,26 +187,26 @@ const scroll = async (direction = "down", amount = 300, method = "mouse") => {
   switch (direction) {
     case "up":
       if (method === "mouse") {
-        await robot.scrollMouse(0, amount );
+        config.TD_VM ? await sandbox.send({type: "scroll", amount }) : await robot.scrollMouse(0, amount );
       } else {
-        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") {
-        await robot.scrollMouse(0, amount * -1);
+        config.TD_VM ? await sandbox.send({type: "scroll", amount: amount * -1}) : await robot.scrollMouse(0, amount * -1);
       } else {
-        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":
-      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":
-      await robot.scrollMouse(amount, 0);
+      config.TD_VM ? console.log('Not Supported') : await robot.scrollMouse(amount, 0);
       await redraw.wait(2500);
       break;
     default:
@@ -224,21 +234,32 @@ const click = async (x, y, action = "click") => {
   x = parseInt(x);
   y = parseInt(y);
 
-  robot.moveMouseSmooth(x, y, 0.1);
-  
+  config.TD_VM ? await sandbox.send({type: "moveMouse", x, y }) : await robot.moveMouseSmooth(x, y, 0.1);
   await delay(1000); // wait for the mouse to move
 
-  if (process.platform === "darwin" && action === "right-click") {
+  if (!config.TD_VM && process.platform === "darwin" && action === "right-click") {
     robot.keyToggle('control', 'down', 'control');
     await delay(250);
   }
 
   if (action !== "hover") {
-    robot.mouseClick(button, double);
+    if (config.TD_VM) {
+      if (action === "click" || action === "left-click") {
+        await sandbox.send({type: "leftClick" })
+      } else if (action === "right-click") {
+        await sandbox.send({type: "rightClick" })
+      } else if (action === "middle-click") {
+        await sandbox.send({type: "middleClick" })
+      } else if (action === "double-click") {
+        await sandbox.send({type: "doubleClick" })
+      }
+    } else {
+      robot.mouseClick(button, double);
+    }
     emitter.emit(events.mouseClick, { x, y, button, click });
   }
 
-  if (process.platform === "darwin" && action === "right-click") {
+  if (!config.TD_VM && process.platform === "darwin" && action === "right-click") {
     await delay(250);
     robot.keyToggle('control', 'up', 'control');
   }
@@ -253,7 +274,7 @@ const hover = async (x, y) => {
   x = parseInt(x);
   y = parseInt(y);
 
-  await robot.moveMouseSmooth(x, y, 0.1);
+  await sandbox.send({type: "moveMouse", x, y });
 
   await redraw.wait(2500);
 
@@ -364,7 +385,13 @@ 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 });
+    } 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);
@@ -372,7 +399,8 @@ let commands = {
       await robot.typeStringDelayed(string, delay);
     else
       await robot.typeString(string);
-    await redraw.wait(5000);
+    }
+    // await redraw.wait(5000);
     return;
   },
   // press keys
@@ -395,7 +423,7 @@ let commands = {
         key = "control";
       }
 
-      if (modifierKeys.includes(key)) {
+      if (!config.TD_VM && modifierKeys.includes(key)) {
         modifierKeysPressed.push(key);
       } else {
         keysPressed.push(key);
@@ -411,32 +439,40 @@ let commands = {
     });
 
     // only one key can be pressed at a time
-    if (keysPressed.length > 1) {
+    if (!config.TD_VM && keysPressed.length > 1) {
       throw new AiError(
         "Only one key can be pressed at a time. However, multiple modifier keys can be pressed at the same time.",
       );
     }
 
     // make sure modifier keys are valid, multiple are allowed
-    let modsToPress = modifierKeysPressed.map((key) => {
-      if (keymap[key] === undefined) {
-        logger.error(`Modifier key not found: ${key}`);
-        throw new AiError(`Modifier key not found: ${key}`);
-      } else {
-        return keymap[key];
-      }
-    });
+    let modsToPress = [];
+    
+    if (!config.TD_VM) {
+      modifierKeysPressed.map((key) => {
+        if (keymap[key] === undefined) {
+          logger.error(`Modifier key not found: ${key}`);
+          throw new AiError(`Modifier key not found: ${key}`);
+        } else {
+          return keymap[key];
+        }
+      }); 
+      robot.keyTap(keysPressed[0], modsToPress);
+    } else {
+      await sandbox.send({type: "press", keys: keysPressed });
+    }
 
     // finally, press the keys
-    robot.keyTap(keysPressed[0], modsToPress);
 
     await redraw.wait(5000);
 
     // keyTap will release the normal keys, but will not release modifier keys
     // so we need to release the modifier keys manually
-    modsToPress.forEach((key) => {
-      robot.keyToggle(key, "up");
-    });
+    if (!config.TD_VM) {
+      modsToPress.forEach((key) => {
+        robot.keyToggle(key, "up");
+      });
+    }
 
     return;
   },
@@ -546,15 +582,18 @@ let commands = {
 
     if (method === "keyboard") {
       try {
-        // use robot to press CMD+F
-        await robot.keyTap("f", commandOrControl);
-        // keyTap will release the normal keys, but will not release modifier keys
-        // so we need to release the modifier keys manually
-        robot.keyToggle(commandOrControl, "up");
-        // type the text
-        await robot.typeStringDelayed(text, 500);
-        await redraw.wait(5000);
-        await robot.keyTap("escape");
+
+        if (!config.TD_VM) {
+          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 redraw.wait(5000);
+          await sandbox.send({type: "press", keys: ["escape"] });
+        }
+
       } catch (e) {
         logger.error("%s", e);
         throw new AiError(
@@ -666,23 +705,28 @@ let commands = {
   },
   exec: async (cli_command, use_stderr = false, silent = false) => {
 
-    let args = {};
-    if (silent) {
-      args = { stdio: [] };
-    }
+    if (config.TD_VM) {
+      return await sandbox.send({type: "commands.run", commands: cli_command });
+    } else {
 
-    const { stdout, stderr } = await exec(cli_command, args);
+      let args = {};
+      if (silent) {
+        args = { stdio: [] };
+      }
 
-    if (!silent) {
-      logger.info(chalk.dim(stdout), true);
-    }
+      const { stdout, stderr } = await exec(cli_command, args);
 
-    if (use_stderr) {
-      return stderr;
-    } else {
-      return stdout;
-    }
+      if (!silent) {
+        logger.info(chalk.dim(stdout), true);
+      }
 
+      if (use_stderr) {
+        return stderr;
+      } else {
+        return stdout;
+      }
+
+    }
   }
 };
 

package/lib/config.js

@@ -26,10 +26,12 @@ const config = {
   TD_ANALYTICS: true,
   TD_NOTIFY: false,
   TD_MINIMIZE: true,
-  TD_API_ROOT: "https://api.testdriver.ai",
+  TD_API_ROOT: "https://replayable-api-production.herokuapp.com",
+  TD_API_KEY: null,
   TD_DEV: parseValue(process.env["DEV"]),
   TD_PROFILE: false,
-  TD_OVERLAY: true
+  TD_OVERLAY: true,
+  TD_VM: true
 };
 
 // Find all env vars starting with TD_

package/lib/events.js

@@ -3,6 +3,7 @@ const { EventEmitter } = require("events");
 const emitter = new EventEmitter();
 
 const events = {
+  showWindow: "show-window",
   mouseClick: "mouse-click",
   screenCapture: {
     start: "screen-capture:start",
@@ -17,6 +18,9 @@ const events = {
   matches: {
     show: "matches:show",
   },
+  vm: {
+    show: "vm:show",
+  }
 };
 
 const getValues = (obj) => {

package/lib/focus-application.js

@@ -5,6 +5,22 @@ const { platform } = require("./system");
 const scriptPath = path.join(__dirname, "focusWindow.ps1");
 const robot = require("robotjs");
 const { logger } = require("./logger");
+const sandbox = require("./sandbox");
+
+async function focusVSCode() {
+
+  try {
+    
+    if (platform() == "mac") {
+      return await execSync('open -a "Visual Studio Code"');
+    } else {
+      return await execSync('"C:\\Program Files\\Microsoft VS Code\\Code.exe"');
+    }
+  } catch (error) {
+    logger.error(error);
+  }
+
+}
 
 // apple script that focuses on a window
 const appleScriptSetFrontmost = (windowName) => `

package/lib/generator.js

@@ -64,6 +64,21 @@ const dumpToYML = async function (inputArray) {
 
   return yml;
 };
+const rawToFormatted = async function (inputCommands) {
+  // inputCommands is raw yml
+
+  let json = await yaml.load(inputCommands);
+  // use yml dump to convert json to yml
+  let yml = await yaml.dump({
+    version: package.version,
+    session: session.get(),
+    steps: [
+      {commands: json.commands},
+    ],
+  });
+
+  return yml;
+};
 
 const hydrateFromYML = async function (yml) {
   // use yml load to convert yml to json
@@ -79,4 +94,5 @@ module.exports = {
   dumpToYML,
   hydrateFromYML,
   jsonToManual,
+  rawToFormatted
 };

package/lib/init.js

@@ -8,6 +8,12 @@ const chalk = require("chalk");
 const { Readable } = require("stream");
 const { logger } = require("./logger");
 
+const validateUUID = (uuid) => {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(uuid);
+};
+
+
 async function getLatestRelease(owner, repo) {
   try {
     const response = await fetch(
@@ -69,26 +75,32 @@ module.exports = async () => {
   logger.info("");
 
   const response = await prompts([
-    // {
-    //   type: 'password',
-    //   name: 'DASHCAM_API_KEY',
-    //   message: 'API KEY (from https://app.dashcam.io/team)',
-    //   // validate: value => (validate(value) ? true : 'Invalid API Key')
-    // },
     {
       type: "confirm",
-      name: "TD_NOTIFY",
-      message: "Enable desktop notifications?",
+      name: "TD_VM",
+      message: "Use Testdriver Runners? (Recommended)",
       initial: true,
     },
     {
-      type: "confirm",
+      type: prev => (prev ? "password" : null),
+      name: 'TD_API_KEY',
+      message: 'API KEY (from https://app.testdriver.ai/team)',
+      validate: value => (validateUUID(value) ? true : 'Invalid API Key')
+    },
+    {
+      type: prev => (prev ? null : "confirm"),
       name: "TD_MINIMIZE",
       message: "Minimize terminal app?",
       initial: true,
     },
     {
-      type: "confirm",
+      type: prev => (prev ? null : "confirm"),
+      name: "TD_NOTIFY",
+      message: "Enable desktop notifications?",
+      initial: true,
+    },
+    {
+      type: prev => (prev ? null : "confirm"),
       name: "TD_SPEAK",
       message: "Enable text to speech narration?",
       initial: true,
@@ -98,26 +110,19 @@ module.exports = async () => {
       name: "TD_ANALYTICS",
       message: "Send anonymous analytics?",
       initial: true,
-    },
-    {
-      type: "text",
-      name: "APPEND",
-      message: "Where should we append these values?",
-      initial: ".env",
-    },
+    }
   ]);
 
   logger.info("");
-  logger.info(chalk.dim(`Writing ${response.APPEND}...`));
+  logger.info(chalk.dim(`Writing .env...`));
   logger.info("");
   logger.info(`Downloading latest workflow files...`);
   logger.info("");
 
   const env = Object.entries(response)
-    .filter(([key]) => key !== "APPEND")
     .map(([key, value]) => `${key}=${value}`)
     .join("\n");
-  const append = path.join(process.cwd(), response.APPEND);
+  const append = path.join(process.cwd(), '.env');
 
   if (!fs.existsSync(append)) {
     await fs.writeFileSync(append, "");
@@ -153,11 +158,44 @@ module.exports = async () => {
     if (!fs.existsSync(testdriverGenerateFolder)) {
       fs.mkdirSync(testdriverGenerateFolder);
     }
+
+    const tdScreen = path.join(
+      process.cwd(),
+      "testdriver",
+      "screenshots"
+    );
+    if (!fs.existsSync(tdScreen)) {
+      fs.mkdirSync(tdScreen);
+    }
+    const tdScreenMac = path.join(
+      process.cwd(),
+      "testdriver",
+      "screenshots", "mac"
+    );
+    if (!fs.existsSync(tdScreenMac)) {
+      fs.mkdirSync(tdScreenMac);
+    }
+    const tdScreenWindows = path.join(
+      process.cwd(),
+      "testdriver",
+      "screenshots", "windows"
+    );
+    if (!fs.existsSync(tdScreenWindows)) {
+      fs.mkdirSync(tdScreenWindows);
+    }
+    const tdScreenLinux = path.join(
+      process.cwd(),
+      "testdriver",
+      "screenshots", "linux"
+    );
+    if (!fs.existsSync(tdScreenLinux)) {
+      fs.mkdirSync(tdScreenLinux);
+    }
   }
 
   logger.info("");
   logger.info(chalk.green("Testdriver setup complete!"));
   logger.info("");
   logger.info(chalk.yellow("Create a new test by running:"));
-  logger.info("testdriverai testdriver/test.yml");
+  logger.info("testdriverai testdriver/test.yaml");
 };

package/lib/keymaps/sandbox.js

@@ -0,0 +1,124 @@
+// the ai somtimes hallucinates keys
+// so this allows us to map common hallucinations to the correct key
+// doesn't seem like we're making use of this yet
+module.exports = module.exports = {
+  backspace: "backspace",
+  delete: "delete",
+  enter: "enter",
+  tab: "tab",
+  escape: "escape",
+  up: "up",
+  down: "down",
+  right: "right",
+  left: "left",
+  home: "home",
+  end: "end",
+  pageup: "pageup",
+  pagedown: "pagedown",
+  f1: "f1",
+  f2: "f2",
+  f3: "f3",
+  f4: "f4",
+  f5: "f5",
+  f6: "f6",
+  f7: "f7",
+  f8: "f8",
+  f9: "f9",
+  f10: "f10",
+  f11: "f11",
+  f12: "f12",
+  f13: "f13",
+  f14: "f14",
+  f15: "f15",
+  f16: "f16",
+  f17: "f17",
+  f18: "f18",
+  f19: "f19",
+  f20: "f20",
+  f21: "f21",
+  f22: "f22",
+  f23: "f23",
+  f24: "f24",
+  capslock: "capslock",
+  command: "command",
+  alt: "alt",
+  right_alt: "right_alt",
+  control: "ctrl",
+  left_control: "left_control",
+  right_control: "right_control",
+  shift: "shift",
+  right_shift: "right_shift",
+  space: "space",
+  printscreen: "printscreen",
+  insert: "insert",
+  menu: "menu",
+  audio_mute: "audio_mute",
+  audio_vol_down: "audio_vol_down",
+  audio_vol_up: "audio_vol_up",
+  audio_play: "audio_play",
+  audio_stop: "audio_stop",
+  audio_pause: "audio_pause",
+  audio_prev: "audio_prev",
+  audio_next: "audio_next",
+  audio_rewind: "audio_rewind",
+  audio_forward: "audio_forward",
+  audio_repeat: "audio_repeat",
+  audio_random: "audio_random",
+  numpad_lock: "numpad_lock",
+  numpad_0: "numpad_0",
+  numpad_1: "numpad_1",
+  numpad_2: "numpad_2",
+  numpad_3: "numpad_3",
+  numpad_4: "numpad_4",
+  numpad_5: "numpad_5",
+  numpad_6: "numpad_6",
+  numpad_7: "numpad_7",
+  numpad_8: "numpad_8",
+  numpad_9: "numpad_9",
+  "numpad_+": "numpad_+",
+  "numpad_-": "numpad_-",
+  "numpad_*": "numpad_*",
+  "numpad_/": "numpad_/",
+  "numpad_.": "numpad_.",
+  lights_mon_up: "lights_mon_up",
+  lights_mon_down: "lights_mon_down",
+  lights_kbd_toggle: "lights_kbd_toggle",
+  lights_kbd_up: "lights_kbd_up",
+  lights_kbd_down: "lights_kbd_down",
+  a: "a",
+  b: "b",
+  c: "c",
+  d: "d",
+  e: "e",
+  f: "f",
+  g: "g",
+  h: "h",
+  i: "i",
+  j: "j",
+  k: "k",
+  l: "l",
+  m: "m",
+  n: "n",
+  o: "o",
+  p: "p",
+  q: "q",
+  r: "r",
+  s: "s",
+  t: "t",
+  u: "u",
+  v: "v",
+  w: "w",
+  x: "x",
+  y: "y",
+  z: "z",
+  0: "0",
+  1: "1",
+  2: "2",
+  3: "3",
+  4: "4",
+  5: "5",
+  6: "6",
+  7: "7",
+  8: "8",
+  9: "9",
+};

package/lib/logger.js

@@ -1,6 +1,7 @@
 // central logger for the bot
 const winston = require("winston");
 const os = require("os");
+const websockets = require("./websockets");
 
 // simple match for aws instance i-*
 const shouldLog =
@@ -74,7 +75,9 @@ const createMarkdownStreamLogger = () => {
     log: (chunk) => {
       if (typeof chunk !== "string") {
         return;
-      }
+      }        
+      
+      websockets.sendToClients("output", chunk);
 
       const previousConsoleOutput = markedParsePartial(buffer, 0, -1);
 

package/lib/overlay.js

@@ -11,8 +11,6 @@ ipc.config.silent = true;
 
 let electronProcess;
 
-logger.info("Spawning GUI...");
-
 try {
   // Resolve the path to Electron CLI
   const electronCliPath = require.resolve('electron/cli.js');

package/lib/redraw.js

@@ -146,7 +146,9 @@ async function checkCondition(resolve, startTime, timeoutMs) {
     logger.debug(`   `);
     resolve("true");
   } else {
-    checkCondition(resolve, startTime, timeoutMs);
+    setTimeout(() => {
+      checkCondition(resolve, startTime, timeoutMs);
+    }, 500);
   }
 }