@testdriverai/agent 7.8.0-test.38

package/test/manual/reconnect-provision.test.mjs

@@ -0,0 +1,49 @@
+/**
+ * TestDriver SDK - Reconnect Test Part 1: Provision
+ * 
+ * This test provisions a new sandbox and navigates to the login page.
+ * The sandbox ID is saved to .testdriver/last-sandbox for the next test.
+ * 
+ * The sandbox has keepAlive: 120000 (2 minutes) after disconnect.
+ * Run reconnect-signin.test.mjs within 2 minutes of this test completing.
+ * 
+ * Usage:
+ *   1. npm test -- examples/reconnect-provision.test.mjs
+ *   2. (within 2 minutes) examples/reconnect-signin.test.mjs
+ */
+
+import { afterAll, describe, expect, it } from "vitest";
+import { TestDriver } from "../../lib/vitest/hooks.mjs";
+
+describe("Reconnect Test - Part 1: Provision", () => {
+
+  afterAll(async () => {
+    // Explicitly DO NOT disconnect - we want the sandbox to stay alive
+    // for the reconnect test. The sandbox will auto-terminate after keepAlive TTL.
+    console.log("\n⚠️  NOT disconnecting - sandbox will stay alive for ~2 minutes (keepAlive: 120000)");
+    console.log("   Run reconnect-signin.test.mjs within 2 minutes to test reconnect\n");
+  });
+
+  it("should provision sandbox and navigate to login page", async (context) => {
+
+    const testdriver = TestDriver(context, { newSandbox: true, headless: false });
+    
+    // Provision Chrome and navigate to login page
+    await testdriver.provision.chrome({
+      url: 'http://testdriver-sandbox.vercel.app/login',
+    });
+
+
+    // Verify we're on the login page
+    const result = await testdriver.assert("I can see a Sign In button");
+    expect(result).toBeTruthy();
+
+    // Get the sandbox ID that was saved
+    const lastSandbox = testdriver.getLastSandboxId();
+    console.log("\n✅ Sandbox provisioned:", lastSandbox?.sandboxId);
+    console.log("   Sandbox info saved to .testdriver/last-sandbox");
+    
+    expect(lastSandbox).toBeTruthy();
+    expect(lastSandbox.sandboxId).toBeTruthy();
+  });
+});

package/test/manual/test-console-logs.test.mjs

@@ -0,0 +1,42 @@
+/**
+ * TestDriver SDK - Console Log Test
+ * Tests that console.log statements are captured and sent to dashcam
+ */
+
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../../lib/vitest/hooks.mjs";
+
+describe("Console Log Test", () => {
+  it("should capture console logs and send them to dashcam", async (context) => {
+    console.log("🎬 Test starting - this should appear in dashcam");
+    
+    const testdriver = TestDriver(context, { headless: true });
+    await testdriver.provision.chrome({ url: 'http://testdriver-sandbox.vercel.app/login' });
+
+    console.log("✅ Chrome launched successfully");
+
+    // Give Chrome a moment to fully render the UI
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    console.log("🔍 Looking for Sign In button");
+
+    // Find and click the sign in button
+    const signInButton = await testdriver.find(
+      "Sign In, black button below the password field",
+    );
+    
+    console.log("👆 Clicking Sign In button");
+    await signInButton.click();
+    
+    console.log("🧪 Asserting error message appears");
+
+    // Assert error shows
+    const result = await testdriver.assert(
+      "an error shows that fields are required",
+    );
+    
+    console.log("✅ Test completed successfully - all logs should be in dashcam");
+    
+    expect(result).toBeTruthy();
+  });
+});

