testdriverai 7.2.56 → 7.2.58

package/lib/vitest/setup-aws.mjs

@@ -1,9 +1,9 @@
 /**
  * Vitest Setup File for AWS Self-Hosted TestDriver Instances
- * 
+ *
  * This setup file spawns a fresh AWS instance before each test
  * and terminates it after each test completes.
- * 
+ *
  * Usage in vitest.config.mjs:
  * ```js
  * export default defineConfig({
@@ -15,7 +15,7 @@
  *   },
  * });
  * ```
- * 
+ *
  * Required environment variables:
  * - AWS_ACCESS_KEY_ID
  * - AWS_SECRET_ACCESS_KEY
@@ -24,10 +24,10 @@
  * - AMI_ID
  */
 
-import { execSync, spawn } from 'child_process';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { beforeEach } from 'vitest';
+import { execSync, spawn } from "child_process";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { beforeEach } from "vitest";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -56,20 +56,23 @@ globalThis.__testdriverAWS = globalThis.__testdriverAWS || {
       execSync(
         `aws ec2 terminate-instances --region "${awsRegion}" --instance-ids "${instanceId}"`,
         {
-          encoding: 'utf-8',
+          encoding: "utf-8",
           env: process.env,
-          stdio: 'inherit',
-        }
+          stdio: "inherit",
+        },
       );
 
       console.log(`[TestDriver] Instance terminated: ${instanceId}`);
     } catch (error) {
-      console.error('[TestDriver] Failed to terminate instance:', error.message);
+      console.error(
+        "[TestDriver] Failed to terminate instance:",
+        error.message,
+      );
       // Don't throw - we don't want to fail the test because of cleanup issues
     } finally {
       testInstances.delete(testId);
     }
