@testdriverai/runner 7.8.0-canary.10

package/lib/pyautogui-local.js

@@ -0,0 +1,229 @@
+/**
+ * pyautogui-local.js — PyAutoGUI WebSocket bridge (cross-platform)
+ *
+ * Spawns pyautogui-cli.py (a WebSocket server on port 8765) as a child
+ * process, then connects to it as a WebSocket client. All input automation
+ * is handled by PyAutoGUI — no nutjs dependency needed.
+ *
+ * Same interface as the old NutJSBridge:
+ *   - extends EventEmitter (emits 'log', 'error')
+ *   - start() — spawn pyautogui-cli.py + connect WS
+ *   - stop()  — close WS + kill process
+ *   - sendCommand(command, data) → Promise<result>
+ *
+ * Protocol (over WebSocket JSON):
+ *   Request:  { "command": "click", "data": { "x": 100, "y": 200 } }
+ *   Response: { "result": true, "originalData": { ... } }
+ *   Error:    { "error": "message" }
+ */
+const { EventEmitter } = require('events');
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const WebSocket = require('ws');
+
+const WS_PORT = 8765;
+const WS_URL = `ws://127.0.0.1:${WS_PORT}`;
+const MAX_CONNECT_ATTEMPTS = 30;       // 30 × 500 ms = 15 s max wait
+const CONNECT_RETRY_DELAY_MS = 500;
+
+class PyAutoGUIBridge extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this._process = null;
+    this._ws = null;
+    this._requestId = 0;
+    this._pending = new Map(); // id → { resolve, reject, timer }
+    this._timeout = options.commandTimeout || 30000; // 30 s default
+    this.started = false;
+  }
+
+  // ── start: spawn python server, wait for WS, connect ──────────────
+
+  async start() {
+    // Find pyautogui-cli.py
+    const scriptPaths = [
+      path.join(__dirname, '..', 'pyautogui-cli.py'),
+      path.join(__dirname, '..', 'scripts', 'pyautogui-cli.py'),
+      'pyautogui-cli.py',
+    ];
+
+    let scriptPath = null;
+    for (const p of scriptPaths) {
+      if (fs.existsSync(p)) {
+        scriptPath = p;
+        break;
+      }
+    }
+
+    if (!scriptPath) {
+      throw new Error(
+        'pyautogui-cli.py not found. Place it in the runner directory.'
+      );
+    }
+
+    this.emit('log', `Starting PyAutoGUI server: ${scriptPath}`);
+
+    // Determine python command — "python3" on Linux/macOS, "python" on Windows
+    const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
+
+    this._process = spawn(pythonCmd, [scriptPath], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    // Forward stderr as log events
+    this._process.stderr.on('data', (data) => {
+      const msg = data.toString().trim();
+      if (msg) this.emit('log', `[pyautogui] ${msg}`);
+    });
+
+    this._process.stdout.on('data', (data) => {
+      const msg = data.toString().trim();
+      if (msg) this.emit('log', `[pyautogui] ${msg}`);
+    });
+
+    this._process.on('error', (err) => {
+      this.emit('error', err);
+    });
+
+    this._process.on('exit', (code) => {
+      this.emit('log', `PyAutoGUI server exited (code=${code})`);
+      this.started = false;
+      this._rejectAll(`PyAutoGUI process exited (code=${code})`);
+    });
+
+    // Wait for WS server to become reachable
+    await this._waitForServer();
+
+    // Connect WebSocket
+    await this._connect();
+
+    this.started = true;
+    this.emit('log', 'PyAutoGUI bridge ready');
+  }
+
+  // ── sendCommand ────────────────────────────────────────────────────
+
+  async sendCommand(command, data) {
+    if (!this.started || !this._ws || this._ws.readyState !== WebSocket.OPEN) {
+      throw new Error('PyAutoGUI WebSocket not connected');
+    }
+
+    const id = ++this._requestId;
+    // Use per-command timeout if provided (e.g. exec with custom timeout), otherwise default
+    const timeoutMs = (data && data.timeout && data.timeout > 0)
+      ? data.timeout + 5000  // Add 5s buffer over the command's own timeout
+      : this._timeout;
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._pending.delete(id);
+        reject(new Error(`PyAutoGUI command timed out: ${command} (${timeoutMs}ms)`));
+      }, timeoutMs);
+
+      this._pending.set(id, { resolve, reject, timer });
+
+      const payload = JSON.stringify({ command, data, _id: id });
+      this._ws.send(payload, (err) => {
+        if (err) {
+          clearTimeout(timer);
+          this._pending.delete(id);
+          reject(new Error(`WS send failed: ${err.message}`));
+        }
+      });
+    });
+  }
+
+  // ── stop ───────────────────────────────────────────────────────────
+
+  stop() {
+    this.started = false;
+
+    if (this._ws) {
+      try { this._ws.close(); } catch {}
+      this._ws = null;
+    }
+
+    if (this._process) {
+      try { this._process.kill(); } catch {}
+      this._process = null;
+    }
+
+    this._rejectAll('PyAutoGUI stopped');
+  }
+
+  // ── internal helpers ───────────────────────────────────────────────
+
+  _rejectAll(reason) {
+    for (const [, pending] of this._pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(reason));
+    }
+    this._pending.clear();
+  }
+
+  /** Poll until the WS server is accepting connections */
+  async _waitForServer() {
+    for (let i = 0; i < MAX_CONNECT_ATTEMPTS; i++) {
+      try {
+        await new Promise((resolve, reject) => {
+          const ws = new WebSocket(WS_URL);
+          ws.once('open', () => { ws.close(); resolve(); });
+          ws.once('error', reject);
+        });
+        return; // server is up
+      } catch {
+        await new Promise(r => setTimeout(r, CONNECT_RETRY_DELAY_MS));
+      }
+    }
+    throw new Error(`PyAutoGUI WS server did not start within ${MAX_CONNECT_ATTEMPTS * CONNECT_RETRY_DELAY_MS / 1000}s`);
+  }
+
+  /** Open persistent WebSocket connection */
+  _connect() {
+    return new Promise((resolve, reject) => {
+      this._ws = new WebSocket(WS_URL);
+
+      this._ws.on('open', () => {
+        this.emit('log', `Connected to PyAutoGUI WS at ${WS_URL}`);
+        resolve();
+      });
+
+      this._ws.on('message', (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString());
+
+          // The pyautogui-cli.py server doesn't echo _id back, so we
+          // resolve the oldest pending request (FIFO). Commands are serial
+          // from the runner's perspective.
+          if (this._pending.size > 0) {
+            const [id, pending] = this._pending.entries().next().value;
+            clearTimeout(pending.timer);
+            this._pending.delete(id);
+
+            if (msg.error) {
+              pending.reject(new Error(msg.error));
+            } else {
+              pending.resolve(msg.result);
+            }
+          }
+        } catch (err) {
+          this.emit('log', `Non-JSON WS message: ${raw}`);
+        }
+      });
+
+      this._ws.on('close', () => {
+        this.emit('log', 'PyAutoGUI WS disconnected');
+        this._rejectAll('WebSocket closed');
+      });
+
+      this._ws.on('error', (err) => {
+        this.emit('error', err);
+        if (!this.started) reject(err);
+      });
+    });
+  }
+}
+
+module.exports = { PyAutoGUIBridge };

