@testdriverai/mcp 7.8.0-canary.12 → 7.8.0-canary.13

package/agent/lib/sandbox.js

@@ -29,6 +29,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
       this._lastConnectParams = null;
       this._teamId = null;
       this._sandboxId = null;
+      this._disconnectedAt = null; // tracks when Ably connection dropped (for timeout extension on reconnect)
 
       // Rate limiting state for Ably publishes (Ably limits to 50 msg/sec per connection)
       this._publishLastTime = 0;
@@ -98,7 +99,7 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
       }
 
       // Save subscription references for historyBeforeSubscribe() during discontinuity recovery
-      this._responseSubscription = await this._sessionChannel.subscribe("response", function (msg) {
+      this._onResponseMsg = function (msg) {
         var message = msg.data;
         if (!message) return;
 
@@ -154,31 +155,53 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         }
 
         if (!message.requestId || !self.ps[message.requestId]) {
-          var debugMode =
-            process.env.VERBOSE || process.env.TD_DEBUG;
-          if (debugMode) {
-            console.warn(
-              "No pending promise found for requestId:",
-              message.requestId,
-            );
-          }
+          var pendingIds = Object.keys(self.ps);
+          var pendingSummary = pendingIds.length > 0
+            ? pendingIds.map(function (rid) {
+              var e = self.ps[rid];
+              return rid + '(' + (e && e.message ? e.message.type : '?') + ')';
+            }).join(', ')
+            : 'none';
+          logger.warn(
+            '[ably] No pending promise for requestId=' + (message.requestId || 'null') +
+            ' | response type=' + (message.type || 'unknown') +
+            ' | error=' + (message.error ? (message.errorMessage || 'true') : 'false') +
+            ' | currently pending: [' + pendingSummary + ']'
+          );
           return;
         }
 
         if (message.error) {
-          var pendingMessage =
-            self.ps[message.requestId] &&
-            self.ps[message.requestId].message;
+          var pendingEntry = self.ps[message.requestId];
+          var pendingMessage = pendingEntry && pendingEntry.message;
+          var pendingAge = pendingEntry && pendingEntry.startTime
+            ? ((Date.now() - pendingEntry.startTime) / 1000).toFixed(1) + 's'
+            : '?';
+          logger.warn(
+            '[ably] Promise REJECTED: requestId=' + message.requestId +
+            ' | type=' + (pendingMessage ? pendingMessage.type : 'unknown') +
+            ' | age=' + pendingAge +
+            ' | error=' + (message.errorMessage || 'Sandbox error')
+          );
           if (!pendingMessage || pendingMessage.type !== "output") {
             emitter.emit(events.error.sandbox, message.errorMessage);
           }
           var error = new Error(message.errorMessage || "Sandbox error");
           error.responseData = message;
           delete self._execBuffers[message.requestId];
-          self.ps[message.requestId].reject(error);
+          pendingEntry.reject(error);
         } else {
           emitter.emit(events.sandbox.received);
           if (self.ps[message.requestId]) {
+            var resolveEntry = self.ps[message.requestId];
+            var resolveAge = resolveEntry.startTime
+              ? ((Date.now() - resolveEntry.startTime) / 1000).toFixed(1) + 's'
+              : '?';
+            logger.log(
+              '[ably] Promise RESOLVED: requestId=' + message.requestId +
+              ' | type=' + (resolveEntry.message ? resolveEntry.message.type : 'unknown') +
+              ' | age=' + resolveAge
+            );
             // Unwrap the result from the Ably response envelope
             // The runner sends { requestId, type, result, success }
             // But SDK commands expect just the result object
@@ -197,9 +220,10 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
           }
         }
         delete self.ps[message.requestId];
-      });
+      };
+      this._responseSubscription = await this._sessionChannel.subscribe("response", this._onResponseMsg);
 
-      this._fileSubscription = await this._sessionChannel.subscribe("file", function (msg) {
+      this._onFileMsg = function (msg) {
         var message = msg.data;
         if (!message) return;
         logger.log(`[ably] Received file: type=${message.type || 'unknown'} (requestId=${message.requestId || 'none'})`);
@@ -209,7 +233,8 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
           delete self.ps[message.requestId];
         }
         emitter.emit(events.sandbox.file, message);
-      });
+      };
+      this._fileSubscription = await this._sessionChannel.subscribe("file", this._onFileMsg);
 
       this.heartbeat = setInterval(function () { }, 5000);
       if (this.heartbeat.unref) this.heartbeat.unref();
