testdriverai 5.7.43 → 5.7.44

package/lib/logger.js

@@ -2,6 +2,8 @@
 const winston = require("winston");
 const os = require("os");
 const server = require("./ipc");
+const chalk = require("chalk");
+const theme = require("./theme");
 
 // simple match for aws instance i-*
 const shouldLog =
@@ -49,14 +51,233 @@ const logger = winston.createLogger({
   transports: [new winston.transports.Console()],
 });
 
+const plain = (codePart) => codePart;
+
 // marked is a markdown parser
 // markedTerminal allows us to render markdown in CLI
 marked.use(
-  markedTerminal({
-    width: 58, // 58 is the width of the terminal output on a 16" macbook pro
-    reflowText: true,
-    tab: 0,
-  }),
+  markedTerminal(
+    {
+      width: 58, // 58 is the width of the terminal output on a 16" macbook pro
+      reflowText: true,
+      tab: 2,
+    },
+    {
+      theme: {
+        /**
+         * keyword in a regular Algol-style language
+         */
+        keyword: theme.blue,
+
+        /**
+         * built-in or library object (constant, class, function)
+         */
+        built_in: theme.cyan,
+
+        /**
+         * user-defined type in a language with first-class syntactically significant types, like
+         * Haskell
+         */
+        type: theme.cyan,
+
+        /**
+         * special identifier for a built-in value ("true", "false", "null")
+         */
+        literal: theme.blue,
+
+        /**
+         * number, including units and modifiers, if any.
+         */
+        number: theme.green,
+
+        /**
+         * literal regular expression
+         */
+        regexp: theme.red,
+
+        /**
+         * literal string, character
+         */
+        string: theme.green,
+
+        /**
+         * parsed section inside a literal string
+         */
+        subst: plain,
+
+        /**
+         * symbolic constant, interned string, goto label
+         */
+        symbol: plain,
+
+        /**
+         * class or class-level declaration (interfaces, traits, modules, etc)
+         */
+        class: theme.blue,
+
+        /**
+         * function or method declaration
+         */
+        function: theme.yellow,
+
+        /**
+         * name of a class or a function at the place of declaration
+         */
+        title: plain,
+
+        /**
+         * block of function arguments (parameters) at the place of declaration
+         */
+        params: plain,
+
+        /**
+         * comment
+         */
+        comment: theme.green,
+
+        /**
+         * documentation markup within comments
+         */
+        doctag: theme.green,
+
+        /**
+         * flags, modifiers, annotations, processing instructions, preprocessor directive, etc
+         */
+        meta: theme.grey,
+
+        /**
+         * keyword or built-in within meta construct
+         */
+        "meta-keyword": plain,
+
+        /**
+         * string within meta construct
+         */
+        "meta-string": plain,
+
+        /**
+         * heading of a section in a config file, heading in text markup
+         */
+        section: plain,
+
+        /**
+         * XML/HTML tag
+         */
+        tag: theme.grey,
+
+        /**
+         * name of an XML tag, the first word in an s-expression
+         */
+        name: theme.blue,
+
+        /**
+         * s-expression name from the language standard library
+         */
+        "builtin-name": plain,
+
+        /**
+         * name of an attribute with no language defined semantics (keys in JSON, setting names in
+         * .ini), also sub-attribute within another highlighted object, like XML tag
+         */
+        attr: theme.cyan,
+
+        /**
+         * name of an attribute followed by a structured value part, like CSS properties
+         */
+        attribute: plain,
+
+        /**
+         * variable in a config or a template file, environment var expansion in a script
+         */
+        variable: plain,
+
+        /**
+         * list item bullet in text markup
+         */
+        bullet: plain,
+
+        /**
+         * code block in text markup
+         */
+        code: plain,
+
+        /**
+         * emphasis in text markup
+         */
+        emphasis: chalk.italic,
+
+        /**
+         * strong emphasis in text markup
+         */
+        strong: chalk.bold,
+
+        /**
+         * mathematical formula in text markup
+         */
+        formula: plain,
+
+        /**
+         * hyperlink in text markup
+         */
+        link: chalk.underline,
+
+        /**
+         * quotation in text markup
+         */
+        quote: plain,
+
+        /**
+         * tag selector in CSS
+         */
+        "selector-tag": plain,
+
+        /**
+         * #id selector in CSS
+         */
+        "selector-id": plain,
+
+        /**
+         * .class selector in CSS
+         */
+        "selector-class": plain,
+
+        /**
+         * [attr] selector in CSS
+         */
+        "selector-attr": plain,
+
+        /**
+         * :pseudo selector in CSS
+         */
+        "selector-pseudo": plain,
+
+        /**
+         * tag of a template language
+         */
+        "template-tag": plain,
+
+        /**
+         * variable in a template language
+         */
+        "template-variable": plain,
+
+        /**
+         * added or changed line in a diff
+         */
+        addition: theme.green,
+
+        /**
+         * deleted line in a diff
+         */
+        deletion: theme.red,
+
+        /**
+         * things not matched by any token
+         */
+        default: plain,
+      },
+    },
+  ),
 );
 
 const spaceChar = "    ";