package/test/manual/test-find-api.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+/**
+ * Quick test of the new find() API
+ * This is a simple smoke test to verify the Element class works
+ */
+
+const TestDriver = require("../sdk");
+
+async function testFindAPI() {
+  console.log("Testing new find() API...\n");
+
+  const client = new TestDriver("test-key", {
+    logging: false,
+  });
+
+  // Test 1: Create element without connecting
+  console.log("✓ Test 1: Creating Element instance");
+  const element = client.find("test element");
+  console.log("  Element description:", element.description);
+  console.log("  Element found():", element.found());
+  console.log("  Element coordinates:", element.getCoordinates());
+
+  // Test 2: Verify element methods exist
+  console.log("\n✓ Test 2: Verifying Element methods");
+  console.log("  Has find():", typeof element.find === "function");
+  console.log("  Has click():", typeof element.click === "function");
+  console.log("  Has hover():", typeof element.hover === "function");
+  console.log(
+    "  Has doubleClick():",
+    typeof element.doubleClick === "function",
+  );
+  console.log("  Has rightClick():", typeof element.rightClick === "function");
+  console.log("  Has mouseDown():", typeof element.mouseDown === "function");
+  console.log("  Has mouseUp():", typeof element.mouseUp === "function");
+  console.log("  Has found():", typeof element.found === "function");
+  console.log(
+    "  Has getCoordinates():",
+    typeof element.getCoordinates === "function",
+  );
+
+  // Test 3: Verify error handling for clicking unfound element
+  console.log("\n✓ Test 3: Error handling for unfound element");
+  try {
+    await element.click();
+    console.log("  ❌ Should have thrown error");
+  } catch (error) {
+    console.log("  ✓ Correctly throws error:", error.message);
+  }
+
+  // Test 4: Verify TypeScript types exist (if running from TypeScript)
+  console.log("\n✓ Test 4: SDK methods");
+  console.log("  Has find():", typeof client.find === "function");
+  console.log(
+    "  Has deprecated hoverText():",
+    typeof client.hoverText === "undefined" ? "not yet connected" : "exists",
+  );
+  console.log(
+    "  Has deprecated waitForText():",
+    typeof client.waitForText === "undefined" ? "not yet connected" : "exists",
+  );
+
+  console.log("\n✅ All basic tests passed!");
+  console.log(
+    "\nNote: Full integration tests require connection to TestDriver sandbox.",
+  );
+  console.log("See examples/sdk-find-example.js for complete usage examples.");
+}
+
+testFindAPI().catch((error) => {
+  console.error("Test failed:", error);
+  process.exit(1);
+});

package/test/manual/test-init.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+
+# Test script for the init command
+# Usage: ./test-init.sh
+
+set -e
+
+echo "🧪 Testing testdriverai init command..."
+echo ""
+
+# Cleanup function
+cleanup() {
+  echo "🧹 Cleaning up test directories..."
+  rm -rf /tmp/testdriver-test-*
+}
+
+trap cleanup EXIT
+
+# Test 1: Full init with all features
+echo "1️⃣  Testing full initialization (package.json, tests, workflow, npm install)..."
+cd /tmp
+mkdir -p testdriver-test-init
+cd testdriver-test-init
+node /Users/ianjennings/Development/cli/bin/testdriverai.js init
+echo ""
+echo "✅ Files created:"
+find . -type f -not -path "./node_modules/*" | sort
+echo ""
+echo "📄 package.json:"
+cat package.json
+echo ""
+echo "📄 vitest.config.js:"
+cat vitest.config.js
+echo ""
+echo "📄 GitHub workflow:"
+cat .github/workflows/testdriver.yml
+echo ""
+echo "📄 First 15 lines of tests/example.test.js:"
+head -15 tests/example.test.js
+echo ""
+echo "📦 Installed dependencies:"
+npm list --depth=0
+echo ""
+echo "---"
+echo ""
+
+# Test 2: Help command
+echo "2️⃣  Testing help command..."
+node /Users/ianjennings/Development/cli/bin/testdriverai.js init --help
+echo ""
+echo "---"
+echo ""
+
+echo "✅ All tests passed!"