package/network.ps1

@@ -0,0 +1,18 @@
+# Get cumulative total bytes sent and received for each network interface
+$networkInterfaces = Get-WmiObject -Query "SELECT Name, BytesReceivedPerSec, BytesSentPerSec FROM Win32_PerfRawData_Tcpip_NetworkInterface"
+
+# Initialize counters
+$totalBytesSent = 0
+$totalBytesReceived = 0
+
+# Sum up the cumulative bytes sent and received for all interfaces
+foreach ($interface in $networkInterfaces) {
+    $totalBytesSent += $interface.BytesSentPerSec
+    $totalBytesReceived += $interface.BytesReceivedPerSec
+}
+
+# Calculate the overall total bytes transferred
+$totalNetworkBytes = $totalBytesSent + $totalBytesReceived
+
+# Output results in JSON format for parsing in Node.js
+Write-Output "{`"totalBytesSent`": $totalBytesSent, `"totalBytesReceived`": $totalBytesReceived, `"totalNetworkBytes`": $totalNetworkBytes}"

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@testdriverai/runner",
+  "version": "7.8.0-canary.10",
+  "description": "TestDriver Runner - Ably-based remote automation agent with Node.js automation",
+  "main": "index.js",
+  "bin": {
+    "testdriver-runner": "./index.js",
+    "testdriver-sandbox-agent": "./sandbox-agent.js"
+  },
+  "files": [
+    "index.js",
+    "sandbox-agent.js",
+    "lib/",
+    "scripts-desktop/",
+    "entrypoint.sh",
+    "45-allow-colord.pkla",
+    "Xauthority",
+    "wallpaper.png",
+    "focusWindow.ps1",
+    "getActiveWindow.ps1",
+    "network.ps1"
+  ],
+  "scripts": {
+    "start": "node index.js",
+    "test": "node test/local-test.mjs",
+    "test:packer": "cd ../sdk && npx vitest run --config vitest.runner.config.mjs runner/packer/test/packer-ami.test.mjs",
+    "test:packer:skip-build": "cd ../sdk && SKIP_PACKER_BUILD=true npx vitest run --config vitest.runner.config.mjs runner/packer/test/packer-ami.test.mjs",
+    "test:auto-upgrade": "cd ../sdk && npx vitest run --config vitest.runner.config.mjs runner/packer/test/auto-upgrade.test.mjs"
+  },
+  "dependencies": {
+    "@sentry/node": "^10.37.0",
+    "ably": "^2.6.0",
+    "dashcam": "beta",
+    "dashcam-chrome": "*",
+    "dotenv": "^16.0.0",
+    "pngjs": "^7.0.0",
+    "sharp": "^0.33.0",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "e2b": "^2.12.1"
+  }
+}