-  }
+  },
 };
 
 /**
@@ -81,22 +84,27 @@ function cleanupAllInstances() {
     return;
   }
 
-  console.log(`[TestDriver] Emergency cleanup: terminating ${testInstances.size} instance(s)`);
+  console.log(
+    `[TestDriver] Emergency cleanup: terminating ${testInstances.size} instance(s)`,
+  );
 
   for (const [testId, instanceInfo] of testInstances.entries()) {
     const { instanceId, awsRegion } = instanceInfo;
-    
+
     try {
       console.log(`[TestDriver] Terminating instance: ${instanceId}`);
       execSync(
         `aws ec2 terminate-instances --region "${awsRegion}" --instance-ids "${instanceId}"`,
         {
-          encoding: 'utf-8',
-          stdio: 'inherit',
-        }
+          encoding: "utf-8",
+          stdio: "inherit",
+        },
       );
     } catch (error) {
-      console.error(`[TestDriver] Failed to terminate instance ${instanceId}:`, error.message);
+      console.error(
+        `[TestDriver] Failed to terminate instance ${instanceId}:`,
+        error.message,
+      );
     }
   }
 
@@ -104,26 +112,26 @@ function cleanupAllInstances() {
 }
 
 // Register cleanup handlers for various exit scenarios
-process.on('exit', cleanupAllInstances);
-process.on('SIGINT', () => {
-  console.log('\n[TestDriver] Received SIGINT, cleaning up instances...');
+process.on("exit", cleanupAllInstances);
+process.on("SIGINT", () => {
+  console.log("\n[TestDriver] Received SIGINT, cleaning up instances...");
   cleanupAllInstances();
   // Don't call process.exit here - let the signal handler do its job
 });
-process.on('SIGTERM', () => {
-  console.log('\n[TestDriver] Received SIGTERM, cleaning up instances...');
+process.on("SIGTERM", () => {
+  console.log("\n[TestDriver] Received SIGTERM, cleaning up instances...");
   cleanupAllInstances();
   // Don't call process.exit here - let the signal handler do its job
 });
-process.on('uncaughtException', (error) => {
-  console.error('[TestDriver] Uncaught exception:', error);
+process.on("uncaughtException", (error) => {
+  console.error("[TestDriver] Uncaught exception:", error);
   cleanupAllInstances();
   // Don't call process.exit here - let Node.js handle the exception
 });
 
 beforeEach(async (context) => {
   // Only spawn if TD_OS=windows (indicates Windows self-hosted mode)
-  if (process.env.TD_OS !== 'windows') {
+  if (process.env.TD_OS !== "windows") {
     return;
   }
 
@@ -135,61 +143,76 @@ beforeEach(async (context) => {
   }
 
   // Verify required parameters are available
+  if (process.env.TD_OS === "windows") {
+    console.log(
+      "[TestDriver] startup check: TWOCAPTCHA_API_KEY is " +
+        (process.env.TWOCAPTCHA_API_KEY ? "REQUIRED" : "MISSING"),
+    );
+  }
+
   if (!process.env.AWS_LAUNCH_TEMPLATE_ID || !process.env.AMI_ID) {
-    throw new Error('[TestDriver] TD_OS=windows requires AWS_LAUNCH_TEMPLATE_ID and AMI_ID environment variables');
+    throw new Error(
+      "[TestDriver] TD_OS=windows requires AWS_LAUNCH_TEMPLATE_ID and AMI_ID environment variables",
+    );
   }
 
   // Check if AWS CLI is installed
   try {
-    execSync('which aws', { stdio: 'ignore' });
+    execSync("which aws", { stdio: "ignore" });
   } catch (error) {
-    throw new Error('[TestDriver] AWS CLI is not installed. Install it from https://aws.amazon.com/cli/');
+    throw new Error(
+      "[TestDriver] AWS CLI is not installed. Install it from https://aws.amazon.com/cli/",
+    );
   }
 
   const testId = context.task.id;
-  
-  console.log(`[TestDriver] Spawning AWS instance for test: ${context.task.name}`);
-  
+
+  console.log(
+    `[TestDriver] Spawning AWS instance for test: ${context.task.name}`,
+  );
+
   try {
     // Find the spawn-runner.sh script (relative to this file)
-    const spawnScriptPath = join(__dirname, '../../setup/aws/spawn-runner.sh');
-    
+    const spawnScriptPath = join(__dirname, "../../setup/aws/spawn-runner.sh");
+
     // Execute spawn-runner.sh with live output streaming
     const output = await new Promise((resolve, reject) => {
-      const child = spawn('bash', [spawnScriptPath], {
+      const child = spawn("bash", [spawnScriptPath], {
         env: {
           ...process.env,
-          AWS_REGION: process.env.AWS_REGION || 'us-east-2',
-          RESOLUTION: process.env.RESOLUTION || '1920x1080',
+          AWS_REGION: process.env.AWS_REGION || "us-east-2",
+          RESOLUTION: process.env.RESOLUTION || "1920x1080",
         },
       });
 
-      let stdout = '';
-      let stderr = '';
+      let stdout = "";
+      let stderr = "";
 
       // Stream stdout in real-time
-      child.stdout.on('data', (data) => {
+      child.stdout.on("data", (data) => {
         const str = data.toString();
         process.stdout.write(str); // Show output immediately
         stdout += str;
       });
 
       // Stream stderr in real-time
-      child.stderr.on('data', (data) => {
+      child.stderr.on("data", (data) => {
         const str = data.toString();
         process.stderr.write(str); // Show errors immediately
         stderr += str;
       });
 
-      child.on('close', (code) => {
+      child.on("close", (code) => {
         if (code !== 0) {
-          reject(new Error(`spawn-runner.sh exited with code ${code}\n${stderr}`));
+          reject(
+            new Error(`spawn-runner.sh exited with code ${code}\n${stderr}`),
+          );
         } else {
           resolve(stdout);
         }
       });
 
-      child.on('error', (err) => {
+      child.on("error", (err) => {
         reject(err);
       });
     });
@@ -200,7 +223,7 @@ beforeEach(async (context) => {
     const awsRegionMatch = output.match(/AWS_REGION=(.+)/);
 
     if (!publicIpMatch || !instanceIdMatch || !awsRegionMatch) {
-      throw new Error('Failed to parse spawn-runner.sh output');
+      throw new Error("Failed to parse spawn-runner.sh output");
     }
 
     const publicIp = publicIpMatch[1].trim();
@@ -215,7 +238,7 @@ beforeEach(async (context) => {
 
     console.log(`[TestDriver] Instance spawned: ${instanceId} at ${publicIp}`);
   } catch (error) {
-    console.error('[TestDriver] Failed to spawn AWS instance:', error.message);
+    console.error("[TestDriver] Failed to spawn AWS instance:", error.message);
     throw error;
   }
 });

package/package.json

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

package/sdk.d.ts

@@ -216,7 +216,7 @@ export interface TestDriverOptions {
   /** Sandbox resolution (default: '1366x768') */
   resolution?: string;
   /** Operating system for the sandbox (default: 'linux') */
-  os?: 'windows' | 'linux';
+  os?: "windows" | "linux";
   /** Enable analytics tracking (default: true) */
   analytics?: boolean;
   /** Enable console logging output (default: true) */