package/test/manual/test-prompt-cache.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test to verify prompt caching functionality
+ *
+ * This test demonstrates that:
+ * 1. First .prompt() call makes an API request and caches the YAML response
+ * 2. Second .prompt() call with the same prompt uses the cached YAML
+ * 3. Cache can be disabled with TD_NO_PROMPT_CACHE=true
+ */
+
+const TestDriver = require("./sdk.js");
+const promptCache = require("./agent/lib/cache.js");
+
+async function testPromptCache() {
+  console.log("Testing prompt caching functionality...\n");
+
+  // API key loaded automatically from .env
+  const client = new TestDriver({
+    os: "linux",
+    logging: true,
+  });
+
+  try {
+    // Connect to sandbox
+    console.log("Connecting to sandbox...");
+    await client.connect();
+    console.log("Connected!\n");
+
+    const testPrompt = "click the search button";
+
+    // Clear cache for this prompt to start fresh
+    const cachePath = promptCache.getCachePath(testPrompt);
+    console.log(`Cache path for "${testPrompt}": ${cachePath}\n`);
+
+    // Test 1: First call (should make API request and cache)
+    console.log("Test 1: First .ai() call (should cache the response)");
+    const stats1 = promptCache.getCacheStats();
+    console.log(`Cache before: ${stats1.count} files`);
+
+    await client.ai(testPrompt);
+
+    const stats2 = promptCache.getCacheStats();
+    console.log(`Cache after: ${stats2.count} files`);
+    console.log(
+      `Cache hit: ${promptCache.hasCache(testPrompt) ? "YES" : "NO"}\n`,
+    );
+
+    // Test 2: Second call (should use cache)
+    console.log(
+      "Test 2: Second .ai() call with same prompt (should use cache)",
+    );
+    console.log('Look for "(using cached response)" message above...\n');
+    await client.ai(testPrompt);
+
+    // Test 3: Third call with cache disabled (should make API call)
+    console.log(
+      "\nTest 3: Third .ai() call with cache=false (should bypass cache)",
+    );
+    await client.ai(testPrompt, false);
+
+    // Test 4: Show cache contents
+    console.log("\nTest 4: Cache contents");
+    const cachedYaml = promptCache.readCache(testPrompt);
+    if (cachedYaml) {
+      console.log("Cached YAML preview (first 500 chars):");
+      console.log(cachedYaml.substring(0, 500));
+      console.log("...\n");
+    }
+
+    // Test 5: Cache statistics
+    console.log("Test 5: Cache statistics");
+    const finalStats = promptCache.getCacheStats();
+    console.log(`Total cached prompts: ${finalStats.count}`);
+    console.log(`Cache files:`, finalStats.files.slice(0, 5));
+
+    console.log("\n✅ Prompt caching test completed!");
+    console.log("\nTo disable caching, pass false: client.ai(prompt, false)");
+    console.log("To clear cache, delete .testdriver/.cache/*.yaml files");
+  } catch (error) {
+    console.error("❌ Test failed:", error.message);
+    throw error;
+  } finally {
+    // Disconnect
+    await client.disconnect();
+  }
+}
+
+// Run the test
+if (require.main === module) {
+  testPromptCache().catch((error) => {
+    console.error("Test error:", error);
+    process.exit(1);
+  });
+}
+
+module.exports = testPromptCache;

package/test/manual/test-provision-auth.mjs

@@ -0,0 +1,22 @@
+/**
+ * Quick test to verify provision() authentication works
+ */
+
+import { test } from 'vitest';
+import { provision } from '../../lib/presets/index.mjs';
+
+test('provision auth test', async (context) => {
+  console.log('Starting provision...');
+  
+  const { testdriver, dashcam } = await provision('chrome', {
+    url: 'http://testdriver-sandbox.vercel.app/',
+  }, context);
+  
+  console.log('✅ Provision complete!');
+  console.log('TestDriver:', testdriver);
+  console.log('Dashcam:', dashcam);
+  
+  // Try a simple find
+  const result = await testdriver.find('any element');
+  console.log('Find result:', result);
+});

package/test/manual/test-sandbox-render.js

@@ -0,0 +1,29 @@
+const TestDriver = require("./sdk.js");
+
+async function test() {
+  console.log("Testing sandbox rendering...");
+
+  // API key loaded automatically from .env
+  const client = new TestDriver({
+    os: process.env.TEST_PLATFORM || "linux",
+    headless: false, // Should open browser
+    logging: true,
+  });
+
+  try {
+    console.log("Connecting to sandbox...");
+    const instance = await client.connect();
+    console.log("Connected to instance:", instance);
+
+    // Wait a bit to see if browser opens
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+
+    await client.disconnect();
+    console.log("Test completed successfully");
+  } catch (error) {
+    console.error("Test failed:", error);
+    process.exit(1);
+  }
+}
+
+test();

package/test/manual/test-sdk-methods.js

@@ -0,0 +1,15 @@
+const SDK = require("./sdk.js");
+
+const client = new SDK("test-key");
+
+// Get all public methods (non-private, non-constructor)
+const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(client))
+  .filter((m) => !m.startsWith("_") && m !== "constructor")
+  .sort();
+
+console.log("Public SDK Methods:");
+console.log(methods.join(", "));
+console.log("\nTotal:", methods.length, "methods");
+
+// Check if commands will be set up after connect
+console.log("\nCommands before connect:", client.commands);

