@testdriverai/agent 7.8.0-test.38

package/lib/vitest/setup-aws.mjs

@@ -0,0 +1,247 @@
+/**
+ * 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({
+ *   test: {
+ *     setupFiles: [
+ *       'testdriverai/vitest/setup',
+ *       'testdriverai/vitest/setup-aws'
+ *     ],
+ *   },
+ * });
+ * ```
+ *
+ * Required environment variables:
+ * - AWS_ACCESS_KEY_ID
+ * - AWS_SECRET_ACCESS_KEY
+ * - AWS_REGION (default: us-east-2)
+ * - AWS_LAUNCH_TEMPLATE_ID
+ * - AMI_ID
+ */
+
+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);
+
+// Store instance info per test
+const testInstances = new Map();
+
+// Global object to share instance termination callbacks with hooks.mjs
+globalThis.__testdriverAWS = globalThis.__testdriverAWS || {
+  instances: testInstances,
+  /**
+   * Terminate the instance for a given test ID
+   * Called by hooks.mjs after dashcam.stop() completes
+   */
+  async terminateInstance(testId) {
+    const instanceInfo = testInstances.get(testId);
+    if (!instanceInfo) {
+      return; // No instance was spawned for this test
+    }
+
+    const { instanceId, awsRegion } = instanceInfo;
+
+    console.log(`[TestDriver] Terminating AWS instance: ${instanceId}`);
+
+    try {
+      execSync(
+        `aws ec2 terminate-instances --region "${awsRegion}" --instance-ids "${instanceId}"`,
+        {
+          encoding: "utf-8",
+          env: process.env,
+          stdio: "inherit",
+        },
+      );
+
+      console.log(`[TestDriver] Instance terminated: ${instanceId}`);
+    } catch (error) {
+      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);
+    }
+  },
+};
+
+/**
+ * Cleanup function to terminate all running instances
+ * Called on process exit to ensure no orphaned instances
+ */
+function cleanupAllInstances() {
+  if (testInstances.size === 0) {
+    return;
+  }
+
+  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",
+        },
+      );
+    } catch (error) {
+      console.error(
+        `[TestDriver] Failed to terminate instance ${instanceId}:`,
+        error.message,
+      );
+    }
+  }
+
+  testInstances.clear();
+}
+
+// Register cleanup handlers for various exit scenarios
+process.on("exit", cleanupAllInstances);
+process.on("SIGINT", () => {
+  cleanupAllInstances();
+  // Don't call process.exit here - let the signal handler do its job
+});
+process.on("SIGTERM", () => {
+  cleanupAllInstances();
+  // Don't call process.exit here - let the signal handler do its job
+});
+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") {
+    return;
+  }
+
+  // If TD_IP is already set, use it and skip spawning
+  if (process.env.TD_IP) {
+    console.log(`[TestDriver] Using existing instance at ${process.env.TD_IP}`);
+    context.ip = process.env.TD_IP;
+    return;
+  }
+
+  // If ip is provided via plugin options, skip spawning
+  const pluginIp = globalThis.__testdriverPlugin?.state?.testDriverOptions?.ip;
+  if (pluginIp) {
+    console.log(`[TestDriver] Using ip from plugin options: ${pluginIp}`);
+    context.ip = pluginIp;
+    return;
+  }
+
+  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",
+    );
+  }
+
+  // Check if AWS CLI is installed
+  try {
+    execSync("which aws", { stdio: "ignore" });
+  } catch (error) {
+    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}`,
+  );
+
+  try {
+    // Find the spawn-runner.sh script (relative to this file)
+    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], {
+        env: {
+          ...process.env,
+          AWS_REGION: process.env.AWS_REGION || "us-east-2",
+          RESOLUTION: process.env.RESOLUTION || "1920x1080",
+        },
+      });
+
+      let stdout = "";
+      let stderr = "";
+
+      // Stream stdout in real-time
+      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) => {
+        const str = data.toString();
+        process.stderr.write(str); // Show errors immediately
+        stderr += str;
+      });
+
+      child.on("close", (code) => {
+        if (code !== 0) {
+          reject(
+            new Error(`spawn-runner.sh exited with code ${code}\n${stderr}`),
+          );
+        } else {
+          resolve(stdout);
+        }
+      });
+
+      child.on("error", (err) => {
+        reject(err);
+      });
+    });
+
+    // Parse the output
+    const publicIpMatch = output.match(/PUBLIC_IP=(.+)/);
+    const instanceIdMatch = output.match(/INSTANCE_ID=(.+)/);
+    const awsRegionMatch = output.match(/AWS_REGION=(.+)/);
+
+    if (!publicIpMatch || !instanceIdMatch || !awsRegionMatch) {
+      throw new Error("Failed to parse spawn-runner.sh output");
+    }
+
+    const publicIp = publicIpMatch[1].trim();
+    const instanceId = instanceIdMatch[1].trim();
+    const awsRegion = awsRegionMatch[1].trim();
+
+    // Store instance info for this test
+    testInstances.set(testId, { publicIp, instanceId, awsRegion });
+
+    // Set IP on test context (not process.env to avoid conflicts in parallel tests)
+    context.ip = publicIp;
+    context.instanceId = instanceId;
+
+    console.log(`[TestDriver] Instance spawned: ${instanceId} at ${publicIp}`);
+  } catch (error) {
+    console.error("[TestDriver] Failed to spawn AWS instance:", error.message);
+    throw error;
+  }
+});
+
+// NOTE: No afterEach hook here!
+// Instance termination is now handled by hooks.mjs AFTER dashcam.stop() completes.
+// This ensures dashcam can properly stop before the instance is terminated.

package/lib/vitest/setup-self-hosted.mjs

@@ -0,0 +1,151 @@
+/**
+ * Vitest Setup File for 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({
+ *   test: {
+ *     setupFiles: [
+ *       'testdriverai/vitest/setup',
+ *       'testdriverai/vitest/setup-self-hosted'
+ *     ],
+ *   },
+ * });
+ * ```
+ * 
+ * Required environment variables:
+ * - AWS_ACCESS_KEY_ID
+ * - AWS_SECRET_ACCESS_KEY
+ * - AWS_REGION (default: us-east-2)
+ * - AWS_LAUNCH_TEMPLATE_ID
+ * - AMI_ID
+ */
+
+import { execSync } 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);
+
+// Store instance info per test
+const testInstances = new Map();
+
+// Global object to share instance termination callbacks with hooks.mjs
+// Use the same global as setup-aws.mjs for consistency
+if (!globalThis.__testdriverAWS) {
+  globalThis.__testdriverAWS = {
+    instances: testInstances,
+    /**
+     * Terminate the instance for a given test ID
+     * Called by hooks.mjs after dashcam.stop() completes
+     */
+    async terminateInstance(testId) {
+      const instanceInfo = testInstances.get(testId);
+      if (!instanceInfo) {
+        return; // No instance was spawned for this test
+      }
+
+      const { instanceId, awsRegion } = instanceInfo;
+
+      console.log(`[TestDriver] Terminating AWS instance: ${instanceId}`);
+
+      try {
+        execSync(
+          `aws ec2 terminate-instances --region "${awsRegion}" --instance-ids "${instanceId}"`,
+          {
+            encoding: 'utf-8',
+            env: process.env,
+            stdio: 'inherit',
+          }
+        );
+
+        console.log(`[TestDriver] Instance terminated: ${instanceId}`);
+      } catch (error) {
+        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);
+      }
+    }
+  };
+}
+
+beforeEach(async (context) => {
+  // Only spawn if TD_OS=windows (indicates Windows self-hosted mode)
+  if (process.env.TD_OS !== 'windows') {
+    return;
+  }
+
+  // If TD_IP is already set, use it and skip spawning
+  if (process.env.TD_IP) {
+    console.log(`[TestDriver] Using existing instance at ${process.env.TD_IP}`);
+    context.ip = process.env.TD_IP;
+    return;
+  }
+
+  // If ip is provided via plugin options, skip spawning
+  const pluginIp = globalThis.__testdriverPlugin?.state?.testDriverOptions?.ip;
+  if (pluginIp) {
+    console.log(`[TestDriver] Using ip from plugin options: ${pluginIp}`);
+    context.ip = pluginIp;
+    return;
+  }
+
+  // Verify AWS credentials are available
+  if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_LAUNCH_TEMPLATE_ID || !process.env.AMI_ID) {
+    throw new Error('[TestDriver] TD_OS=windows requires AWS credentials (AWS_ACCESS_KEY_ID, AWS_LAUNCH_TEMPLATE_ID, AMI_ID)');
+  }
+
+  const testId = context.task.id;
+  
+  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');
+    
+    // Execute spawn-runner.sh
+    const output = execSync(`sh ${spawnScriptPath}`, {
+      encoding: 'utf-8',
+      env: {
+        ...process.env,
+        AWS_REGION: process.env.AWS_REGION || 'us-east-2',
+        RESOLUTION: process.env.RESOLUTION || '1920x1080',
+      },
+      stdio: ['pipe', 'pipe', 'inherit'], // Inherit stderr for real-time logs
+    });
+
+    // Parse the output
+    const publicIpMatch = output.match(/PUBLIC_IP=(.+)/);
+    const instanceIdMatch = output.match(/INSTANCE_ID=(.+)/);
+    const awsRegionMatch = output.match(/AWS_REGION=(.+)/);
+
+    if (!publicIpMatch || !instanceIdMatch || !awsRegionMatch) {
+      throw new Error('Failed to parse spawn-runner.sh output');
+    }
+
+    const publicIp = publicIpMatch[1].trim();
+    const instanceId = instanceIdMatch[1].trim();
+    const awsRegion = awsRegionMatch[1].trim();
+
+    // Store instance info for this test (use global's map)
+    globalThis.__testdriverAWS.instances.set(testId, { publicIp, instanceId, awsRegion });
+
+    // Set IP on test context (not process.env to avoid conflicts in parallel tests)
+    context.ip = publicIp;
+
+    console.log(`[TestDriver] Instance spawned: ${instanceId} at ${publicIp}`);
+  } catch (error) {
+    console.error('[TestDriver] Failed to spawn AWS instance:', error.message);
+    throw error;
+  }
+});
+
+// NOTE: No afterEach hook here!
+// Instance termination is now handled by hooks.mjs AFTER dashcam.stop() completes.
+// This ensures dashcam can properly stop before the instance is terminated.

