@testdriverai/runner 7.8.0-test.39 → 7.8.0-test.40

package/lib/ably-service.js

@@ -170,6 +170,7 @@ 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) => {
@@ -230,7 +231,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;
@@ -239,7 +240,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;
@@ -248,21 +249,24 @@ 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
+    // 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;
+
     this._automation.on('exec.output', ({ requestId, chunk }) => {
-      this._sendResponse({
-        type: 'exec.output',
-        requestId,
-        chunk,
-        timestamp: Date.now(),
-      }).catch(() => {}); // best-effort, don't block exec
+      this._execOutputQueue.push({ requestId, chunk });
+      this._drainExecOutputQueue();
     });
 
-    // Subscribe to commands
-    this._sessionChannel.subscribe('command', async (msg) => {
+    // Subscribe to commands — save subscription ref for historyBeforeSubscribe()
+    this._commandSubscription = await this._sessionChannel.subscribe('command', async (msg) => {
       const message = msg.data;
       if (!message) return;
 
@@ -293,7 +297,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`,
@@ -407,11 +411,27 @@ 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) {
+          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
-    this._sessionChannel.subscribe('control', async (msg) => {
+    // Subscribe to control messages — save subscription ref for historyBeforeSubscribe()
+    this._controlSubscription = await this._sessionChannel.subscribe('control', async (msg) => {
       const message = msg.data;
       if (!message) return;
 
@@ -453,6 +473,77 @@ class AblyService extends EventEmitter {
     this.emit('log', 'Published runner.ready signal');
   }
 
+  /**
+   * 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.
+   */
+  async _recoverFromDiscontinuity() {
+    const subs = [
+      { name: 'command', sub: this._commandSubscription },
+      { name: 'control', sub: this._controlSubscription },
+    ];
+    for (const { name, sub } 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) {
+          recovered += page.items.length;
+          page = page.hasNext() ? await page.next() : null;
+        }
+        this.emit('log', `Discontinuity recovery: found ${recovered} ${name} message(s) in gap`);
+      } catch (err) {
+        this.emit('log', `Discontinuity recovery failed for ${name}: ${err.message}`);
+        Sentry.captureException(err);
+      }
+    }
+  }
+
   /**
    * Send a response on the session channel.
    */
@@ -518,12 +609,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/package.json

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