testdriverai 1.0.0 → 4.0.0

package/lib/parser.js

@@ -0,0 +1,100 @@
+// parses markdown content to find code blocks, and then extracts yaml from those code blocks
+const Parser = require('markdown-parser');
+const yaml = require('js-yaml');
+
+let parser = new Parser();
+
+// use markdown parser to find code blocks within AI response
+const findCodeBlocks = (markdownContent) => {
+  
+  return new Promise((resolve, reject) => {
+    parser.parse(markdownContent, (err, result) => {
+
+      if (err) {
+        return reject(err);
+      }
+      
+      let codes = result.codes.filter((code) => {
+        return code.code.indexOf('yml') > -1 || code.code.indexOf('yaml') > -1;
+      })
+
+      return resolve(codes);
+
+    });
+    
+  });
+
+}
+
+// parse the yml from the included codeblock and clean it up
+const getYAMLFromCodeBlock = function(codeblock) {
+
+  let lines = codeblock.code.split('\n');
+
+  // if first line is yaml or yml, remove it
+  if (lines[0].indexOf('yaml') > -1 || lines[0].indexOf('yml') > -1) {
+    lines.shift();
+  }
+
+  // count the whitespace in each line, and remove the line if it's all whitespace
+  lines = lines.filter((line) => {
+    return line.trim().length > 0 && line.trim()[0] !== ',';
+    // sometimes it produces yaml with breaks, or just a single comma
+  });
+
+  return lines.join('\n');
+  
+}
+
+// do the actual parsing
+// this library is very strict
+// note that errors are sent to the AI will it may self-heal
+const parseYAML = async function(inputYaml) {
+
+  let doc = await yaml.load(inputYaml);
+  return doc;
+
+};
+
+module.exports = { 
+  findCodeBlocks,
+  getYAMLFromCodeBlock,
+  getCommands: async function(codeBlock) {
+
+    const yml = getYAMLFromCodeBlock(codeBlock);
+    let yamlArray = await parseYAML(yml);
+  
+    let steps = yamlArray?.steps;
+
+    if (steps) {
+
+      let commands = [];
+
+      // combine them all as if they were a single step
+      steps.forEach((s) => {
+        commands = commands.concat(s.commands);
+      });
+
+      // filter undefined values
+      commands = commands.filter((r) => {
+        return r;
+      });
+
+      if (!commands.length) {
+        throw new Error('No actions found in yaml. Individual commands must be under the `commands` key.');
+      }
+
+      return commands;
+
+    } else {
+      let commands = yamlArray?.commands;
+
+      if (!commands?.length) {
+        throw new Error('No actions found in yaml. Individual commands must be under the `commands` key.');
+      }
+      
+      return commands;
+
+    }
+  }
+}

package/lib/redraw.js