package/lib/vitest/setup.mjs

@@ -0,0 +1,46 @@
+/**
+ * Vitest Setup File for TestDriver
+ * 
+ * This file is run by Vitest before each test file to set up
+ * the TestDriver plugin state and global helpers.
+ * 
+ * Usage in vitest.config.mjs:
+ * ```js
+ * export default defineConfig({
+ *   test: {
+ *     setupFiles: ['testdriverai/vitest/setup'],
+ *   },
+ * });
+ * ```
+ */
+
+import {
+    clearDashcamUrls,
+    clearSuiteTestRun,
+    getAllDashcamUrls,
+    getDashcamUrl,
+    getPluginState,
+    getSuiteTestRun,
+    pluginState,
+    registerDashcamUrl,
+    setSuiteTestRun,
+} from '../../interfaces/vitest-plugin.mjs';
+
+// Set up global TestDriver plugin interface
+// This allows tests and the SDK to communicate with the reporter
+globalThis.__testdriverPlugin = {
+  state: pluginState,
+  registerDashcamUrl,
+  getDashcamUrl,
+  getAllDashcamUrls,
+  clearDashcamUrls,
+  getPluginState,
+  getSuiteTestRun,
+  setSuiteTestRun,
+  clearSuiteTestRun,
+};
+
+// Log that setup is complete (only in debug mode)
+if (process.env.TD_LOG_LEVEL?.toLowerCase() === 'debug') {
+  console.log('[TestDriver] Setup file initialized, global plugin interface available');
+}