package/test/manual/test-sdk-refactor.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+/**
+ * Quick test to verify SDK refactoring works correctly
+ */
+
+const TestDriver = require("./sdk.js");
+
+async function test() {
+  console.log("Testing SDK refactor...\n");
+
+  // Test 1: SDK construction (API key loaded automatically from .env)
+  console.log("✓ Test 1: Creating SDK instance");
+  const client = new TestDriver({
+    logging: false,
+  });
+
+  console.log("  - agent exists:", !!client.agent);
+  console.log("  - emitter exists:", !!client.emitter);
+  console.log("  - config exists:", !!client.config);
+  console.log("  - session exists:", !!client.session);
+  console.log("  - apiClient exists:", !!client.apiClient);
+  console.log("  - analytics exists:", !!client.analytics);
+  console.log("  - sandbox exists:", !!client.sandbox);
+  console.log("  - system exists:", !!client.system);
+
+  // Test 2: Check agent methods are accessible
+  console.log("\n✓ Test 2: Checking agent methods");
+  console.log(
+    "  - agent.exploratoryLoop exists:",
+    typeof client.agent.exploratoryLoop,
+  );
+  console.log("  - agent.buildEnv exists:", typeof client.agent.buildEnv);
+  console.log(
+    "  - agent.getRecentSandboxId exists:",
+    typeof client.agent.getRecentSandboxId,
+  );
+
+  // Test 3: Check SDK methods
+  console.log("\n✓ Test 3: Checking SDK methods");
+  console.log("  - ai() exists:", typeof client.ai);
+  console.log("  - auth() exists:", typeof client.auth);
+  console.log("  - connect() exists:", typeof client.connect);
+  console.log("  - disconnect() exists:", typeof client.disconnect);
+
+  console.log("\n✅ All basic tests passed!");
+}
+
+test().catch((error) => {
+  console.error("\n❌ Test failed:", error.message);
+  console.error(error.stack);
+  process.exit(1);
+});

package/test/manual/test-stack-trace.mjs

@@ -0,0 +1,57 @@
+/**
+ * Quick test to verify stack trace filtering works
+ */
+
+// Mock the MatchError similar to commands.js
+class MatchError extends Error {
+  constructor(message, fatal = false) {
+    super(message);
+    this.fatal = fatal;
+    this.attachScreenshot = true;
+  }
+}
+
+// Simulate SDK wrapper with stack filtering (improved version)
+class TestSDK {
+  constructor() {
+    const command = async (message) => {
+      // Simulate the command throwing an error
+      throw new MatchError(`AI Assertion failed: ${message}`, true);
+    };
+
+    // Wrap the method with proper stack trace handling
+    this.assert = async function (...args) {
+      // Capture the call site for better error reporting
+      const callSite = {};
+      Error.captureStackTrace(callSite, this.assert);
+
+      try {
+        return await command(...args);
+      } catch (error) {
+        // Replace the stack trace to point to the actual caller
+        if (Error.captureStackTrace && callSite.stack) {
+          const errorMessage = error.stack?.split("\n")[0];
+          const callerStack = callSite.stack?.split("\n").slice(1);
+          error.stack = errorMessage + "\n" + callerStack.join("\n");
+        }
+        throw error;
+      }
+    }.bind(this);
+  }
+}
+
+// Test it
+async function runTest() {
+  const client = new TestSDK();
+
+  try {
+    console.log("Testing stack trace...\n");
+    await client.assert("home page appears"); // Line 42 - this should show in stack
+  } catch (error) {
+    console.log("Error caught!");
+    console.log("Stack trace:");
+    console.log(error.stack);
+  }
+}
+
+runTest();

