testdriverai 4.2.19 → 5.0.0-beta-8

package/lib/sandbox.js

@@ -0,0 +1,64 @@
+const EventEmitter = require('events');
+const WebSocket = require('ws');
+const config = require('./config');
+
+class Sandbox {
+  constructor() {
+    this.socket = null;
+    this.ps = {};
+    this.heartbeat = null;
+  }
+
+  send(message) {
+    let resolvePromise;
+    if (this.socket) {
+      message.requestId = Math.random().toString(36).substring(7) + new Date().getTime();
+      let p = new Promise((resolve, reject) => {
+        this.socket.send(JSON.stringify(message));
+        resolvePromise = resolve;
+      });
+      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://')}`);
+
+      // handle errors
+      this.socket.on('error', (err) => {
+        console.log('Socket Closed');
+        console.log('If this happens during setup, check your API Key (`TD_API_KEY` in `.env`).');
+        err && console.log(err);
+        clearInterval(this.heartbeat);
+        reject();
+      }); 
+
+      this.socket.on('open', async () => {
+        
+        this.heartbeat = setInterval(() => {
+          this.send({type: 'ping'});
+        }, 5000);
+
+        resolve(this);
+      });
+
+      this.socket.on('message', (raw) => {
+        let message = JSON.parse(raw);
+
+        if (this.ps[message.requestId]) {
+          this.ps[message.requestId].resolve(message);
+          delete this.ps[message.requestId];
+        } else {
+          console.log('unhandled message', message);
+        }
+      });
+
+    });
+  }
+}
+
+const sandboxInstance = new Sandbox();
+module.exports = sandboxInstance;

package/lib/speak.js

@@ -1,9 +1,12 @@
 const say = require("say");
 const config = require("./config");