package/manual/captcha-api.test.mjs

@@ -0,0 +1,51 @@
+/**
+ * Test for testdriver.captcha() API
+ * Clean, simple API for solving captchas
+ */
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../lib/vitest/hooks.mjs";
+import { getDefaults } from "./config.mjs";
+
+console.log("DEBUG: process.env.TD_OS:", process.env.TD_OS);
+
+describe("testdriver.captcha() API", () => {
+  it("should solve reCAPTCHA v3 with auto-detect", async (context) => {
+    const testdriver = TestDriver(context, { ...getDefaults(context) });
+
+    // Launch Chrome (remote debugging is enabled automatically on Linux)
+    await testdriver.provision.chrome({
+      url: "https://2captcha.com/demo/recaptcha-v3",
+    });
+
+    await testdriver.screenshot();
+
+    // Solve the captcha with just the API key - everything else is auto-detected!
+    const result = await testdriver.captcha({
+      apiKey: process.env.TWOCAPTCHA_API_KEY,
+    });
+
+    console.log("Captcha result:", result);
+    await testdriver.screenshot();
+
+    expect(result.success).toBe(true);
+  }, 180000);
+
+  it("should solve Cloudflare Turnstile", async (context) => {
+    const testdriver = TestDriver(context, { ...getDefaults(context) });
+
+    await testdriver.provision.chrome({
+      url: "https://2captcha.com/demo/cloudflare-turnstile",
+    });
+
+    await testdriver.screenshot();
+
+    const result = await testdriver.captcha({
+      apiKey: process.env.TWOCAPTCHA_API_KEY,
+    });
+
+    console.log("Turnstile result:", result);
+    await testdriver.screenshot();
+
+    expect(result.success).toBe(true);
+  }, 180000);
+});