package/test/manual/verify-element-api.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+/**
+ * Verify Element class API
+ * Tests that all expected methods and properties are available
+ */
+
+async function verify() {
+  // Create a test element instance - need to access Element class directly
+  const { Element } = require("./sdk.js");
+  const elem = new Element("test", null, null, null);
+
+  console.log("Verifying Element class API...\n");
+
+  // Check methods exist
+  const methods = [
+    "find",
+    "found",
+    "click",
+    "hover",
+    "doubleClick",
+    "rightClick",
+    "mouseDown",
+    "mouseUp",
+    "getCoordinates",
+    "getResponse",
+  ];
+
+  let passed = 0;
+  let failed = 0;
+
+  console.log("Testing methods:");
+  methods.forEach((method) => {
+    if (typeof elem[method] === "function") {
+      console.log(`  ✓ ${method}()`);
+      passed++;
+    } else {
+      console.log(`  ✗ ${method}() - MISSING`);
+      failed++;
+    }
+  });
+
+  // Test property getters (should return null when element not found)
+  const props = [
+    "x",
+    "y",
+    "centerX",
+    "centerY",
+    "width",
+    "height",
+    "confidence",
+    "screenshot",
+    "boundingBox",
+    "text",
+    "label",
+  ];
+
+  console.log("\nTesting properties (should be null when not found):");
+  props.forEach((prop) => {
+    if (prop in elem) {
+      const value = elem[prop];
+      if (value === null) {
+        console.log(`  ✓ ${prop} = null`);
+        passed++;
+      } else {
+        console.log(`  ✗ ${prop} = ${value} (expected null)`);
+        failed++;
+      }
+    } else {
+      console.log(`  ✗ ${prop} - MISSING`);
+      failed++;
+    }
+  });
+
+  console.log("\n" + "=".repeat(50));
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  console.log("=".repeat(50));
+
+  if (failed > 0) {
+    process.exit(1);
+  } else {
+    console.log("\n✅ All Element API verification tests passed!");
+  }
+}
+
+verify().catch((err) => {
+  console.error("Error:", err);
+  process.exit(1);
+});

package/test/manual-unawaited-promise.test.mjs

@@ -0,0 +1,31 @@
+/**
+ * Manual test to verify unawaited promise detection
+ * 
+ * Run with: vitest run test/manual-unawaited-promise.test.mjs
+ * 
+ * Expected: You should see a warning like:
+ * ⚠️  Warning: Previous find() may not have been awaited.
+ */
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../lib/vitest/hooks.mjs";
+
+describe("Unawaited Promise Detection", () => {
+  it("should warn when a promise is not awaited", async (context) => {
+    const testdriver = TestDriver(context);
+    
+    await testdriver.provision.chrome({
+      url: 'https://example.com',
+    });
+
+    // INTENTIONALLY missing await - should trigger warning on next call
+    testdriver.find("some button");
+    
+    // This second call should print a warning about the previous unawaited find()
+    const element = await testdriver.find("Example Domain heading");
+    
+    console.log("Element found:", element.found());
+    
+    // If we got here without error and saw the warning, the feature works!
+    expect(true).toBeTruthy();
+  });
+});

package/vitest.config.mjs

@@ -0,0 +1,58 @@
+import TestDriver from "testdriverai/vitest";
+import { defineConfig } from "vitest/config";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const { resolveEnv, getEnvironmentNames } = require("../shared/resolve-env");
+
+// Always include AWS setup - it will be a no-op unless TD_OS=windows
+// Note: dotenv is loaded automatically by the TestDriver SDK
+const setupFiles = [
+  "testdriverai/vitest/setup",
+  "testdriverai/vitest/setup-aws"
+];
+
+const sharedTestConfig = {
+  retry: 0,
+  testTimeout: 900000,
+  hookTimeout: 900000,
+  maxConcurrency: 100,
+  disableConsoleIntercept: false,
+  silent: false,
+  reporters: [
+    "verbose",
+    TestDriver()
+  ],
+  setupFiles,
+  include: ["examples/**/*.test.mjs"],
+};
+
+// ── Resolve env vars via shared/resolve-env.js ──────────────────────
+// Uses: environments.json (URLs) + envs/{env}.env (overlay) + fixtures (API keys)
+// TD_PLAN selects which plan's API key to use (default: enterprise)
+const plan = process.env.TD_PLAN || "enterprise";
+const defaultEnv = process.env.TD_ENV || "dev";
+const environments = getEnvironmentNames();
+
+// Apply default env to the main process so the reporter/plugin picks it up
+// (vitest's test.env only propagates to worker processes, not the main process)
+const defaultResolved = resolveEnv(defaultEnv, plan);
+Object.assign(process.env, defaultResolved);
+
+// ── Usage ───────────────────────────────────────────────────────────
+// TD_PLAN=enterprise vitest run --project dev
+// TD_PLAN=free vitest run --project test examples/assert.test.mjs
+// vitest run --project canary --project stable
+export default defineConfig({
+  test: {
+    ...sharedTestConfig,
+    env: defaultResolved,
+    projects: environments.map((envName) => ({
+      extends: true,
+      test: {
+        name: envName,
+        env: resolveEnv(envName, plan),
+      },
+    })),
+  },
+});