@testdriverai/runner 7.11.96-test → 7.11.97-canary

package/lib/ably-service.js

@@ -205,6 +205,7 @@ class AblyService extends EventEmitter {
     this._connected = false;
     this._statsInterval = null;
     this._closed = false; // set to true in close() to suppress post-close events
+    this._inFlight = new Map(); // requestId → { type, startedAt }; commands currently executing
   }
 
   /**
@@ -323,8 +324,17 @@ class AblyService extends EventEmitter {
 
       const requestId = message.requestId;
       const type = message.type;
-
-      this.emit('log', `Command received: ${type} (requestId=${requestId})`);
+      const receivedAt = Date.now();
+
+      // Anything still executing when this arrives means the SDK (or a
+      // redelivery) sent commands concurrently — the first thing to rule out
+      // when input gets garbled.
+      const inFlight = [...this._inFlight.values()]
+        .map((c) => `${c.type}+${receivedAt - c.startedAt}ms`);
+      this.emit('log',
+        `Command received: ${type} (requestId=${requestId})` +
+        (inFlight.length ? ` while in-flight: [${inFlight.join(', ')}]` : ''));
+      this._inFlight.set(requestId, { type, startedAt: receivedAt });
 
       // Stop re-publishing runner.ready once we get the first command
       this._stopReadySignal();
@@ -358,11 +368,13 @@ class AblyService extends EventEmitter {
             result,
             success: true,
           });
-          this.emit('log', `Command completed: ${type} (requestId=${requestId})`);
+          this._inFlight.delete(requestId);
+          this.emit('log', `Command completed: ${type} (requestId=${requestId}) in ${Date.now() - receivedAt}ms`);
           const span = Sentry.getActiveSpan();
           if (span) span.setAttribute('command.success', true);
         } catch (err) {
-          this.emit('log', `Command failed: ${type} — ${err.message}`);
+          this._inFlight.delete(requestId);
+          this.emit('log', `Command failed: ${type} after ${Date.now() - receivedAt}ms — ${err.message}`);
           const span = Sentry.getActiveSpan();
           if (span) {
             span.setAttribute('command.success', false);

package/lib/automation.js

@@ -46,11 +46,21 @@ const API_KEY = process.env.TD_API_KEY;
 // shell injection and escaping issues.
 
 const PYTHON = IS_WINDOWS ? 'python' : 'python3';
+// `_td(phase, **kv)` writes `__td <phase> t=<epoch ms> [k=v ...]` to stderr and
+// flushes, so even a SIGTERM-killed process leaves a trail of how far it got.
+// Scripts can call _td() themselves to mark sub-steps (see click/write).
+const PY_MARK =
+  "import sys, time; " +
+  "_td = lambda p, **kw: (sys.stderr.write('__td ' + p + ' t=%d' % int(time.time() * 1000) + ''.join(' %s=%s' % kv for kv in kw.items()) + '\\n'), sys.stderr.flush()); " +
+  "_td('start'); ";
+// Disable FAILSAFE (move to corner aborts) and PAUSE (100ms delay between calls).
+const PY_SETUP =
+  "import pyautogui, atexit; pyautogui.FAILSAFE = False; pyautogui.PAUSE = 0; " +
+  "_td('imported'); atexit.register(lambda: _td('exit'))";
 // 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 pyautogui, sys; pyautogui.FAILSAFE = False; ';
+  ? PY_MARK + "import os; os.environ.setdefault('DISPLAY', ':0'); " + PY_SETUP
+  : PY_MARK + PY_SETUP;
 
 /**
  * Read width/height from a PNG buffer's IHDR chunk without decoding the image.
@@ -200,6 +210,78 @@ async function fetchWithRetry(url, init, {
 // it grows into a timeout.
 const SLOW_PY_MS = 2000;
 
+// In-flight pyautogui subprocesses and the most recent completed one, so a
+// timeout can say whether another call overlapped it or just preceded it.
+let pyCallSeq = 0;
+const activePy = new Map(); // seq → { label, startedAt }
+let lastPy = null;          // { label, startedAt, endedAt }
+
+/**
+ * Split `__td` phase markers out of stderr.
+ * @param {string} stderr
+ * @returns {{ phases: Array<{phase: string, t: number, extra: string}>, stderr: string }}
+ */
+function parsePhaseMarkers(stderr) {
+  const phases = [];
+  const rest = [];
+  for (const line of (stderr || '').split(/\r?\n/)) {
+    const m = /^__td (\S+) t=(\d+)(.*)$/.exec(line);
+    if (m) phases.push({ phase: m[1], t: Number(m[2]), extra: m[3].trim() });
+    else if (line.trim()) rest.push(line);
+  }
+  return { phases, stderr: rest.join('\n') };
+}
+
+/**
+ * Render phases as offsets from spawn, e.g.
+ * `start@+95ms imported@+900ms clicked@+930ms pos=414,51 exit@+931ms`.
+ * If the process never reached 'exit', says where it stalled and for how long.
+ */
+function describePhases(phases, startedAt, endedAt) {
+  if (!phases.length) return 'no phases reached (interpreter never started executing)';
+  const parts = phases.map((p) => `${p.phase}@+${p.t - startedAt}ms${p.extra ? ' ' + p.extra : ''}`);
+  const last = phases[phases.length - 1];
+  if (last.phase !== 'exit') {
+    parts.push(`stalled after '${last.phase}' for ${endedAt - last.t}ms`);
+  }
+  return parts.join(' ');
+}
+
+/**
+ * Describe other pyautogui calls relative to one that started at `startedAt`.
+ * @param {Array<{label: string, startedAt: number}>} overlapping - calls in flight at start
+ * @param {{label: string, endedAt: number}|null} prev - last call that finished before start
+ */
+function describeNeighbours(overlapping, prev, startedAt) {
+  const parts = [];
+  parts.push(overlapping.length
+    ? `overlapping: [${overlapping.map((c) => `${c.label} (started ${startedAt - c.startedAt}ms earlier)`).join(', ')}]`
+    : 'overlapping: none');
+  if (prev) parts.push(`previous: ${prev.label} ended ${startedAt - prev.endedAt}ms before start`);
+  return parts.join(' | ');
+}
+
+/**
+ * Best-effort snapshot of the desktop when a pyautogui call times out:
+ * which window is in the foreground, and which python processes exist (with
+ * age in seconds) — a stale one means an earlier command is still running.
+ * Bounded to a few seconds so it can't turn a timeout into a longer stall.
+ */
+async function collectTimeoutDiagnostics() {
+  const win = IS_WINDOWS
+    ? runScript(['powershell', '-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', path.join(__dirname, '..', 'getActiveWindow.ps1')], 5)
+    : runScript(['bash', '-c', "xdotool getactivewindow getwindowname 2>/dev/null || echo ''"], 5);
+  const procs = IS_WINDOWS
+    ? runScript(['powershell', '-NoProfile', '-Command',
+        'Get-Process python* -ErrorAction SilentlyContinue | ForEach-Object { "$($_.Id):$([int]((Get-Date) - $_.StartTime).TotalSeconds)s" }'], 5)
+    : runScript(['bash', '-c', "ps -eo pid,etimes,comm | awk '$3 ~ /python/ {print $1\":\"$2\"s\"}'"], 5);
+  const [w, p] = await Promise.all([win, procs]);
+  const squash = (s) => s.trim().replace(/\s+/g, ' ');
+  const winStr = w.success ? (squash(w.stdout).slice(0, 200) || 'none') : `unavailable (${squash(w.stderr).slice(0, 100)})`;
+  const procStr = p.success ? (squash(p.stdout) || 'none') : 'unavailable';
+  return `activeWindow=${winStr} | pythonProcs(pid:age)=${procStr}`;
+}
+
 /**
  * Free space on the volume holding `dir`, in bytes.
  *
@@ -274,42 +356,59 @@ function sweepStaleScreenshots() {
  * @param {string} script — Python code (pyautogui + sys are already imported via PY_IMPORT prefix)
  * @param {string[]} [extraArgs=[]] — additional args available as sys.argv[1], sys.argv[2], etc.
  * @param {number} [timeout=15000] — subprocess timeout in ms
+ * @param {string} [label] — short name for logs; defaults to the script's first statement
  * @returns {Promise<string>} stdout output (trimmed)
  */