package/manual/drag-and-drop.test.mjs

@@ -0,0 +1,59 @@
+/**
+ * TestDriver SDK - Drag and Drop Test (Vitest)
+ * Converted from: testdriver/acceptance/drag-and-drop.yaml
+ */
+
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../lib/vitest/hooks.mjs";
+import { getDefaults } from "./config.mjs";
+
+const isLinux = (process.env.TD_OS || "linux") === "linux";
+
+describe("Drag and Drop Test", () => {
+  it.skipIf(isLinux)(
+    'should drag "New Text Document" to "Recycle Bin"',
+    async (context) => {
+      const testdriver = TestDriver(context, { ...getDefaults(context), headless: true });
+      await testdriver.provision.chrome({ url: 'http://testdriver-sandbox.vercel.app/login' });
+
+      //
+      // Show the desktop
+      await testdriver.pressKeys(["win", "d"]);
+
+      // Open the context menu
+      await testdriver.pressKeys(["shift", "f10"]);
+
+      // Hover over "New" in the context menu
+      const newOption = await testdriver.find(
+        "New, new option in the open context menu on the desktop",
+      );
+      await newOption.hover();
+
+      // Click "Text Document" in the context menu
+      const textDocOption = await testdriver.find(
+        "Text Document, text document option in the new submenu of the desktop context menu",
+      );
+      await textDocOption.click();
+
+      // Unfocus the "Text Document" text field
+      await testdriver.pressKeys(["esc"]);
+
+      // Drag the "New Text Document" icon to the "Recycle Bin"
+      const textDoc = await testdriver.find(
+        "New Text Document, new text document icon in the center of the desktop",
+      );
+      await textDoc.mouseDown();
+
+      const recycleBin = await testdriver.find(
+        "Recycle Bin, recycle bin icon in the top left corner of the desktop",
+      ).hover();
+      await recycleBin.mouseUp();
+
+      // Assert "New Text Document" icon is not on the Desktop
+      const result = await testdriver.assert(
+        'the "New Text Document" icon is not visible on the Desktop',
+      );
+      expect(result).toBeTruthy();
+    },
+  );
+});

