@testdriverai/runner 7.8.0-canary.15 → 7.8.0-test.39

package/README.md

@@ -1,187 +1 @@
-# @testdriverai/runner
-
-The TestDriver Runner is a desktop automation agent that connects to the TestDriver API via [Ably](https://ably.com/) realtime messaging. It receives commands from the SDK (click, type, find, screenshot, etc.) and executes them on a desktop environment using PyAutoGUI and Sharp.
-
-## Architecture
-
-The runner operates in two modes:
-
-| Mode | Binary | Use Case |
-|------|--------|----------|
-| **Presence Runner** | `testdriver-runner` | Self-registers with the API, enters Ably presence, and waits for SDK sessions to claim it. Used for persistent/pooled runners. |
-| **Sandbox Agent** | `testdriver-sandbox-agent` | Reads pre-provisioned credentials from a config file or environment variables. Used for ephemeral cloud sandboxes (E2B, AWS EC2). |
-
-## Prerequisites
-
-### System Requirements
-
-- **Node.js** >= 18
-- **Python 3** with `pyautogui` and `Pillow`
-- A desktop environment (physical display, VNC, or virtual framebuffer)
-
-### Desktop Environment (Linux)
-
-```bash
-# Virtual display + desktop
-apt-get install -y xvfb xfce4 xfce4-terminal dbus-x11 wmctrl
-
-# VNC access (optional, for debugging)
-apt-get install -y tigervnc-standalone-server novnc websockify
-
-# Python automation
-pip3 install pyautogui python-xlib Pillow
-```
-
-### Desktop Environment (Windows)
-
-- Standard Windows desktop (RDP or console session)
-- Python 3 with `pyautogui` and `Pillow`:
-  ```powershell
-  pip install pyautogui Pillow
-  ```
-
-### Chrome
-
-Google Chrome or Chrome for Testing must be installed and accessible on `PATH`.
-
-## Installation
-
-### From the TestDriver API (recommended)
-
-```bash
-curl -fSL -H "x-api-key: $TD_API_KEY" \
-  https://api.testdriver.ai/api/v7/runner/download \
-  -o /tmp/testdriverai-runner.tgz && \
-  npm install -g /tmp/testdriverai-runner.tgz && \
-  rm /tmp/testdriverai-runner.tgz
-```
-
-### From source (development)
-
-```bash
-cd runner
-npm install
-npm start
-```
-
-## Quick Start
-
-### Presence Runner
-
-```bash
-export TD_API_KEY="your-team-api-key"
-testdriver-runner
-```
-
-The runner will:
-1. Register with the API at `/api/v7/runner/register`
-2. Receive an Ably token and channel
-3. Enter presence on the runner channel
-4. Wait for SDK sessions to claim it
-
-### Sandbox Agent
-
-The sandbox agent reads credentials from a JSON config file that the API provisions (via SSM, cloud-init, etc.):
-
-**Linux:** `/tmp/testdriver-agent.json`
-**Windows:** `C:\Windows\Temp\testdriver-agent.json`
-
-```json
-{
-  "sandboxId": "sb-abc123",
-  "ably": {
-    "token": "ably-token-string",
-    "channel": "testdriver:env:team:sandbox"
-  },
-  "apiRoot": "https://api.testdriver.ai",
-  "apiKey": "team-api-key"
-}
-```
-
-Start the agent (it will wait up to 5 minutes for the config file to appear):
-
-```bash
-testdriver-sandbox-agent
-```
-
-Or pass credentials via environment variables instead:
-
-```bash
-export SANDBOX_ID="my-sandbox"
-export ABLY_TOKEN='{"token":"..."}'
-export ABLY_CHANNEL="testdriver:env:team:sandbox"
-testdriver-sandbox-agent
-```
-
-## Environment Variables
-
-### Required
-
-| Variable | Description |
-|----------|-------------|
-| `TD_API_KEY` | Team API key (presence runner mode) |
-
-### Optional
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `TD_API_ROOT` | Per `TD_ENV` | API server URL |
-| `TD_ENV` | `stable` | Environment (`dev` / `test` / `canary` / `stable`) |
-| `TD_RUNNER_ID` | Auto-generated UUID | Fixed runner identifier |
-| `TD_RUNNER_SINGLE` | `false` | Exit after one session |
-| `TD_RUNNER_OS` | Auto-detected | OS capability advertised to API |
-| `TD_VNC_URL` | Auto-detected | Public VNC URL override |
-| `TD_NOVNC_PORT` | Auto-detected | noVNC WebSocket proxy port |
-| `SANDBOX_ID` | Auto-generated | Sandbox identifier (agent mode) |
-| `ABLY_TOKEN` | From config file | Ably auth token JSON (agent mode) |
-| `ABLY_CHANNEL` | From config file | Ably channel name (agent mode) |
-| `CONFIG_PATH` | `/tmp/testdriver-agent.json` | Config file path override (agent mode) |
-| `SCREEN_WIDTH` | `1366` | Virtual display width (Linux) |
-| `SCREEN_HEIGHT` | `768` | Virtual display height (Linux) |
-| `DISPLAY` | `:0` | X11 display (Linux) |
-
-## Logs
-
-| Platform | Runner Log | Agent Log |
-|----------|-----------|-----------|
-| Linux/macOS | `/tmp/testdriver-runner.log` | `/tmp/testdriver-agent.log` |
-| Windows | `C:\Windows\Temp\testdriver-runner.log` | `C:\Windows\Temp\testdriver-agent.log` |
-
-## Desktop Scripts
-
-Helper scripts in `scripts-desktop/` for managing the Linux desktop environment:
-
-| Script | Purpose |
-|--------|---------|
-| `start-desktop.sh` | Starts Xvfb, XFCE, D-Bus, disables screen blanking |
-| `launch_chrome.sh` | Launches Chrome with standard flags |
-| `launch_chrome_for_testing.sh` | Launches Chrome for Testing with remote debugging (port 9222) |
-| `control_window.sh` | Window management (minimize, restore, focus) via wmctrl |
-
-## Deployment
-
-### AWS AMI (Packer)
-
-See `packer/` for Packer templates that build AMIs with the runner pre-installed. The AMI includes the full desktop stack, Chrome, Python, and the runner.
-
-### E2B Sandboxes
-
-The E2B template installs the runner in a Dockerfile. See `sdk/setup/e2b/` for the recommended setup.
-
-### Docker
-
-```bash
-TD_API_KEY=your-key docker compose up --build
-```
-
-## Updating
-
-Re-download and reinstall:
-
-```bash
-curl -fSL -H "x-api-key: $TD_API_KEY" \
-  https://api.testdriver.ai/api/v7/runner/download \
-  -o /tmp/testdriverai-runner.tgz && \
-  npm install -g /tmp/testdriverai-runner.tgz && \
-  rm /tmp/testdriverai-runner.tgz
-```
+# runner

package/lib/ably-service.js

@@ -170,7 +170,6 @@ class AblyService extends EventEmitter {
         callback(null, this._ablyToken);
       },
       clientId: this._clientId,
-      echoMessages: false,              // don't receive our own published messages
       disconnectedRetryTimeout: 5000,   // retry reconnect every 5s (default 15s)
       suspendedRetryTimeout: 15000,     // retry from suspended every 15s (default 30s)
       logHandler: (msg) => {
@@ -231,7 +230,7 @@ class AblyService extends EventEmitter {
         level: 'info',
         message,
         timestamp: Date.now(),
-      }).catch(() => { }); // best-effort
+      }).catch(() => {}); // best-effort
     });
     this._automation.on('warn', (message) => {
       if (!this._debugMode) return;
@@ -240,7 +239,7 @@ class AblyService extends EventEmitter {
         level: 'warn',
         message,
         timestamp: Date.now(),
-      }).catch(() => { }); // best-effort
+      }).catch(() => {}); // best-effort
     });
     this._automation.on('error', (message) => {
       if (!this._debugMode) return;
@@ -249,24 +248,21 @@ class AblyService extends EventEmitter {
         level: 'error',
         message: typeof message === 'string' ? message : message.message || String(message),
         timestamp: Date.now(),
-      }).catch(() => { }); // best-effort
+      }).catch(() => {}); // best-effort
     });
 