package/sandbox-agent.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+/**
+ * sandbox-agent.js — Ably-based sandbox automation agent
+ *
+ * Runs on the sandbox machine (Windows EC2 instance or any remote host).
+ * Replaces pyautogui-cli.py as the entry point for remote-controlled
+ * desktop automation.
+ *
+ * Flow:
+ *   1. Reads Ably credentials from /tmp/testdriver-agent.json (Linux)
+ *      or C:\Windows\Temp\testdriver-agent.json (Windows)
+ *   2. Initializes the Automation module (@nut-tree/nut-js)
+ *   3. Connects to Ably and subscribes to command channel
+ *   4. Executes commands and publishes responses
+ *
+ * The API writes the credentials file during sandbox provisioning
+ * (via SSM SendCommand or userdata script).
+ *
+ * Config file format:
+ *   {
+ *     "sandboxId": "abc123",
+ *     "ably": {
+ *       "token": "...",
+ *       "channel": "testdriver:env:team:sandbox"
+ *     }
+ *   }
+ *
+ * Environment variables (override config file):
+ *   SANDBOX_ID      — sandbox ID
+ *   ABLY_TOKEN      — Ably auth token (JSON string)
+ *   ABLY_CHANNEL    — Ably session channel name
+ *   CONFIG_PATH     — path to config file (overrides default)
+ */
+require('dotenv').config();
+const Sentry = require('@sentry/node');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { Automation } = require('./lib/automation');
+const { AblyService } = require('./lib/ably-service');
+
+/**
+ * Get the local runner version from package.json.
+ */
+function getLocalVersion() {
+  try {
+    if (process.env.RUNNER_VERSION) return process.env.RUNNER_VERSION;
+    const pkg = require('./package.json');
+    return pkg.version;
+  } catch { return null; }
+}
+
+const IS_WINDOWS = process.platform === 'win32';
+
+// ─── Load config ─────────────────────────────────────────────────────────────
+
+function loadConfigFromFile() {
+  const configPath = process.env.CONFIG_PATH || (
+    IS_WINDOWS
+      ? 'C:\\Windows\\Temp\\testdriver-agent.json'
+      : '/tmp/testdriver-agent.json'
+  );
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  let raw = fs.readFileSync(configPath, 'utf-8');
+  // Strip UTF-8 BOM if present (PowerShell 5.1 Set-Content -Encoding UTF8 adds it)
+  if (raw.charCodeAt(0) === 0xFEFF) raw = raw.slice(1);
+  return JSON.parse(raw);
+}
+
+/**
+ * Wait for the config file to appear on disk.
+ * The API writes it via SSM after the instance is running, so the agent
+ * (started at logon by the scheduled task) may boot before it exists.
+ */
+async function waitForConfig(timeoutMs) {
+  if (!timeoutMs) timeoutMs = 300000; // 5 minutes
+  const pollInterval = 2000; // 2s
+  const configPath = process.env.CONFIG_PATH || (
+    IS_WINDOWS
+      ? 'C:\\Windows\\Temp\\testdriver-agent.json'
+      : '/tmp/testdriver-agent.json'
+  );
+
+  const deadline = Date.now() + timeoutMs;
+  log('Waiting for config file: ' + configPath);
+
+  while (Date.now() < deadline) {
+    var cfg = loadConfigFromFile();
+    if (cfg && cfg.ably && cfg.ably.token) {
+      log('Config file loaded');
+      return cfg;
+    }
+    await new Promise(function (resolve) { setTimeout(resolve, pollInterval); });
+  }
+
+  throw new Error(
+    'Config file not found after ' + (timeoutMs / 1000) + 's: ' + configPath + '\n' +
+    'The API must provision this file during sandbox creation.\n' +
+    'Or set ABLY_TOKEN and ABLY_CHANNEL environment variables.'
+  );
+}
+
+function loadConfig() {
+  // Try environment variables first
+  if (process.env.ABLY_TOKEN && process.env.ABLY_CHANNEL) {
+    return {
+      sandboxId: process.env.SANDBOX_ID || 'agent-' + Date.now(),
+      ably: {
+        token: JSON.parse(process.env.ABLY_TOKEN),
+        channel: process.env.ABLY_CHANNEL,
+      },
+    };
+  }
+
+  // Synchronous load (for backward compat when called from tests / env-var mode)
+  var cfg = loadConfigFromFile();
+  if (cfg) return cfg;
+
+  throw new Error(
+    'Config file not found.\n' +
+    'The API must provision this file during sandbox creation.\n' +
+    'Or set ABLY_TOKEN and ABLY_CHANNEL environment variables.'
+  );
+}
+
+// ─── Write connection info (for compatibility with pyautogui-cli.py) ─────────
+
+function writeConnectionInfo(sandboxId) {
+  const ip = getLocalIP();
+  const info = {
+    agent: 'testdriver-sandbox-agent',
+    sandboxId,
+    transport: 'ably',
+    ip,
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+  };
+
+  const outputPath = IS_WINDOWS
+    ? 'C:\\Windows\\Temp\\testdriver-agent-status.json'
+    : '/tmp/testdriver-agent-status.json';
+
+  try {
+    fs.writeFileSync(outputPath, JSON.stringify(info, null, 2));
+  } catch (err) {
+    console.warn(`[agent] Failed to write status file: ${err.message}`);
+  }
+}
+
+function getLocalIP() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return '127.0.0.1';
+}
+
+// ─── Logging ─────────────────────────────────────────────────────────────────
+
+const logFile = IS_WINDOWS
+  ? 'C:\\Windows\\Temp\\testdriver-agent.log'
+  : '/tmp/testdriver-agent.log';
+
+function log(msg) {
+  const line = `[${new Date().toISOString()}] ${msg}`;
+  console.log(line);
+  try {
+    fs.appendFileSync(logFile, line + '\n');
+  } catch { }
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+async function main() {
+  log('TestDriver Sandbox Agent starting...');
+  log(`Runner version: ${getLocalVersion() || 'unknown'}`);
+
+  // Wait for config file — the API writes it via SSM after the instance boots.
+  // The SSM command also updates the runner (via S3 for non-stable envs, or npm
+  // for stable) BEFORE writing the config, so by this point we're up to date.
+  const config = await waitForConfig(300000);
+
+  // Initialize Sentry for distributed tracing
+  const sentryDsn = process.env.SENTRY_DSN || config.sentryDsn || 'https://452bd5a00dbd83a38ee8813e11c57694@o4510262629236736.ingest.us.sentry.io/4510480443637760';
+  if (sentryDsn) {
+    const { version } = require('./package.json');
+    Sentry.init({
+      dsn: sentryDsn,
+      // Use tracesSampler to inherit parent sampling decisions
+      // This ensures SDK → API → Runner traces stay connected
+      tracesSampler: (samplingContext) => {
+        // Inherit parent sampling decision for distributed tracing continuity
+        if (samplingContext.parentSampled !== undefined) {
+          return samplingContext.parentSampled;
+        }
+        // Sample all runner-initiated traces (shouldn't happen often)
+        return 1.0;
+      },
+      environment: process.env.NODE_ENV || 'production',
+      release: version,
+      serverName: os.hostname(),
+    });
+    log('Sentry initialized');
+  }
+  log(`Sandbox ID: ${config.sandboxId}`);
+  log(`Transport: Ably`);
+
+  // Initialize automation
+  const automation = new Automation({
+    sandboxId: config.sandboxId,
+    apiRoot: config.apiRoot,
+    apiKey: config.apiKey,
+  });
+  log('Automation module initialized');
+
+  // Write connection info
+  writeConnectionInfo(config.sandboxId);
+
+  // Connect to Ably
+  const ablyService = new AblyService({
+    automation,
+    ablyToken: config.ably.token,
+    channel: config.ably.channel || (config.ably.channels && config.ably.channels.commands),
+    sandboxId: config.sandboxId,
+    apiRoot: config.apiRoot,
+    apiKey: config.apiKey,
+    updateInfo: null, // sandbox-agent doesn't do self-update checks
+  });
+
+  ablyService.on('log', (msg) => log(`[ably] ${msg}`));
+  ablyService.on('error', (err) => log(`[ably] ERROR: ${err.message}`));
+
+  await ablyService.connect();
+  log('Agent ready — listening for commands via Ably');
+
+  // ─── Graceful shutdown ────────────────────────────────────────────
+
+  const shutdown = async () => {
+    log('Shutting down...');
+    await ablyService.close();
+    automation.cleanup();
+    await Sentry.close(2000);
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // Keep process alive
+  setInterval(() => { }, 60000);
+}
+
+main().catch((err) => {
+  log(`Fatal error: ${err.message}`);
+  console.error(err);
+  process.exit(1);
+});

package/scripts-desktop/control_window.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+# Check and print each argument
+echo "Number of arguments: $#"
+for i in "${!@}"; do
+    echo "Arg[$i]: ${!i}"
+done
+
+# Existing logic
+if [ "$#" -lt 2 ]; then
+    echo "Error: Not enough arguments supplied."
+    echo "Usage: ./control_window.sh <WindowTitle> <Action>"
+    echo "Actions: Minimize, Restore, Focus"
+    exit 1
+fi
+
+# Assign arguments
+WINDOW_TITLE="$1"
+ACTION="$2"
+
+# Debug output
+echo "=== Debugging Arguments ==="
+echo "WindowTitle: '$WINDOW_TITLE'"
+echo "Action: '$ACTION'"
+echo "==========================="
+
+# Validate action
+if [[ "$ACTION" != "Minimize" && "$ACTION" != "Restore" && "$ACTION" != "Focus" ]]; then
+    echo "Invalid action. Valid actions are: Minimize, Restore, Focus."
+    exit 1
+fi
+
+# Search for windows matching the title
+WINDOW_IDS=$(wmctrl -lx | grep -i "$WINDOW_TITLE" | awk '{print $1}')
+
+if [ -z "$WINDOW_IDS" ]; then
+    echo "No window found with title containing '$WINDOW_TITLE'"
+    exit 1
+fi
+
+# Perform action on each matching window
+for WIN_ID in $WINDOW_IDS; do
+    WINDOW_NAME=$(xprop -id "$WIN_ID" WM_NAME | cut -d'"' -f2)
+    echo "Found window: '$WINDOW_NAME'"
+
+    case "$ACTION" in
+        Minimize)
+            xdotool windowminimize "$WIN_ID"
+            echo "Minimized '$WINDOW_NAME'"
+            ;;
+        Restore|Focus)
+            # Raise and focus window (xdotool will automatically un-minimize if minimized)
+            xdotool windowmap "$WIN_ID"
+            xdotool windowactivate "$WIN_ID"
+            echo "Brought '$WINDOW_NAME' to the foreground."
+            ;;
+    esac
+done
+

package/scripts-desktop/launch_chrome.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+jumpapp google-chrome --disable-fre --no-default-browser-check --no-first-run $@

package/scripts-desktop/launch_chrome_for_testing.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# Resolve dashcam-chrome extension path from the runner package or global install
+DASHCAM_CHROME_PATH=$(node -e "try{console.log(require.resolve('dashcam-chrome').replace(/\/[^/]*$/,''))}catch{}" 2>/dev/null)
+if [ -z "$DASHCAM_CHROME_PATH" ]; then
+  DASHCAM_CHROME_PATH="/usr/local/lib/node_modules/dashcam-chrome"
+fi
+
+jumpapp chrome-for-testing --remote-debugging-port=9222 --disable-fre --no-default-browser-check --no-first-run --load-extension="$DASHCAM_CHROME_PATH" $@