@@ -247,16 +247,18 @@ export interface TestDriverOptions {
   /** Enable/disable Dashcam video recording (default: true) */
   dashcam?: boolean;
   /** Redraw configuration for screen change detection */
-  redraw?: boolean | {
-    /** Enable redraw detection (default: true) */
-    enabled?: boolean;
-    /** Pixel difference threshold for redraw detection */
-    diffThreshold?: number;
-    /** Enable screen redraw detection */
-    screenRedraw?: boolean;
-    /** Enable network activity monitoring */
-    networkMonitor?: boolean;
-  };
+  redraw?:
+    | boolean
+    | {
+        /** Enable redraw detection (default: true) */
+        enabled?: boolean;
+        /** Pixel difference threshold for redraw detection */
+        diffThreshold?: number;
+        /** Enable screen redraw detection */
+        screenRedraw?: boolean;
+        /** Enable network activity monitoring */
+        networkMonitor?: boolean;
+      };
   /** @deprecated Use redraw.diffThreshold instead */
   redrawThreshold?: number | object;
   /** Additional environment variables */
@@ -277,7 +279,7 @@ export interface ConnectOptions {
   /** EC2 instance type for sandbox (e.g., 'i3.metal') */
   sandboxInstance?: string;
   /** Operating system for the sandbox (default: 'linux') */
-  os?: 'windows' | 'linux';
+  os?: "windows" | "linux";
   /** Run in headless mode (default: false) */
   headless?: boolean;
   /** Reuse recent connection if available (default: true) */
@@ -498,6 +500,36 @@ export interface ExecOptions {
   silent?: boolean;
 }
 
+/** Options for captcha command */
+export interface CaptchaOptions {
+  /** 2captcha API key (required) */
+  apiKey: string;
+  /** Override auto-detected sitekey */
+  sitekey?: string;
+  /** Captcha type: 'recaptcha_v2', 'recaptcha_v3', 'hcaptcha', 'turnstile' */
+  type?: string;
+  /** reCAPTCHA v3 action (default: 'verify') */
+  action?: string;
+  /** Whether to auto-submit the form (default: true) */
+  autoSubmit?: boolean;
+  /** Polling interval in ms for 2captcha (default: 5000) */
+  pollInterval?: number;
+  /** Max time in ms to wait for solution (default: 120000) */
+  timeout?: number;
+}
+
+/** Result of captcha solving */
+export interface CaptchaResult {
+  /** Whether the captcha was solved successfully */
+  success: boolean;
+  /** Success/error message */
+  message: string;
+  /** The solved captcha token */
+  token: string | null;
+  /** Raw output from the solver script */
+  output: string;
+}
+
 /**
  * A Promise that resolves to an Element but also has chainable element methods.
  * This enables syntax like: await testdriver.find("button").click()
@@ -800,7 +832,7 @@ export default class TestDriverSDK {
   /**
    * The operating system of the sandbox
    */
-  readonly os: 'windows' | 'linux';
+  readonly os: "windows" | "linux";
 
   /**
    * Provision API for launching applications
@@ -844,7 +876,7 @@ export default class TestDriverSDK {
    */
   getLastSandboxId(): {
     sandboxId: string | null;
-    os: 'windows' | 'linux';
+    os: "windows" | "linux";
     ami: string | null;
     instanceType: string | null;
     timestamp: string | null;
@@ -879,7 +911,10 @@ export default class TestDriverSDK {
    * await element.click();
    */
   find(description: string, cacheThreshold?: number): ChainableElementPromise;
-  find(description: string, options?: { cacheThreshold?: number; cacheKey?: string; timeout?: number }): ChainableElementPromise;
+  find(
+    description: string,
+    options?: { cacheThreshold?: number; cacheKey?: string; timeout?: number },
+  ): ChainableElementPromise;
 
   /**
    * Find all elements matching a description
@@ -924,20 +959,23 @@ export default class TestDriverSDK {
    * Type text
    * @param text - Text to type
    * @param options - Options object with delay and secret
-   * 
+   *
    * @example
    * // Type regular text
    * await client.type('hello world');
-   * 
+   *
    * @example
    * // Type a password securely (not logged or stored)
    * await client.type(process.env.TD_PASSWORD, { secret: true });
-   * 
+   *
    * @example
    * // Type with custom delay
    * await client.type('slow typing', { delay: 100 });
    */
-  type(text: string | number, options?: { delay?: number; secret?: boolean }): Promise<void>;
+  type(
+    text: string | number,
+    options?: { delay?: number; secret?: boolean },
+  ): Promise<void>;
 
   /**
    * Wait for text to appear on screen
@@ -1081,7 +1119,10 @@ export default class TestDriverSDK {
    * @param direction - Direction to scroll (default: 'down')
    * @param options - Options object with amount
    */
-  scroll(direction?: ScrollDirection, options?: { amount?: number }): Promise<void>;
+  scroll(
+    direction?: ScrollDirection,
+    options?: { amount?: number },
+  ): Promise<void>;
 
   // Application Control
 
@@ -1112,6 +1153,12 @@ export default class TestDriverSDK {
    */
   extract(description: string): Promise<string>;
 
+  /**
+   * Solve a captcha on the current page using 2captcha service
+   * @param options - Captcha solving options
+   */
+  captcha(options: CaptchaOptions): Promise<CaptchaResult>;
+
   // Code Execution
 
   /**