+const websockets = require("./websockets");
+
 
 module.exports = (message) => {
   if (config["TD_SPEAK"]) {
     say.stop();
+    // websockets.sendToClients("output", message);  
     if (process.platform === "darwin") {
       say.speak(message, "Fred", 1.2);
     } else {

package/lib/system.js

@@ -2,13 +2,28 @@
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
-const screenshot = require("screenshot-desktop");
 const si = require("systeminformation");
 const robot = require("robotjs");
 const sharp = require("sharp");
 const { emitter, events } = require("./events.js");
+const sandbox = require("./sandbox.js");
+const config = require("./config.js");
 
-const { logger } = require("./logger.js");
+let scshotdesk;
+if (!config.TD_VM) {
+  scshotdesk = require("screenshot-desktop");
+}
+
+const screenshot = async (options) => {
+
+  if (config.TD_VM) {
+    let {base64} = await sandbox.send({type: 'screenshot'});
+    let image = Buffer.from(base64, 'base64');
+    fs.writeFileSync(options.filename, image);
+  } else {
+    return await scshotdesk({ filename: options.filename, format: "png" });
+  }
+}
 
 let primaryDisplay = null;
 
@@ -26,7 +41,13 @@ const getPrimaryDisplay = async () => {
 };
 
 const getSystemInformationOsInfo = async () => {
-  return await si.osInfo();
+  if (config.TD_VM) {
+    return {
+      os: 'linux'
+    }
+  } else {
+    return await si.osInfo();
+  }
 };
 
 let countImages = 0;
@@ -37,7 +58,7 @@ const tmpFilename = () => {
 
 const captureAndResize = async (scale = 1, silent = false, mouse = false) => {
   try {
-    const primaryDisplay = await getPrimaryDisplay();
+
     if (!silent) {
       emitter.emit(events.screenCapture.start, {
         scale,
@@ -51,21 +72,35 @@ const captureAndResize = async (scale = 1, silent = false, mouse = false) => {
 
     await screenshot({ filename: step1, format: "png" });
 
-    // Fetch the mouse position
-    const mousePos = robot.getMousePos();
+    let sharpInstance;
+    if (config.TD_VM) {
+
+      // resize to 1:1 px ratio
+      sharpInstance = sharp(step1).resize(
+        Math.floor(1024 * scale),
+        Math.floor(768 * scale),
+      );
+
+    } else {
 
-    // Location of cursor image
-    const cursorPath = path.join(__dirname, "resources", "cursor.png");
+      const primaryDisplay = await getPrimaryDisplay();
+      
+      sharpInstance = sharp(step1).resize(
+        Math.floor(primaryDisplay.currentResX * scale),
+        Math.floor(primaryDisplay.currentResY * scale),
+      );
 
-    // resize to 1:1 px ratio
-    const sharpInstance = sharp(step1).resize(
-      Math.floor(primaryDisplay.currentResX * scale),
-      Math.floor(primaryDisplay.currentResY * scale),
-    );
+      // Fetch the mouse position
+      const mousePos = robot.getMousePos();
+
+      // Location of cursor image
+      const cursorPath = path.join(__dirname, "resources", "cursor.png");
+
+      if (mouse) {
+        // composite the mouse image ontop
+        sharpInstance.composite([{ input: cursorPath, left: mousePos.x, top: mousePos.y }]);
+      }
 
-    if (mouse) {
-      // composite the mouse image ontop
-      sharpInstance.composite([{ input: cursorPath, left: mousePos.x, top: mousePos.y }]);
     }
 
     await sharpInstance.toFile(step2);
@@ -115,7 +150,7 @@ const platform = () => {
 // Import get-windows using dynamic import for ES module compatibility
 let activeWindowFn = null;
 const initializeActiveWindow = async () => {
-  if (!activeWindowFn) {
+  if (!activeWindowFn && !config.TD_VM) {
     const { activeWindow } = await import('get-windows');
     activeWindowFn = activeWindow;
   }
@@ -124,17 +159,27 @@ const initializeActiveWindow = async () => {
 
 // this is the focused window
 const activeWin = async () => {
-  try {
-    const activeWindow = await initializeActiveWindow();
-    return await activeWindow();
-  } catch (error) {
-    logger.error('Error getting active window: %s', error);
-    return null;
+  
+  if (config.TD_VM) { 
+    
+  return "error getting active window, proceed normally";
+
+  } else {
+
+    try {
+      const activeWindow = await initializeActiveWindow();
+      return await activeWindow();
+    } catch (error) {
+      logger.error('Error getting active window: %s', error);
+      return null;
+    }
+
   }
 };
 
 const getMousePosition = async () => {
-  return await robot.getMousePos();
+  // @todo vm does expose mouse position, add it back
+  return config.TD_VM ? await robot.getMousePos() : null;
 };
 
 module.exports = {

package/lib/websockets.js

@@ -0,0 +1,78 @@
+const WebSocket = require('ws');
+
+class WebSocketServerSingleton {
+  constructor() {
+    if (!WebSocketServerSingleton.instance) {
+      this.wss = new WebSocket.Server({ port: 8080 }, () => {
+      });
+
+      this.clients = new Set();
+      this.eventListeners = new Map();
+
+      this.wss.on('error', (error) => {
+        console.error('WebSocket server error:', error);
+      });
+
+      this.wss.on('connection', (ws) => {
+
+        console.log('Client connected');
+        this.clients.add(ws);
+
+        ws.on('message', (message) => {
+          try {
+            const parsedMessage = JSON.parse(message);
+            if (parsedMessage.event) {
+              this.triggerEvent(parsedMessage.event, parsedMessage);
+            } else {
+              console.error('Parsed message does not contain an event property');
+            }
+          } catch (error) {
+            console.error('Error parsing message:', error);
+          }
+        });
+
+        ws.on('close', () => {
+          this.clients.delete(ws);
+          console.log('Client disconnected');
+        });
+
+        ws.on('error', (error) => {
+          console.error('WebSocket error:', error);
+        });
+      });
+
+      WebSocketServerSingleton.instance = this;
+    }
+
+    return WebSocketServerSingleton.instance;
+  }
+
+  addEventListener(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, []);
+    }
+    this.eventListeners.get(event).push(listener);
+  }
+
+  triggerEvent(event, data) {
+    if (this.eventListeners.has(event)) {
+      for (const listener of this.eventListeners.get(event)) {
+        listener(data);
+      }
+    }
+  }
+
+  sendToClients(event, message) {
+    const data = JSON.stringify({ event, message });
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    }
+  }
+}
+
+const instance = new WebSocketServerSingleton();
+Object.freeze(instance);
+
+module.exports = instance;