package/manual/flake-diffthreshold-001.test.mjs

@@ -0,0 +1,9 @@
+/**
+ * Popup Loading - diffThreshold=0.01, cache=true
+ */
+import { popupLoadingTest } from "./flake-shared.mjs";
+
+popupLoadingTest("screen=0.01, cache=true", {
+  redraw: { enabled: true, thresholds: { screen: 0.01 } },
+  cache: true,
+});

package/manual/flake-diffthreshold-01.test.mjs

@@ -0,0 +1,9 @@
+/**
+ * Popup Loading - diffThreshold=0.1, cache=false
+ */
+import { popupLoadingTest } from "./flake-shared.mjs";
+
+popupLoadingTest("screen=0.1, cache=false", {
+  redraw: { enabled: true, thresholds: { screen: 0.1 } },
+  cache: false,
+});

package/manual/flake-diffthreshold-05.test.mjs

@@ -0,0 +1,9 @@
+/**
+ * Popup Loading - diffThreshold=0.5, cache=true
+ */
+import { popupLoadingTest } from "./flake-shared.mjs";
+
+popupLoadingTest("screen=0.5, cache=true", {
+  redraw: { enabled: true, thresholds: { screen: 0.5 } },
+  cache: true,
+});

package/manual/flake-noredraw-cache.test.mjs

@@ -0,0 +1,9 @@
+/**
+ * Popup Loading - redraw=false, cache=true
+ */
+import { popupLoadingTest } from "./flake-shared.mjs";
+
+popupLoadingTest("redraw=false, cache=true", {
+  redraw: { enabled: false },
+  cache: true,
+});

package/manual/flake-noredraw-nocache.test.mjs

@@ -0,0 +1,9 @@
+/**
+ * Popup Loading - redraw=false, cache=false
+ */
+import { popupLoadingTest } from "./flake-shared.mjs";
+
+popupLoadingTest("redraw=false, cache=false", {
+  redraw: { enabled: false },
+  cache: false,
+});

package/manual/flake-redraw-cache.test.mjs

@@ -0,0 +1,9 @@
+/**
+ * Popup Loading - redraw=true, cache=true
+ */
+import { popupLoadingTest } from "./flake-shared.mjs";
+
+popupLoadingTest("redraw=true, cache=true", {
+  redraw: { enabled: true },
+  cache: true,
+});

package/manual/flake-redraw-nocache.test.mjs

@@ -0,0 +1,9 @@
+/**
+ * Popup Loading - redraw=true, cache=false
+ */
+import { popupLoadingTest } from "./flake-shared.mjs";
+
+popupLoadingTest("redraw=true, cache=false", {
+  redraw: { enabled: true },
+  cache: false,
+});

package/manual/flake-rocket-match.test.mjs

@@ -0,0 +1,30 @@
+/**
+ * Popup Loading - Skip straight to the rocket match (skipToIcons=true)
+ */
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../lib/vitest/hooks.mjs";
+
+describe("Rocket Match (skipToIcons)", () => {
+  it("should find the rocket in the icon grid", async (context) => {
+    const testdriver = TestDriver(context, {
+      preview: "ide",
+      ip: context.ip || process.env.TD_IP,
+    });
+
+    await testdriver.provision.chrome({
+      url: "https://v0-popup-with-loading-bar.vercel.app/?skipToIcons=true",
+    });
+
+    // Wait for the 5x5 grid of images to fully load and click the rocket
+    await testdriver.find("The icon of a rocket in the 5x5 grid of images", {
+      timeout: 60000,
+      zoom: 1,
+    }).click();
+
+    // Assert the success message appears
+    const rocketResult = await testdriver.assert(
+      "The text 'You found the rocket!' is visible on the page"
+    );
+    expect(rocketResult).toBeTruthy();
+  });
+});