@@ -218,18 +243,50 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
       this._statsInterval = setInterval(() => {
         const connState = this._ably ? this._ably.connection.state : 'no-client';
         const chState = this._sessionChannel ? this._sessionChannel.state : 'null';
-        const pending = Object.keys(this.ps).length;
+        const pendingIds = Object.keys(this.ps);
+        const pending = pendingIds.length;
         logger.log(`[ably][stats] connection=${connState} | sandbox=${this._sandboxId} | pending=${pending} | channel=${chState}`);
+        if (pending > 0) {
+          const now = Date.now();
+          for (const rid of pendingIds) {
+            const entry = this.ps[rid];
+            if (!entry) continue;
+            const type = entry.message ? entry.message.type : 'unknown';
+            const ageSec = ((now - (entry.startTime || now)) / 1000).toFixed(1);
+            logger.log(`[ably][stats]   pending: requestId=${rid} | type=${type} | age=${ageSec}s`);
+          }
+        }
       }, 10000);
       if (this._statsInterval.unref) this._statsInterval.unref();
 
       this._ably.connection.on("disconnected", function () {
         logger.log("[ably] Connection: disconnected - will auto-reconnect");
+        self._disconnectedAt = Date.now();
       });
 
       this._ably.connection.on("connected", function () {
         // Log reconnection so the user knows the blip was recovered
         logger.log("[ably] Connection: reconnected");
+        // Extend any pending command timeouts by the disconnection duration so
+        // commands whose timer was counting down while the connection was down
+        // don't get incorrectly timed out.
+        if (self._disconnectedAt) {
+          var disconnectionDurationMs = Date.now() - self._disconnectedAt;
+          self._disconnectedAt = null;
+          var pendingIds = Object.keys(self.ps);
+          if (pendingIds.length > 0) {
+            logger.log(
+              '[ably] Extending ' + pendingIds.length + ' pending timeout(s) by ' +
+              disconnectionDurationMs + 'ms after disconnection'
+            );
+            for (var i = 0; i < pendingIds.length; i++) {
+              var entry = self.ps[pendingIds[i]];
+              if (entry && typeof entry.extendTimeout === 'function') {
+                entry.extendTimeout(disconnectionDurationMs);
+              }
+            }
+          }
+        }
       });
 
       this._ably.connection.on("suspended", function () {
@@ -267,12 +324,14 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
     /**
      * Recover missed messages after a channel discontinuity.
      * Uses historyBeforeSubscribe() on each subscription, which guarantees
-     * no gap between historical and live messages.
+     * no gap between historical and live messages.  Each recovered message
+     * is dispatched through the same handler that processes live messages
+     * so that pending promises are resolved/rejected correctly.
      */
     async _recoverFromDiscontinuity() {
       var subs = [
-        { name: 'response', sub: this._responseSubscription },
-        { name: 'file', sub: this._fileSubscription },
+        { name: 'response', sub: this._responseSubscription, handler: this._onResponseMsg },
+        { name: 'file', sub: this._fileSubscription, handler: this._onFileMsg },
       ];
       var totalRecovered = 0;
       for (var i = 0; i < subs.length; i++) {
@@ -283,17 +342,29 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
           var page = await entry.sub.historyBeforeSubscribe({ limit: 100 });
           var recovered = 0;
           while (page) {
-            recovered += page.items.length;
+            // Replay each missed message through the handler so pending
+            // promises get resolved instead of timing out.
+            for (var j = 0; j < page.items.length; j++) {
+              recovered++;
+              try {
+                if (entry.handler) {
+                  logger.log('[ably] Replaying recovered ' + entry.name + ' message (requestId=' + (page.items[j].data && page.items[j].data.requestId || 'none') + ')');
+                  entry.handler(page.items[j]);
+                }
+              } catch (replayErr) {
+                logger.error('[ably] Error replaying recovered message: ' + (replayErr.message || replayErr));
+              }
+            }
             page = page.hasNext() ? await page.next() : null;
           }
           totalRecovered += recovered;
-          logger.log('[ably] Discontinuity recovery: found ' + recovered + ' ' + entry.name + ' message(s) in gap');
+          logger.log('[ably] Discontinuity recovery: replayed ' + recovered + ' ' + entry.name + ' message(s) from 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');
+        logger.warn('[ably] Recovered and replayed ' + totalRecovered + ' message(s) that were missed during connection interruption');
       } else {
         logger.log('[ably] Discontinuity recovery: no missed messages found');
       }
@@ -780,8 +851,25 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
 
       var requestId = message.requestId;
 
-      var timeoutId = setTimeout(function () {
+      // timeoutId and timeoutExpiresAt are declared as vars so they can be
+      // updated by extendTimeout() (closure mutation).
+      var timeoutId;
+      var timeoutExpiresAt;
+
+      var timeoutFn = function () {
         if (self.ps[requestId]) {
+          var pendingIds = Object.keys(self.ps);
+          var pendingSummary = pendingIds.map(function (rid) {
+            var e = self.ps[rid];
+            var age = e && e.startTime ? ((Date.now() - e.startTime) / 1000).toFixed(1) + 's' : '?';
+            return rid + '(' + (e && e.message ? e.message.type : '?') + ', ' + age + ')';
+          }).join(', ');
+          logger.error(
+            '[ably] Promise TIMEOUT: requestId=' + requestId +
+            ' | type=' + message.type +
+            ' | timeout=' + timeout + 'ms' +
+            ' | all pending: [' + pendingSummary + ']'
+          );
           delete self.ps[requestId];
           delete self._execBuffers[requestId];
           rejectPromise(
@@ -794,7 +882,10 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
             ),
           );
         }
-      }, timeout);
+      };
+
+      timeoutId = setTimeout(timeoutFn, timeout);
+      timeoutExpiresAt = Date.now() + timeout;
       if (timeoutId.unref) timeoutId.unref();
 
       this.ps[requestId] = {
@@ -807,6 +898,26 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
           clearTimeout(timeoutId);
           rejectPromise(error);
         },
+        /**
+         * Extend the pending timeout by disconnectionDurationMs — called on Ably reconnect
+         * to compensate for time spent disconnected.
+         */
+        extendTimeout: function (disconnectionDurationMs) {
+          clearTimeout(timeoutId);
+          // Clamp remaining to 0 so a command whose timer expired during the
+          // outage still gets the full disconnection duration as its new budget.
+          var remaining = Math.max(0, timeoutExpiresAt - Date.now());
+          // Minimum 5s remaining after extension to allow the response to arrive.
+          var MIN_REMAINING_MS = 5000;
+          var newRemaining = Math.max(remaining + disconnectionDurationMs, MIN_REMAINING_MS);
+          timeoutExpiresAt = Date.now() + newRemaining;
+          timeoutId = setTimeout(timeoutFn, newRemaining);
+          if (timeoutId.unref) timeoutId.unref();
+          logger.log(
+            '[ably] Extended timeout for requestId=' + requestId +
+            ' by ' + disconnectionDurationMs + 'ms (new remaining: ' + Math.round(newRemaining / 1000) + 's)'
+          );
+        },
         message: message,
         startTime: Date.now(),
       };

package/lib/vitest/hooks.mjs

@@ -42,14 +42,14 @@ function checkVitestVersion() {
     if (major < MINIMUM_VITEST_VERSION) {
       throw new Error(
         `TestDriver requires Vitest >= ${MINIMUM_VITEST_VERSION}.0.0, but found ${version}. ` +
-          `Please upgrade Vitest: npm install vitest@latest`,
+        `Please upgrade Vitest: npm install vitest@latest`,
       );
     }
   } catch (err) {
     if (err.code === "MODULE_NOT_FOUND") {
       throw new Error(
         "TestDriver requires Vitest to be installed. " +
-          "Please install it: npm install vitest@latest",
+        "Please install it: npm install vitest@latest",
       );
     }
     throw err;
@@ -646,7 +646,7 @@ export function TestDriver(context, options = {}) {
 
       // Wait for connection to finish if it was initiated
       if (currentInstance.__connectionPromise) {
-        await currentInstance.__connectionPromise.catch(() => {}); // Ignore connection errors during cleanup
+        await currentInstance.__connectionPromise.catch(() => { }); // Ignore connection errors during cleanup
       }
 
       // Disconnect with timeout

package/package.json

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