@@ -0,0 +1,51 @@
+const {captureScreenPNG} = require('./system');
+
+const Jimp = require('jimp');
+
+async function compareImages(image1Url, image2Url) {
+    const image1 = await Jimp.read(image1Url);
+    const image2 = await Jimp.read(image2Url);
+
+    // Perceived distance
+    const distance = Jimp.distance(image1, image2);
+    // Pixel difference
+    const diff = Jimp.diff(image1, image2);
+    
+    if (diff.percent < 0.15) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+let startImage = null;
+
+async function start() {
+  startImage = await captureScreenPNG();
+  return startImage;
+}
+
+function wait(timeoutMs) {
+  return new Promise(async (resolve, reject) => {
+    const startTime = Date.now();
+    
+    async function checkCondition() {
+
+      let nowImage = await captureScreenPNG();
+      let result = await compareImages(startImage, nowImage);
+
+      if (result) {
+        resolve('Condition met');
+      } else if (Date.now() - startTime >= timeoutMs) {
+        resolve('Timeout reached');
+      } else {
+        setTimeout(checkCondition, 0);
+      }
+
+    }
+    
+    checkCondition();
+  });
+}
+
+module.exports = {start, wait};

package/lib/sdk.js

@@ -0,0 +1,113 @@
+// custom "sdk" for calling our API
+const root = "http://api.testdriver.ai";
+const chalk = require('chalk');
+const axios = require('axios');
+const session = require('./session')
+const package = require('../package.json');
+const version = package.version;
+
+let token = null;
+
+let outputError = (e) => {
+
+  console.log(chalk.red(e.code || e.response.data.code))
+
+  if (e.response) {
+  
+    console.log(chalk.red(e.response?.status), chalk.red(e.response?.statusText))
+    if(e.response.data) { console.log(e.response.data) }
+    if(e.response.data.message) { console.log(e.response.data.message) }
+    if (e.response.data.problems) {
+      console.log('-----')
+      console.log(e.response.data.problems.join('\n'))
+    }
+  } 
+}
+
+let auth = async () => {
+  
+  // data.apiKey = process.env.DASHCAM_API_KEY; @todo add-auth
+
+  if (!data.apiKey) {
+    console.log(chalk.red('API key not found. Set DASHCAM_API_KEY in your environment.'));
+    process.exit(1);
+  }
+
+  let config = {
+    method: 'post',
+    maxBodyLength: Infinity,
+    url: [root, 'auth/exchange-api-key'].join('/'),
+    headers: { 
+      'Content-Type': 'application/json'
+    },
+    data
+  };
+
+  // this is a dashcam api url
+  try {
+    let res = await axios.request(config);
+    token = res.data.token;
+  } catch (e) { 
+    outputError(e);
+    process.exit(1);
+  }
+
+}
+
+let req = async (path, data) => {
+
+  // for each value of data, if it is empty remove it
+  for (let key in data) {
+    if (!data[key]) {
+      delete data[key];
+    }
+  }
+
+  data.session = session.get()?.id;
+  data = JSON.stringify(data);
+
+  let dataCopy = JSON.parse(data);
+  delete dataCopy.image
+  
+  let url = [root, 'api', 'v' + version, 'testdriver', path].join('/');
+
+  let config = {
+    method: 'post',
+    maxBodyLength: Infinity,
+    url,
+    headers: { 
+      'Content-Type': 'application/json',
+      // 'Authorization': 'Bearer ' + token @todo add-auth
+    },
+    data
+  };
+  
+  let response;
+  let redirect = null
+  try {
+    response = await axios.request(config);
+  } catch (e) {
+
+    if (e.response?.status === 301) {
+      config.url = root + e.response.data;
+      redirect = config;
+    } else {
+      outputError(e);
+    }
+
+  }
+
+  if (redirect) {
+    response = await axios.request(redirect).catch(e => {
+      outputError(e);
+    });
+  }
+
+  if (!response) {
+    return;
+  } else {
+    return response.data;
+  }
+}
+
+module.exports = {req, auth};

package/lib/session.js

@@ -0,0 +1,10 @@
+let session = null;
+
+module.exports = {
+  get: () => {
+    return session;
+  },
+  set: (s) => {
+    session = s;
+  }
+};

package/lib/speak.js

@@ -0,0 +1,14 @@
+const say = require('say');
+
+module.exports = (message) => {
+  
+  if (process.env["TD_SPEAK"]) {
+    say.stop();
+    if (process.platform === 'darwin') {
+      say.speak(message, 'Fred', 1.2);
+    } else {
+      say.speak(message);
+    }
+  }
+
+}

package/lib/system.js

@@ -0,0 +1,112 @@
+// utilities for getting information about the system
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const screenshot = require('screenshot-desktop')
+const si = require('systeminformation');
+const activeWindow = require('active-win');
+const sharp = require('sharp')
+const robot = require('robotjs');
+
+let displayMultiple = 0;
+let primaryDisplay = null;
+
+// get the primary display
+// this is the only display we ever target, because fuck it
+// the vm only has one and most people only have one
+const getPrimaryDisplay = async () => {
+
+  // calculate scaling resolution
+  let graphics = await si.graphics();
+  let primaryDisplay = graphics.displays.find((display) => display.main == true);
+
+  return primaryDisplay;
+}
+
+const getSystemInformationOsInfo = async() => {
+  return await si.osInfo();
+}
+
+// this hepls us understand how to scale things for retina screens
+const calculateDisplayMultiple = async () => {
+  let primaryDisplay = await getPrimaryDisplay();
+  displayMultiple = primaryDisplay.currentResX / primaryDisplay.resolutionX;
+};
+
+const getDisplayMultiple = async () => {
+
+  if (!displayMultiple) {
+    await calculateDisplayMultiple();
+  }
+  
+  return displayMultiple;
+};
+
+const tmpFilename = () => {
+  return path.join(os.tmpdir(), `${new Date().getTime() + Math.random()}.png`); 
+}
+
+// our handy screenshot function
+const captureScreenBase64 = async () => {
+
+  let primaryDisplay = await getPrimaryDisplay();
+  
+  let step1 = tmpFilename();
+  let step2 = tmpFilename();
+
+  await screenshot({ filename: step1, format: 'png' });
+
+  // resize to 1:1 px ratio
+  await sharp(step1)
+    .resize(primaryDisplay.currentResX, primaryDisplay.currentResY)
+    .toFile(step2);
+
+  let image = fs.readFileSync(step2, "base64");
+
+  return image;
+
+};
+
+const captureScreenPNG = async () => {
+      
+    let step1 = tmpFilename();
+    await screenshot({ filename: step1, format: 'png' });
+    
+    return step1;
+  
+}
+
+const platform = () => {
+  let platform = process.platform;
+  if (platform === 'darwin') {
+    platform = 'mac';
+  } else if (platform === 'win32') {
+    platform = 'windows';
+  } else if (platform === 'linux') {
+    platform = 'linux';
+  } else {
+    throw new Error('Unsupported platform');
+  }
+  return platform;
+}
+
+// this is the focused window
+const activeWin = async () => {
+  return await activeWindow();
+}
+
+const getMousePosition = async () => {
+  return await robot.getMousePos();
+}
+
+module.exports = {
+  captureScreenBase64,
+  captureScreenPNG,
+  getDisplayMultiple,
+  calculateDisplayMultiple,
+  getMousePosition,
+  primaryDisplay,
+  activeWin,
+  platform,
+  getSystemInformationOsInfo
+}

package/lib/valid-version.js

@@ -0,0 +1,19 @@
+const semver = require('semver')
+const package = require('../package.json');
+
+// Function to check if the new version's minor version is >= current version's minor version
+module.exports = (inputVersion) => {
+
+  const currentParsed = semver.parse(package.version);
+  const inputParsed = semver.parse(inputVersion.replace('v', ''));
+
+  if (!currentParsed || !inputParsed) {
+    throw new Error('Invalid version format');
+  }
+
+  // Compare major and minor versions
+  if (inputParsed.major === currentParsed.major && inputParsed.minor >= currentParsed.minor) {
+      return true;
+  }
+  return false;
+}

package/package.json

@@ -1,11 +1,57 @@
 {
   "name": "testdriverai",
-  "version": "1.0.0",
+  "version": "4.0.0",
+  "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "index.js",
+  "bin": {
+    "testdriver": "./index.js"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "start": "node index.js",
+    "dev": "DEV=true node index.js",
+    "debug": "DEV=true VERBOSE=true node index.js",
+    "bundle": "node build.mjs",
+    "postinstall": "node postinstall.js"
   },
   "author": "",
   "license": "ISC",
-  "description": ""
+  "dependencies": {
+    "@electerm/strip-ansi": "^1.0.0",
+    "active-win": "^8.2.1",
+    "axios": "^1.6.8",
+    "chalk": "^4.1.2",
+    "cli-progress": "^3.12.0",
+    "datadog-winston": "^1.6.0",
+    "decompress": "^4.2.1",
+    "dotenv": "^16.4.5",
+    "jimp": "^0.22.12",
+    "js-yaml": "^4.1.0",
+    "markdown-parser": "0.0.8",
+    "marked": "^12.0.1",
+    "marked-terminal": "^7.0.0",
+    "node-notifier": "^10.0.1",
+    "prompts": "^2.4.2",
+    "remark-parse": "^11.0.0",
+    "rimraf": "^5.0.5",
+    "robotjs": "^0.6.0",
+    "say": "^0.16.0",
+    "screenshot-desktop": "^1.15.0",
+    "semver": "^7.6.2",
+    "sharp": "^0.33.4",
+    "systeminformation": "^5.22.7",
+    "tmp": "^0.2.3",
+    "uuid": "^10.0.0",
+    "winston": "^3.13.0"
+  },
+  "devDependencies": {
+    "esbuild": "0.20.2",
+    "esbuild-plugin-fileloc": "^0.0.6",
+    "node-addon-api": "^8.0.0",
+    "node-gyp": "^10.1.0"
+  },
+  "optionalDependencies": {
+    "@esbuild/linux-x64": "^0.21.5",
+    "@img/sharp-libvips-win32-x64": "^1.0.2",
+    "@img/sharp-win32-x64": "^0.33.4"
+  }
 }

package/postinstall.js

@@ -0,0 +1,20 @@
+let platform = require('os').platform();
+let exec = require('child_process').exec;
+
+if (platform !== 'darwin') {
+  console.log('TestDriver Setup: Skipping codesign becasue not on Mac');
+  return;
+}
+
+console.log('TestDriver Setup: Codesigning terminal-notifier.app');
+
+let signScript = `codesign --sign - --force --deep node_modules/node-notifier/vendor/mac.noindex/terminal-notifier.app`;
+
+exec(signScript, (error, stdout, stderr) => {
+  if (error) {
+    console.error(`exec error: ${error}`);
+    return;
+  }
+  console.log(`stdout: ${stdout}`);
+  console.error(`stderr: ${stderr}`);
+});

package/subimage/index.js

@@ -0,0 +1,70 @@
+const Jimp = require("jimp");
+const path = require("path");
+cv = require('./opencv.js');
+
+async function findTemplateImage(haystack, needle, threshold) {
+  try {
+    const positions = [];
+
+    const imageSource = await Jimp.read(path.join(haystack));
+    const imageTemplate = await Jimp.read(path.join(needle));
+
+    const templ = cv.matFromImageData(imageTemplate.bitmap);
+    let src = cv.matFromImageData(imageSource.bitmap);
+    let processedImage = new cv.Mat();
+    let mask = new cv.Mat();
+
+    cv.matchTemplate(src, templ, processedImage, cv.TM_CCOEFF_NORMED, mask);
+
+    cv.threshold(
+      processedImage,
+      processedImage,
+      threshold,
+      1,
+      cv.THRESH_BINARY
+    );
+    processedImage.convertTo(processedImage, cv.CV_8UC1);
+    let contours = new cv.MatVector();
+    let hierarchy = new cv.Mat();
+
+    cv.findContours(
+      processedImage,
+      contours,
+      hierarchy,
+      cv.RETR_EXTERNAL,
+      cv.CHAIN_APPROX_SIMPLE
+    );
+
+    for (let i = 0; i < contours.size(); ++i) {
+      let [x, y] = contours.get(i).data32S; // Contains the points
+      positions.push({
+        x,
+        y,
+        height: templ.rows,
+        width: templ.cols,
+        centerX: x + templ.cols / 2,
+        centerY: y + templ.rows / 2,
+      });
+    }
+
+    src.delete();
+    mask.delete();
+    templ.delete();
+
+    return positions;
+  } catch (err) {
+    console.error('OpenCV threw an error');
+  }
+}
+
+function onRuntimeInitialized() {
+}
+
+// Finally, load the open.js as before. The function `onRuntimeInitialized` contains our program.
+Module = {
+  onRuntimeInitialized,
+};
+
+module.exports = {
+  findTemplateImage
+}