-function runPyAutoGUI(script, extraArgs = [], timeout = 15000) {
+function runPyAutoGUI(script, extraArgs = [], timeout = 15000, label) {
   return new Promise((resolve, reject) => {
     // Always force DISPLAY=:0 on Linux so pyautogui can connect to X11
     const env = { ...process.env };
     if (IS_LINUX) {
       env.DISPLAY = env.DISPLAY || ':0';
     }
-    // First line only — enough to identify the op in timing logs without
-    // pasting the whole program into every message.
-    const label = script.split('\n', 1)[0].slice(0, 60);
+    label = label || script.split(/[;\n]/, 1)[0].slice(0, 60);
     const startedAt = Date.now();
-    execFile(PYTHON, ['-c', PY_IMPORT + script, ...extraArgs.map(String)], {
+    const overlapping = [...activePy.values()];
+    const prev = lastPy;
+    const seq = ++pyCallSeq;
+    activePy.set(seq, { label, startedAt });
+    // Newline (not `;`) between prelude and script so compound statements
+    // (for/try) in the script are valid.
+    execFile(PYTHON, ['-c', PY_IMPORT + '\n' + script, ...extraArgs.map(String)], {
       encoding: 'utf-8',
       timeout,
       env,
-    }, (err, stdout, stderr) => {
-      const elapsed = Date.now() - startedAt;
+    }, async (err, stdout, stderr) => {
+      const endedAt = Date.now();
+      const elapsed = endedAt - startedAt;
+      activePy.delete(seq);
+      lastPy = { label, startedAt, endedAt };
+      const { phases, stderr: cleanStderr } = parsePhaseMarkers(stderr);
+      const phaseSummary = describePhases(phases, startedAt, endedAt);
       if (err) {
         // execFile kills the child when `timeout` elapses, surfacing as
-        // killed/SIGTERM with an empty stderr and a generic "Command failed"
-        // message. That is indistinguishable from a Python crash unless we
-        // name it, so say plainly that it was a timeout and how long it ran.
+        // killed/SIGTERM with a generic "Command failed" message. Name it as a
+        // timeout and attach everything we know about where it stalled.
         if (err.killed || err.signal) {
-          reject(new Error(
-            `pyautogui timed out after ${elapsed}ms (limit ${timeout}ms, ` +
-            `signal ${err.signal || 'none'}, no stderr) — ${label}`
-          ));
+          const diag = await collectTimeoutDiagnostics().catch((e) => `diagnostics failed: ${e.message}`);
+          const msg =
+            `pyautogui timed out after ${elapsed}ms (limit ${timeout}ms, signal ${err.signal || 'none'}) — ${label}` +
+            ` | phases: ${phaseSummary}` +
+            ` | ${describeNeighbours(overlapping, prev, startedAt)}` +
+            ` | ${diag}` +
+            (cleanStderr ? ` | stderr: ${cleanStderr.slice(0, 300)}` : '');
+          console.warn(`[automation] ${msg}`);
+          reject(new Error(msg));
           return;
         }
-        const msg = (stderr || '').trim() || err.message;
-        reject(new Error(`pyautogui command failed after ${elapsed}ms: ${msg}`));
+        const msg = cleanStderr || err.message;
+        reject(new Error(`pyautogui command failed after ${elapsed}ms (${label} | phases: ${phaseSummary}): ${msg}`));
       } else {
         if (elapsed > SLOW_PY_MS) {
-          console.warn(`[automation] slow pyautogui: ${elapsed}ms — ${label}`);
+          console.warn(
+            `[automation] slow pyautogui: ${elapsed}ms — ${label} | phases: ${phaseSummary}` +
+            ` | ${describeNeighbours(overlapping, prev, startedAt)}`
+          );
         }
         resolve((stdout || '').trim());
       }
@@ -549,9 +648,12 @@ class Automation extends EventEmitter {
         "for k in ['shift','shiftleft','shiftright','ctrl','ctrlleft','ctrlright'," +
         "'alt','altleft','altright','command','win','winleft','winright']:\n" +
         " try: pyautogui.keyUp(k)\n" +
-        " except: pass"
+        " except: pass",
+        [], 15000, 'releaseModifiers',
       );
-    } catch {}
+    } catch (err) {
+      console.warn(`[automation] releaseModifiers failed: ${err.message}`);
+    }
   }
 
   /**
@@ -600,9 +702,19 @@ class Automation extends EventEmitter {
         const button = data.button || 'left';
         if (data.x != null && data.y != null) {
           console.log(`[automation] click: (${data.x},${data.y})`);
-          await runPyAutoGUI(`pyautogui.click(${data.x}, ${data.y}, button=sys.argv[1])`, [button]);
+          // moveTo + click split with markers so a hang is attributable to
+          // the cursor move vs. the button event, and `pos` confirms the
+          // cursor actually landed where the click was requested.
+          await runPyAutoGUI(
+            `pyautogui.moveTo(${data.x}, ${data.y}); _td('moved', pos='%d,%d' % pyautogui.position()); ` +
+            `pyautogui.click(button=sys.argv[1]); _td('clicked', pos='%d,%d' % pyautogui.position())`,
+            [button], 15000, `click(${data.x},${data.y},${button})`,
+          );
         } else {
-          await runPyAutoGUI(`pyautogui.click(button=sys.argv[1])`, [button]);
+          await runPyAutoGUI(
+            `pyautogui.click(button=sys.argv[1]); _td('clicked', pos='%d,%d' % pyautogui.position())`,
+            [button], 15000, `click(${button})`,
+          );
         }
         return true;
       }
@@ -676,7 +788,18 @@ class Automation extends EventEmitter {
       case 'write': {
         // Type each character — matches pyautogui.write() behavior
         // Text passed via sys.argv[1] to avoid escaping issues
-        await runPyAutoGUI('pyautogui.write(sys.argv[1])', [data.text || '']);
+        // Add interval between keystrokes to prevent garbled/dropped chars.
+        // Without an interval, keystrokes can collide with concurrent commands
+        // (like clicks) or overflow the keyboard buffer.
+        // Default: 50ms. Can be overridden via data.interval.
+        const interval = data.interval ?? 0.05;
+        const text = data.text || '';
+        // Typing time grows with length; give it 2x the expected duration on top of the base.
+        const writeTimeout = 15000 + Math.ceil(text.length * interval * 1000 * 2);
+        await runPyAutoGUI(
+          `pyautogui.write(sys.argv[1], interval=${interval}); _td('typed', chars=len(sys.argv[1]))`,
+          [text], writeTimeout, `write(${text.length} chars, interval=${interval})`,
+        );
         await this.releaseModifiers();
         return true;
       }

package/package.json

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