@testdriverai/agent 7.8.0-test.74 → 7.9.0-test.1

package/agent/lib/sandbox.js

@@ -536,6 +536,162 @@ const createSandbox = function (emitter, analytics, sessionInstance) {
         }
       }
 
+      // ─── Handle pending slot claim (trigger.dev waitpoint flow) ────
+      // The API returned early with status: 'pending'. The SDK has now
+      // connected to Ably and entered presence (done in _initAbly above).
+      // Wait for the claim-slot task to publish slot-approved or slot-denied
+      // on the control channel, then re-call authenticate with slotApproved.
+      // On slot-denied, we poll forever (re-calling authenticate every 10s)
+      // until a slot opens, matching _httpPostWithConcurrencyRetry behavior.
+      var concurrencyRetryInterval = 10000;
+      var slotPollStart = Date.now();
+      while (reply.status === 'pending') {
+        logger.log('Slot claim pending — waiting for approval via Ably...');
+
+        var self = this;
+        var slotResolved = false;
+        var slotResolve, slotReject;
+        var slotDecisionPromise = new Promise(function (resolve, reject) {
+          slotResolve = resolve;
+          slotReject = reject;
+        });
+
+        var slotTimeout = setTimeout(function () {
+          if (slotResolved) return;
+          slotResolved = true;
+          try { self._sessionChannel.unsubscribe('control', onSlotControl); } catch (_) {}
+          slotReject(new Error('Slot claim timed out waiting for approval'));
+        }, 60000); // 60s timeout
+        if (slotTimeout.unref) slotTimeout.unref();
+
+        function onSlotControl(msg) {
+          var data = msg.data;
+          if (!data) return;
+          if (data.type === 'slot-approved') {
+            if (slotResolved) return;
+            slotResolved = true;
+            clearTimeout(slotTimeout);
+            try { self._sessionChannel.unsubscribe('control', onSlotControl); } catch (_) {}
+            slotResolve({ approved: true, data: data });
+          } else if (data.type === 'slot-denied') {
+            if (slotResolved) return;
+            slotResolved = true;
+            clearTimeout(slotTimeout);
+            try { self._sessionChannel.unsubscribe('control', onSlotControl); } catch (_) {}
+            slotResolve({ approved: false, data: data });
+          }
+        }
+
+        // Subscribe FIRST, then check history to close the race window
+        // between presence enter (done in _initAbly) and this subscription.
+        // The claim-slot task fires in response to presence enter, so the
+        // decision may already be published by the time we get here.
+        var slotControlSub = await self._sessionChannel.subscribe('control', onSlotControl);
+
+        // Check for decisions published before this subscription was active
+        if (!slotResolved && slotControlSub) {
+          try {
+            var histPage = await slotControlSub.historyBeforeSubscribe({ limit: 10 });
+            while (histPage && !slotResolved) {
+              for (var hi = 0; hi < histPage.items.length; hi++) {
+                onSlotControl(histPage.items[hi]);
+                if (slotResolved) break;
+              }
+              histPage = (!slotResolved && histPage.hasNext()) ? await histPage.next() : null;
+            }
+          } catch (histErr) {
+            logger.warn('[slots] Failed to check history for slot decision: ' + (histErr.message || histErr));
+          }
+        }
+
+        var slotDecision = await slotDecisionPromise;
+
+        if (!slotDecision.approved) {
+          // Slot denied — disconnect Ably and re-try the full authenticate
+          // flow after a delay, polling forever until a slot opens.
+          var elapsed = Date.now() - slotPollStart;
+          logger.log(
+            'Slot denied: ' + (slotDecision.data.message || 'concurrency limit reached') +
+            ' — waiting ' + (concurrencyRetryInterval / 1000) + 's before retrying' +
+            ' (' + Math.round(elapsed / 1000) + 's elapsed)...'
+          );
+          logger.log('Upgrade for more slots → https://console.testdriver.ai/checkout/team');
+          try {
+            if (this._ably) this._ably.close();
+            this._ably = null;
+            this._sessionChannel = null;
+          } catch (_) {}
+
+          await new Promise(function (resolve) {
+            var t = setTimeout(resolve, concurrencyRetryInterval);
+            if (t.unref) t.unref();
+          });
+
+          // Re-call authenticate — this goes through _httpPostWithConcurrencyRetry
+          // so transient HTTP errors are also handled. The new reply will either
+          // be 'pending' again (loop continues) or succeed directly.
+          reply = await this._httpPostWithConcurrencyRetry(
+            "/api/v7/sandbox/authenticate",
+            body,
+            timeout,
+          );
+
+          if (!reply.success && reply.status !== 'pending') {
+            var retryErr = new Error(
+              reply.errorMessage || "Failed to allocate sandbox",
+            );
+            retryErr.responseData = reply;
+            throw retryErr;
+          }
+
+          // Re-init Ably if we got a new pending reply with fresh credentials
+          if (reply.status === 'pending' && reply.ably && reply.ably.token) {
+            this._sandboxId = reply.sandboxId;
+            this._teamId = reply.teamId;
+            await this._initAbly(reply.ably.token, reply.ably.channel);
+            this.instanceSocketConnected = true;
+          }
+
+          continue; // loop back to wait for the next slot decision
+        }
+
+        logger.log('Slot approved — provisioning sandbox...');
+
+        // Re-call authenticate with slotApproved flag to trigger provisioning
+        // Keep the same sandboxId so the Ably channel stays valid
+        var provisionBody = {
+          apiKey: this.apiKey,
+          version: version,
+          os: message.os || this.os || 'linux',
+          session: sessionId,
+          apiRoot: this.apiRoot,
+          sandboxId: this._sandboxId,
+          slotApproved: true,
+        };
+        if (message.resolution) provisionBody.resolution = message.resolution;
+        if (message.ci) provisionBody.ci = message.ci;
+        if (message.ami) provisionBody.ami = message.ami;
+        if (message.instanceType) provisionBody.instanceType = message.instanceType;
+        if (message.e2bTemplateId) provisionBody.e2bTemplateId = message.e2bTemplateId;
+        if (message.keepAlive !== undefined) provisionBody.keepAlive = message.keepAlive;
+
+        reply = await this._httpPostWithConcurrencyRetry(
+          "/api/v7/sandbox/authenticate",
+          provisionBody,
+          timeout,
+        );
+
+        if (!reply.success) {
+          var provisionErr = new Error(
+            reply.errorMessage || "Failed to provision sandbox after approval",
+          );
+          provisionErr.responseData = reply;
+          throw provisionErr;
+        }
+
+        break; // slot approved and provisioned — exit the while loop
+      }
+
       if (message.type === "create") {
         // E2B (Linux) sandboxes return a url directly.
         // We still need to wait for runner.ready since sandbox-agent.js runs inside E2B.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testdriverai/agent",
-  "version": "7.8.0-test.74",
+  "version": "7.9.0-test.1",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",
@@ -116,7 +116,7 @@
   },
   "overrides": {
     "glob": "^11.0.1",
-    "obug": "2.1.0",
+    "obug": "2.1.1",
     "rimraf": "^5.0.10"
   },
   "peerDependencies": {