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

package/agent/lib/sandbox.js

@@ -64,6 +64,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
           callback(null, ablyToken);
         },
         clientId: "sdk-" + this._sandboxId,
+        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)
       });
@@ -96,7 +97,8 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         logger.warn("Failed to enter presence on session channel: " + (e.message || e));
       }
 
-      this._sessionChannel.subscribe("response", function (msg) {
+      // Save subscription references for historyBeforeSubscribe() during discontinuity recovery
+      this._responseSubscription = await this._sessionChannel.subscribe("response", function (msg) {
         var message = msg.data;
         if (!message) return;
 
@@ -197,7 +199,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         delete self.ps[message.requestId];
       });
 
-      this._sessionChannel.subscribe("file", function (msg) {
+      this._fileSubscription = await this._sessionChannel.subscribe("file", function (msg) {
         var message = msg.data;
         if (!message) return;
         logger.log(`[ably] Received file: type=${message.type || 'unknown'} (requestId=${message.requestId || 'none'})`);
@@ -209,7 +211,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         emitter.emit(events.sandbox.file, message);
       });
 
-      this.heartbeat = setInterval(function () {}, 5000);
+      this.heartbeat = setInterval(function () { }, 5000);
       if (this.heartbeat.unref) this.heartbeat.unref();
 
       // ─── Periodic stats logging ────────────────────────────────────────
@@ -240,6 +242,61 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         self.instanceSocketConnected = false;
         emitter.emit(events.error.sandbox, "Ably connection failed");
       });
+
+      // ─── Channel discontinuity detection ──────────────────────────────
+      // Set up BEFORE subscribing so we catch any continuity loss during
+      // the initial attachment. Fires at the channel level, covering all
+      // message types (response, file, control).
+      this._sessionChannel.on(function (stateChange) {
+        var current = stateChange.current;
+        var previous = stateChange.previous;
+        var reason = stateChange.reason;
+        var reasonMsg = reason ? (reason.message || reason.code || String(reason)) : '';
+
+        if (current === 'attached' && stateChange.resumed === false && previous) {
+          logger.warn('[ably] Channel DISCONTINUITY detected (resumed=false)' + (reasonMsg ? ' — ' + reasonMsg : ''));
+          emitter.emit(events.sandbox.progress, {
+            step: 'discontinuity',
+            message: 'Recovering missed messages after connection interruption...',
+          });
+          self._recoverFromDiscontinuity();
+        }
+      });
+    }
+
+    /**
+     * Recover missed messages after a channel discontinuity.
+     * Uses historyBeforeSubscribe() on each subscription, which guarantees
+     * no gap between historical and live messages.
+     */
+    async _recoverFromDiscontinuity() {
+      var subs = [
+        { name: 'response', sub: this._responseSubscription },
+        { name: 'file', sub: this._fileSubscription },
+      ];
+      var totalRecovered = 0;
+      for (var i = 0; i < subs.length; i++) {
+        var entry = subs[i];
+        if (!entry.sub) continue;
+        try {
+          logger.log('[ably] Discontinuity recovery: fetching historyBeforeSubscribe for ' + entry.name + '...');
+          var page = await entry.sub.historyBeforeSubscribe({ limit: 100 });
+          var recovered = 0;
+          while (page) {
+            recovered += page.items.length;
+            page = page.hasNext() ? await page.next() : null;
+          }
+          totalRecovered += recovered;
+          logger.log('[ably] Discontinuity recovery: found ' + recovered + ' ' + entry.name + ' message(s) in gap');
+        } catch (err) {
+          logger.error('[ably] Discontinuity recovery failed for ' + entry.name + ': ' + (err.message || err));
+        }
+      }
+      if (totalRecovered > 0) {
+        logger.warn('[ably] Recovered ' + totalRecovered + ' message(s) that were missed during connection interruption');
+      } else {
+        logger.log('[ably] Discontinuity recovery: no missed messages found');
+      }
     }
 
     /**
@@ -279,10 +336,10 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
               var elapsed = Date.now() - startTime;
               logger.warn(
                 "Transient network error: " + (error.message || error.code) +
-                  " — POST " + path +
-                  " — retry " + attempt + "/3" +
-                  " in " + (delayMs / 1000).toFixed(1) + "s" +
-                  " (" + Math.round(elapsed / 1000) + "s elapsed)...",
+                " — POST " + path +
+                " — retry " + attempt + "/3" +
+                " in " + (delayMs / 1000).toFixed(1) + "s" +
+                " (" + Math.round(elapsed / 1000) + "s elapsed)...",
               );
             },
           });
@@ -294,10 +351,10 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
             var elapsed = Date.now() - startTime;
             logger.log(
               "Concurrency limit reached — waiting " +
-                concurrencyRetryInterval / 1000 +
-                "s for a slot to become available (" +
-                Math.round(elapsed / 1000) +
-                "s elapsed)...",
+              concurrencyRetryInterval / 1000 +
+              "s for a slot to become available (" +
+              Math.round(elapsed / 1000) +
+              "s elapsed)...",
             );
             await new Promise(function (resolve) {
               var t = setTimeout(resolve, concurrencyRetryInterval);
@@ -730,10 +787,10 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
           rejectPromise(
             new Error(
               "Sandbox message '" +
-                message.type +
-                "' timed out after " +
-                timeout +
-                "ms",
+              message.type +
+              "' timed out after " +
+              timeout +
+              "ms",
             ),
           );
         }
@@ -755,7 +812,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
       };
 
       if (message.type === "output") {
-        p.catch(function () {});
+        p.catch(function () { });
       }
 
       this._throttledPublish(this._sessionChannel, "command", message)
@@ -848,7 +905,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
           logger.log("Trace Report (Share When Reporting Bugs):");
           logger.log(
             "https://testdriver.sentry.io/explore/traces/trace/" +
-              reply.traceId,
+            reply.traceId,
           );
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testdriverai/agent",
-  "version": "7.8.0-test.39",
+  "version": "7.8.0-test.40",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",