package/lib/network.js

@@ -1,3 +0,0 @@
-
-
-

package/lib/outputs.js

@@ -1,5 +1,5 @@
 let outputs = {};
-const {logger} = require('./logger');
+const { logger } = require("./logger");
 
 module.exports = {
   getAll: () => {

package/lib/parser.js

@@ -2,35 +2,34 @@
 const Parser = require("markdown-parser");
 const yaml = require("js-yaml");
 const Ajv = require("ajv");
+const theme = require("./theme");
 
 let parser = new Parser();
 
-const chalk = require('chalk');
-
 function formatAjvError(error) {
-
   return [
-    chalk.yellow('❌ Validation Warning (beta)'),
-    `${chalk.yellow('Path:')}      ${chalk.white(error.instancePath)}`,
-    `${chalk.yellow('Schema:')}    ${chalk.cyan(error.schemaPath)}`,
-    `${chalk.yellow('Keyword:')}   ${chalk.magenta(error.keyword)}`,
+    theme.yellow("❌ Validation Warning (beta)"),
+    `${theme.yellow("Path:")}      ${theme.white(error.instancePath)}`,
+    `${theme.yellow("Schema:")}    ${theme.cyan(error.schemaPath)}`,
+    `${theme.yellow("Keyword:")}   ${theme.magenta(error.keyword)}`,
     error.params?.missingProperty
-      ? `${chalk.yellow('Missing:')}   ${chalk.yellow(error.params.missingProperty)}`
-      : '',
-    `${chalk.yellow('Message:')}   ${chalk.white(error.message)}`,
-    `\n`
-  ].filter(Boolean).join('\n');
+      ? `${theme.yellow("Missing:")}   ${theme.yellow(error.params.missingProperty)}`
+      : "",
+    `${theme.yellow("Message:")}   ${theme.white(error.message)}`,
+    `\n`,
+  ]
+    .filter(Boolean)
+    .join("\n");
 }
 
 // use markdown parser to find code blocks within AI response
 const findCodeBlocks = async function (markdownContent) {
-
   let md = markdownContent.match(/```yaml\n([\s\S]*?)```/);
 
   if (md) {
-    return [{code: md[1]}];
+    return [{ code: md[1] }];
   } else {
-    return []
+    return [];
   }
 };
 
@@ -44,7 +43,6 @@ const findGenerativePrompts = async function (markdownContent) {
 
       // parse the markdown content of each code block
       let codes = result.codes.map((code) => {
-
         return new Promise((resolve2, reject2) => {
           try {
             const yamlContent = getYAMLFromCodeBlock(code);
@@ -93,13 +91,12 @@ const parseYAML = async function (inputYaml) {
 // validate yaml using schema.json in root
 let schema = require("../schema.json");
 const validateYAML = async function (yaml) {
-
-  let ajv = new Ajv({allowUnionTypes: true});
+  let ajv = new Ajv({ allowUnionTypes: true });
   let validate = ajv.compile(schema);
   let valid = validate(await parseYAML(yaml));
 
   if (!valid) {
-    validate.errors.forEach(err => console.log(formatAjvError(err)));
+    validate.errors.forEach((err) => console.log(formatAjvError(err)));
     // throw new Error("Invalid YAML");
   }
 
@@ -108,12 +105,14 @@ const validateYAML = async function (yaml) {
 
 // Replace ${VAR} with the value from the vars object
 // Will skip variables that are not in the vars object
-// Will skip escaped variables like \${VAR} 
-function interpolate (yaml, vars) {
-
+// Will skip escaped variables like \${VAR}
+function interpolate(yaml, vars) {
   let newyaml = yaml;
   Object.keys(vars).forEach((key) => {
-    newyaml = newyaml.replace(new RegExp(`(?<!\\\\)\\$\\{${key}\\}`, "g"), vars[key]);
+    newyaml = newyaml.replace(
+      new RegExp(`(?<!\\\\)\\$\\{${key}\\}`, "g"),
+      vars[key],
+    );
   });
   // Replace \$ with $
   newyaml = newyaml.replace(/\\(\${[^}]+})/g, "$1");

package/lib/redraw.js

@@ -3,10 +3,10 @@ const os = require("os");
 const path = require("path");
 const { compare } = require("odiff-bin");
 const logger = require("./logger").logger;
+const theme = require("./theme");
 
 // network
-const si = require('systeminformation');
-const chalk = require('chalk');
+const si = require("systeminformation");
 
 const redrawThresholdPercent = 3;
 const networkUpdateInterval = 2000;
@@ -29,8 +29,7 @@ async function resetState() {
   screenHasRedrawn = false;
 }
 
-const parseNetworkStats = (thisRxBytes,thisTxBytes) => {
-
+const parseNetworkStats = (thisRxBytes, thisTxBytes) => {
   diffRxBytes = lastRxBytes !== null ? thisRxBytes - lastRxBytes : 0;
   diffTxBytes = lastTxBytes !== null ? thisTxBytes - lastTxBytes : 0;
 
@@ -43,27 +42,34 @@ const parseNetworkStats = (thisRxBytes,thisTxBytes) => {
     measurements.shift();
   }
 
-  let avgRx = measurements.reduce((acc, m) => acc + m.rx, 0) / measurements.length;
-  let avgTx = measurements.reduce((acc, m) => acc + m.tx, 0) / measurements.length;
+  let avgRx =
+    measurements.reduce((acc, m) => acc + m.rx, 0) / measurements.length;
+  let avgTx =
+    measurements.reduce((acc, m) => acc + m.tx, 0) / measurements.length;
 
-  let stdDevRx = Math.sqrt(measurements.reduce((acc, m) => acc + Math.pow(m.rx - avgRx, 2), 0) / measurements.length);
-  let stdDevTx = Math.sqrt(measurements.reduce((acc, m) => acc + Math.pow(m.tx - avgTx, 2), 0) / measurements.length);
+  let stdDevRx = Math.sqrt(
+    measurements.reduce((acc, m) => acc + Math.pow(m.rx - avgRx, 2), 0) /
+      measurements.length,
+  );
+  let stdDevTx = Math.sqrt(
+    measurements.reduce((acc, m) => acc + Math.pow(m.tx - avgTx, 2), 0) /
+      measurements.length,
+  );
 
   let zIndexRx = stdDevRx !== 0 ? (diffRxBytes - avgRx) / stdDevRx : 0;
   let zIndexTx = stdDevTx !== 0 ? (diffTxBytes - avgTx) / stdDevTx : 0;
 
-  if ((zIndexRx < 0 && zIndexTx < 0) ) {
+  if (zIndexRx < 0 && zIndexTx < 0) {
     networkSettled = true;
   } else {
     networkSettled = false;
   }
-}
+};
 
 async function updateNetwork() {
-
-  const { exec } = require('child_process');
+  const { exec } = require("child_process");
   const scriptPath = path.join(__dirname, "network.ps1");
-  if (os.platform() === 'win32') {
+  if (os.platform() === "win32") {
     exec(`powershell -File ${scriptPath}`, (error, stdout, stderr) => {
       if (error) {
         logger.error(`Error executing PowerShell script: ${error}`);
@@ -73,7 +79,7 @@ async function updateNetwork() {
         logger.error(`PowerShell error: ${stderr}`);
         return;
       }
-      
+
       try {
         // Parse the JSON output
         const result = JSON.parse(stdout.trim());
@@ -82,15 +88,14 @@ async function updateNetwork() {
         logger.error(`Error parsing JSON: ${parseError}`);
       }
     });
-  } else if (os.platform() === 'darwin') {
-    si.networkStats().then(data => {
+  } else if (os.platform() === "darwin") {
+    si.networkStats().then((data) => {
       parseNetworkStats(data[0].rx_bytes, data[0].tx_bytes);
     });
   }
 }
 
 async function imageDiffPercent(image1Url, image2Url) {
-
   // generate a temporary file path
   const tmpImage = path.join(os.tmpdir(), `tmp-${Date.now()}.png`);
 
@@ -100,7 +105,7 @@ async function imageDiffPercent(image1Url, image2Url) {
     tmpImage,
     {
       failOnLayoutDiff: false,
-      outputDiffMask: false
+      outputDiffMask: false,
     },
   );
 
@@ -115,7 +120,6 @@ async function imageDiffPercent(image1Url, image2Url) {
   }
 }
 
-
 let startImage = null;
 
 async function start() {
@@ -125,7 +129,7 @@ async function start() {
 }
 
 async function checkCondition(resolve, startTime, timeoutMs) {
-  let nowImage = await captureScreenPNG(.25, true);
+  let nowImage = await captureScreenPNG(0.25, true);
   let timeElapsed = Date.now() - startTime;
   let diffPercent = 0;
   let isTimeout = timeElapsed > timeoutMs;
@@ -133,14 +137,30 @@ async function checkCondition(resolve, startTime, timeoutMs) {
   if (!screenHasRedrawn) {
     diffPercent = await imageDiffPercent(startImage, nowImage);
     screenHasRedrawn = diffPercent > redrawThresholdPercent;
-  };
-  
-  // // log redraw as output
-  let redrawText = screenHasRedrawn ? chalk.green(`y`) : chalk.dim(`${diffPercent}/${redrawThresholdPercent}%`);
-  let networkText = networkSettled ? chalk.green(`y`) : chalk.dim(`${Math.trunc((diffRxBytes + diffTxBytes) / networkUpdateInterval)}b/s`);
-  let timeoutText = isTimeout ?  chalk.green(`y`) : chalk.dim(`${Math.floor((timeElapsed)/1000)}/${(timeoutMs / 1000)}s`);
+  }
 
-  logger.debug(`   ` + chalk.dim('redraw=') + redrawText + chalk.dim(' network=') + networkText + chalk.dim(' timeout=') + timeoutText);
+  // // log redraw as output
+  let redrawText = screenHasRedrawn
+    ? theme.green(`y`)
+    : theme.dim(`${diffPercent}/${redrawThresholdPercent}%`);
+  let networkText = networkSettled
+    ? theme.green(`y`)
+    : theme.dim(
+        `${Math.trunc((diffRxBytes + diffTxBytes) / networkUpdateInterval)}b/s`,
+      );
+  let timeoutText = isTimeout
+    ? theme.green(`y`)
+    : theme.dim(`${Math.floor(timeElapsed / 1000)}/${timeoutMs / 1000}s`);
+
+  logger.debug(
+    `   ` +
+      theme.dim("redraw=") +
+      redrawText +
+      theme.dim(" network=") +
+      networkText +
+      theme.dim(" timeout=") +
+      timeoutText,
+  );
 
   if ((screenHasRedrawn && networkSettled) || isTimeout) {
     logger.debug(`   `);

package/lib/resources/prerun.yaml

@@ -5,10 +5,10 @@ steps:
     commands:
       - command: exec
         lang: shell
-        linux: | 
+        linux: |
           jumpapp google-chrome --disable-fre --no-default-browser-check --no-first-run "${TESTDRIVER_WEBSITE}" &
           exit
-        mac: |  
+        mac: |
           open -na "Google Chrome" --args --disable-fre --no-default-browser-check --no-first-run "${TESTDRIVER_WEBSITE}" &
           exit
         windows:

package/lib/sandbox.js

@@ -1,5 +1,5 @@
-const WebSocket = require('ws');
-const config = require('./config');
+const WebSocket = require("ws");
+const config = require("./config");
 
 class Sandbox {
   constructor() {
@@ -11,60 +11,60 @@ class Sandbox {
   send(message) {
     let resolvePromise;
     if (this.socket) {
-      message.requestId = Math.random().toString(36).substring(7) + new Date().getTime();
+      message.requestId =
+        Math.random().toString(36).substring(7) + new Date().getTime();
       let p = new Promise((resolve) => {
         this.socket.send(JSON.stringify(message));
         resolvePromise = resolve;
       });
-      this.ps[message.requestId] = {promise: p, resolve: resolvePromise};
+      this.ps[message.requestId] = { promise: p, resolve: resolvePromise };
       return p;
     }
   }
 
   async boot() {
     return new Promise((resolve, reject) => {
-
-      this.socket = new WebSocket(`${config.TD_API_ROOT.replace('https://', 'wss://')}`);
+      this.socket = new WebSocket(
+        `${config.TD_API_ROOT.replace("https://", "wss://")}`,
+      );
 
       // handle errors
-      this.socket.on('close', () => {
-        console.log('Socket Closed. Check your API KEY (TD_API_KEY)');
+      this.socket.on("close", () => {
+        console.log("Socket Closed. Check your API KEY (TD_API_KEY)");
         clearInterval(this.heartbeat);
         reject();
         process.exit(1);
-      }); 
+      });
 
-      this.socket.on('error', (err) => {
-        console.log('Socket Error');
+      this.socket.on("error", (err) => {
+        console.log("Socket Error");
         err && console.log(err);
         clearInterval(this.heartbeat);
         throw err;
-      }); 
+      });
 
-      this.socket.on('open', async () => {
-        
+      this.socket.on("open", async () => {
         this.heartbeat = setInterval(() => {
-          this.send({type: 'ping'});
+          this.send({ type: "ping" });
         }, 5000);
 
         resolve(this);
       });
 
-      this.socket.on('message', (raw) => {
+      this.socket.on("message", (raw) => {
         let message = JSON.parse(raw);
 
-        if (message.type === 'error') {
+        if (message.type === "error") {
           console.error(message);
-        } 
+        }
 
         if (this.ps[message.requestId]) {
           this.ps[message.requestId].resolve(message);
           delete this.ps[message.requestId];
         } else {
-          console.log('unhandled message', message);
+          console.log("unhandled message", message);
         }
       });
-
     });
   }
 }

package/lib/sdk.js

@@ -1,11 +1,11 @@
 const config = require("./config");
-const chalk = require("chalk");
 const session = require("./session");
 
 // get the version from package.json
 const { version } = require("../package.json");
 const root = config["TD_API_ROOT"];
 const axios = require("axios");
+const theme = require("./theme");
 
 const { logger } = require("./logger");
 
@@ -14,7 +14,7 @@ let token = null;
 const outputError = (error) => {
   logger.error(
     "API Error: %s (%s)",
-    chalk.red(
+    theme.red(
       // HTTP status code from Axios
       error.status ||
         // ...or an explicit error `reason` set by Sails
@@ -22,7 +22,7 @@ const outputError = (error) => {
         // ...or default to the error message
         error.message,
     ),
-    chalk.red(
+    theme.red(
       // e.g. "teamNotExist" from Sails' exits
       error.response?.data?.raw ||
         // ...or the status text
@@ -74,7 +74,7 @@ const parseBody = async (response, body) => {
     }
     return body;
   } catch (err) {
-    logger.error(chalk.red("Parsing Error", err));
+    logger.error(theme.red("Parsing Error", err));
     throw err;
   }
 };

package/lib/session.js

@@ -5,10 +5,8 @@ module.exports = {
     return session;
   },
   set: (s) => {
-
     if (s && !session) {
       session = s;
     }
-
   },
 };

package/lib/system.js

@@ -181,7 +181,7 @@ const activeWin = async () => {
       windows = await activeWindow?.();
     } catch (e) {
       console.error("Error getting active window", e);
-        return "error getting active window, proceed normally";
+      return "error getting active window, proceed normally";
     }
     return windows;
   }

package/lib/theme.js

@@ -0,0 +1,13 @@
+const chalk = require("chalk");
+
+module.exports = {
+  green: chalk.hex("#b3d334"),
+  blue: chalk.hex("#34a3d3"),
+  red: chalk.hex("#d33434"),
+  yellow: chalk.hex("#ced334"),
+  magenta: chalk.hex("#d334b3"),
+  cyan: chalk.hex("#34d3d3"),
+  dim: chalk.dim,
+  gray: chalk.gray,
+  white: chalk.white,
+};

package/lib/upload-secrets.js

@@ -57,7 +57,7 @@ module.exports = async () => {
       try {
         const cmd = `gh secret set ${key} --body "${value}"`;
         execSync(cmd, { stdio: "inherit" });
-      // eslint-disable-next-line no-unused-vars
+        // eslint-disable-next-line no-unused-vars
       } catch (err) {
         console.error(`❌ Failed to upload ${key}`);
       }