-    // Forward exec streaming chunks to SDK with rate limiting.
-    // Exec output can produce many chunks rapidly (e.g. verbose commands);
-    // throttle to avoid hitting Ably's 50 msg/sec per-connection limit.
-    this._execOutputLastTime = 0;
-    this._execOutputMinIntervalMs = 50; // 20 msg/sec max for exec.output
-    this._execOutputQueue = [];         // queued chunks waiting to send
-    this._execOutputDraining = false;
-
+    // Forward exec streaming chunks to SDK
     this._automation.on('exec.output', ({ requestId, chunk }) => {
-      this._execOutputQueue.push({ requestId, chunk });
-      this._drainExecOutputQueue();
+      this._sendResponse({
+        type: 'exec.output',
+        requestId,
+        chunk,
+        timestamp: Date.now(),
+      }).catch(() => {}); // best-effort, don't block exec
     });
 
-    // Subscribe to commands — save subscription ref for historyBeforeSubscribe()
-    this._onCommandMsg = async (msg) => {
+    // Subscribe to commands
+    this._sessionChannel.subscribe('command', async (msg) => {
       const message = msg.data;
       if (!message) return;
 
@@ -275,9 +271,6 @@ class AblyService extends EventEmitter {
 
       this.emit('log', `Command received: ${type} (requestId=${requestId})`);
 
-      // Stop re-publishing runner.ready once we get the first command
-      this._stopReadySignal();
-
       // Per-command timeout: use message.timeout if provided, else default 120s
       // Prevents hanging forever if screenshot capture or S3 upload stalls
       const commandTimeout = (message.timeout && message.timeout > 0)
@@ -300,7 +293,7 @@ class AblyService extends EventEmitter {
 
           // Screenshots are now handled by automation.js (returns { s3Key })
           // No need to check type here - just pass through the result
-
+          
           await this._sendResponse({
             requestId,
             type: `${type}.reply`,
@@ -331,8 +324,7 @@ class AblyService extends EventEmitter {
       } else {
         await executeCommand();
       }
-    };
-    this._commandSubscription = await this._sessionChannel.subscribe('command', this._onCommandMsg);
+    });
 
     // ─── Ably connection state monitoring → Sentry ─────────────────────────
     this._ably.connection.on((stateChange) => {
@@ -415,27 +407,11 @@ class AblyService extends EventEmitter {
             Sentry.captureException(err);
           });
         }
-
-        // Detect discontinuity: channel re-attached but message continuity was lost.
-        // Use historyBeforeSubscribe() on each subscription to recover missed messages.
-        if (current === 'attached' && stateChange.resumed === false && previous === 'attached') {
-          this.emit('log', `Ably channel [session]: DISCONTINUITY (resumed=false)${reasonMsg ? ' — ' + reasonMsg : ''}`);    
-
-          Sentry.withScope((scope) => {
-            scope.setTag('ably.client', 'runner');
-            scope.setTag('ably.channel', sessionCh.name);
-            scope.setTag('ably.issue', 'discontinuity');
-            scope.setFingerprint(['ably-channel-discontinuity', 'runner']);
-            Sentry.captureMessage('Ably channel discontinuity (runner)', 'warning');
-          });
-
-          this._recoverFromDiscontinuity();
-        }
       });
     }
 
-    // Subscribe to control messages — save subscription ref for historyBeforeSubscribe()
-    this._onControlMsg = async (msg) => {
+    // Subscribe to control messages
+    this._sessionChannel.subscribe('control', async (msg) => {
       const message = msg.data;
       if (!message) return;
 
@@ -454,15 +430,14 @@ class AblyService extends EventEmitter {
         this._debugMode = !!message.enabled;
         this.emit('log', `Debug mode ${this._debugMode ? 'enabled' : 'disabled'}`);
       }
-    };
-    this._controlSubscription = await this._sessionChannel.subscribe('control', this._onControlMsg);
+    });
 
     this.emit('log', 'Listening for commands on Ably');
 
     // Signal readiness to SDK — commands sent before this would be lost
     const readyPayload = {
       type: 'runner.ready',
-      os: process.platform === 'win32' ? 'windows' : 'linux',
+      os: 'windows',
       sandboxId: this._sandboxId,
       runnerVersion: getLocalVersion() || 'unknown',
       timestamp: Date.now(),
@@ -476,123 +451,6 @@ class AblyService extends EventEmitter {
     }
     await this._sessionChannel.publish('control', readyPayload);
     this.emit('log', 'Published runner.ready signal');
-
-    // Re-publish runner.ready every 3s for up to 60s.
-    // The SDK may connect after the first publish (race condition),
-    // and Ably channel history may not be enabled. Repeating ensures
-    // the SDK catches at least one live runner.ready message.
-    this._readyInterval = setInterval(async () => {
-      try {
-        readyPayload.timestamp = Date.now();
-        await this._sessionChannel.publish('control', readyPayload);
-        this.emit('log', 'Re-published runner.ready signal');
-      } catch (err) {
-        this.emit('log', `Failed to re-publish runner.ready: ${err.message}`);
-      }
-    }, 3000);
-
-    // Stop after 60s regardless
-    this._readyTimeout = setTimeout(() => {
-      this._stopReadySignal();
-    }, 60000);
-  }
-
-  /**
-   * Stop the repeated runner.ready signal (called on first command or after timeout).
-   */
-  _stopReadySignal() {
-    if (this._readyInterval) {
-      clearInterval(this._readyInterval);
-      this._readyInterval = null;
-    }
-    if (this._readyTimeout) {
-      clearTimeout(this._readyTimeout);
-      this._readyTimeout = null;
-    }
-  }
-
-  /**
-   * Drain the exec.output queue, respecting the rate limit interval.
-   * Coalesces queued chunks per-requestId into single messages to reduce
-   * message count when output arrives faster than we can send.
-   */
-  async _drainExecOutputQueue() {
-    if (this._execOutputDraining) return; // already draining
-    this._execOutputDraining = true;
-
-    try {
-      while (this._execOutputQueue.length > 0) {
-        // Rate limit: wait if needed
-        const now = Date.now();
-        const elapsed = now - this._execOutputLastTime;
-        if (elapsed < this._execOutputMinIntervalMs) {
-          await new Promise((resolve) => setTimeout(resolve, this._execOutputMinIntervalMs - elapsed));
-        }
-
-        // Coalesce all queued chunks for the same requestId
-        const batch = {};
-        while (this._execOutputQueue.length > 0) {
-          const { requestId, chunk } = this._execOutputQueue.shift();
-          if (!batch[requestId]) batch[requestId] = '';
-          batch[requestId] += chunk;
-        }
-
-        this._execOutputLastTime = Date.now();
-
-        // Send one message per requestId
-        for (const [requestId, chunk] of Object.entries(batch)) {
-          this._sendResponse({
-            type: 'exec.output',
-            requestId,
-            chunk,
-            timestamp: Date.now(),
-          }).catch(() => { }); // best-effort
-        }
-      }
-    } finally {
-      this._execOutputDraining = false;
-    }
-  }
-
-  /**
-   * Recover missed messages after a channel discontinuity.
-   * Uses historyBeforeSubscribe() on each subscription, which guarantees
-   * no gap between historical and live messages.  Each recovered message
-   * is dispatched through the same handler that processes live messages
-   * so that missed commands are actually executed.
-   */
-  async _recoverFromDiscontinuity() {
-    const subs = [
-      { name: 'command', sub: this._commandSubscription, handler: this._onCommandMsg },
-      { name: 'control', sub: this._controlSubscription, handler: this._onControlMsg },
-    ];
-    for (const { name, sub, handler } of subs) {
-      if (!sub) continue;
-      try {
-        this.emit('log', `Discontinuity recovery: fetching historyBeforeSubscribe for ${name}...`);
-        let page = await sub.historyBeforeSubscribe({ limit: 100 });
-        let recovered = 0;
-        while (page) {
-          for (const item of page.items) {
-            recovered++;
-            try {
-              if (handler) {
-                this.emit('log', `Replaying recovered ${name} message (requestId=${item.data && item.data.requestId || 'none'})`);
-                await handler(item);
-              }
-            } catch (replayErr) {
-              this.emit('log', `Error replaying recovered ${name} message: ${replayErr.message}`);
-              Sentry.captureException(replayErr);
-            }
-          }
-          page = page.hasNext() ? await page.next() : null;
-        }
-        this.emit('log', `Discontinuity recovery: replayed ${recovered} ${name} message(s) from gap`);
-      } catch (err) {
-        this.emit('log', `Discontinuity recovery failed for ${name}: ${err.message}`);
-        Sentry.captureException(err);
-      }
-    }
   }
 
   /**
@@ -653,8 +511,6 @@ class AblyService extends EventEmitter {
   async close() {
     this.emit('log', 'Closing Ably service...');
 
-    this._stopReadySignal();
-
     if (this._statsInterval) {
       clearInterval(this._statsInterval);
       this._statsInterval = null;
@@ -662,12 +518,12 @@ class AblyService extends EventEmitter {
 
     try {
       if (this._sessionChannel) this._sessionChannel.detach();
-    } catch { }
+    } catch {}
 
     if (this._ably) {
       try {
         this._ably.close();
-      } catch { }
+      } catch {}
       this._ably = null;
     }
 

package/lib/automation.js

@@ -45,10 +45,8 @@ const API_KEY = process.env.TD_API_KEY;
 // shell injection and escaping issues.
 
 const PYTHON = IS_WINDOWS ? 'python' : 'python3';
-// On Linux, ensure DISPLAY is set (use env var or fallback to :0)
-// The os.environ.get() preserves the parent's DISPLAY setting for E2B's :1 display
 const PY_IMPORT = IS_LINUX
-  ? "import os; os.environ.setdefault('DISPLAY', ':0'); import pyautogui, sys; pyautogui.FAILSAFE = False; "
+  ? "import os; os.environ['DISPLAY'] = ':0'; import pyautogui, sys; pyautogui.FAILSAFE = False; "
   : 'import pyautogui, sys; pyautogui.FAILSAFE = False; ';
 
 /**
@@ -527,14 +525,11 @@ class Automation extends EventEmitter {
         const timeout = Math.ceil((data.timeout || 300000) / 1000); // ms to seconds
         const requestId = data.requestId;
 
-        // Buffer stdout chunks to ~32KB before emitting over Ably.
+        // Buffer stdout chunks to ~16KB before emitting over Ably.
         // This reduces message count while keeping each message well under
-        // Ably's 64KB limit. 32KB leaves headroom for the JSON envelope +
-        // string escaping while halving the message count vs the previous
-        // 16KB size, helping avoid Ably's per-channel rate limit on verbose
-        // commands. The SDK accumulates these chunks and reconstructs the
-        // full stdout — the final response only carries returncode + stderr.
-        const CHUNK_FLUSH_SIZE = 32 * 1024; // 32KB
+        // Ably's 64KB limit. The SDK accumulates these chunks and reconstructs
+        // the full stdout — the final response only carries returncode + stderr.
+        const CHUNK_FLUSH_SIZE = 16 * 1024; // 16KB
         let chunkBuffer = '';
         const flushChunkBuffer = () => {
           if (chunkBuffer.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testdriverai/runner",
-  "version": "7.8.0-canary.15",
+  "version": "7.8.0-test.39",
   "description": "TestDriver Runner - Ably-based remote automation agent with Node.js automation",
   "main": "index.js",
   "bin": {

package/scripts-desktop/start-agent.sh

@@ -1,105 +0,0 @@
-#!/bin/bash
-# ─── TestDriver Sandbox Agent Startup ────────────────────────────────────────
-# Starts the sandbox-agent.js (Ably-based automation agent) inside the E2B
-# sandbox. This script is called by the API after writing the config file
-# to /tmp/testdriver-agent.json.
-#
-# This matches the Windows runner pattern: the agent runs locally on the
-# sandbox and executes commands via pyautogui (instead of @e2b/desktop RPC).
-#
-# Usage: bash /opt/testdriver-runner/scripts-desktop/start-agent.sh [&]
-#
-# Prerequisites:
-#   - Desktop environment running (start-desktop.sh completed)
-#   - Config file at /tmp/testdriver-agent.json with Ably credentials
-#   - Node.js installed
-#   - Runner installed at /opt/testdriver-runner
-
-set -e
-
-export DISPLAY="${DISPLAY:-:0}"
-export XAUTHORITY="${XAUTHORITY:-${HOME}/.Xauthority}"
-
-RUNNER_DIR="/opt/testdriver-runner"
-CONFIG_PATH="/tmp/testdriver-agent.json"
-LOG_FILE="/tmp/sandbox-agent.log"
-PID_FILE="/tmp/sandbox-agent.pid"
-
-log() {
-  echo "[$(date -Iseconds)] [start-agent] $1" | tee -a "$LOG_FILE"
-}
-
-# ─── Check if already running ─────────────────────────────────────────────────
-if [ -f "$PID_FILE" ]; then
-  existing_pid=$(cat "$PID_FILE")
-  if kill -0 "$existing_pid" 2>/dev/null; then
-    log "Agent already running (PID: $existing_pid), exiting"
-    exit 0
-  else
-    log "Stale PID file found, removing"
-    rm -f "$PID_FILE"
-  fi
-fi
-
-# ─── Verify prerequisites ─────────────────────────────────────────────────────
-if [ ! -d "$RUNNER_DIR" ]; then
-  log "ERROR: Runner not found at $RUNNER_DIR"
-  exit 1
-fi
-
-if [ ! -f "$RUNNER_DIR/sandbox-agent.js" ]; then
-  log "ERROR: sandbox-agent.js not found in $RUNNER_DIR"
-  exit 1
-fi
-
-if ! command -v node &> /dev/null; then
-  log "ERROR: Node.js not installed"
-  exit 1
-fi
-
-# ─── Wait for config file (with timeout) ─────────────────────────────────────
-# The API writes the config file before calling this script, but we add a
-# brief wait just in case there's any race condition.
-WAIT_TIMEOUT=30
-WAIT_INTERVAL=1
-elapsed=0
-
-log "Waiting for config file: $CONFIG_PATH"
-while [ ! -f "$CONFIG_PATH" ] && [ $elapsed -lt $WAIT_TIMEOUT ]; do
-  sleep $WAIT_INTERVAL
-  elapsed=$((elapsed + WAIT_INTERVAL))
-done
-
-if [ ! -f "$CONFIG_PATH" ]; then
-  log "ERROR: Config file not found after ${WAIT_TIMEOUT}s: $CONFIG_PATH"
-  exit 1
-fi
-
-log "Config file found"
-
-# ─── Start the agent ──────────────────────────────────────────────────────────
-log "Starting sandbox-agent.js..."
-log "DISPLAY=$DISPLAY, RUNNER_DIR=$RUNNER_DIR"
-
-# Run in background, redirect output to log file
-cd "$RUNNER_DIR"
-nohup node sandbox-agent.js >> "$LOG_FILE" 2>&1 &
-AGENT_PID=$!
-
-# Write PID file for process management
-echo "$AGENT_PID" > "$PID_FILE"
-
-log "Agent started (PID: $AGENT_PID)"
-log "Log file: $LOG_FILE"
-
-# Brief pause to catch any immediate startup errors
-sleep 2
-
-if kill -0 "$AGENT_PID" 2>/dev/null; then
-  log "Agent running successfully"
-  exit 0
-else
-  log "ERROR: Agent exited unexpectedly. Check $LOG_FILE for details"
-  tail -20 "$LOG_FILE" | while read line; do log "  $line"; done
-  exit 1
-fi