testdriverai 7.3.2 → 7.3.4

package/test/captcha-solver.test.mjs

@@ -0,0 +1,152 @@
+/**
+ * Unit tests for the captcha solver script
+ * These tests verify the solver script is valid JavaScript and can be loaded correctly
+ */
+import { describe, expect, it } from "vitest";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import vm from "vm";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const solverPath = path.join(__dirname, "..", "lib", "captcha", "solver.js");
+
+// Extract safeParseJson function from the solver script for testing
+function getSafeParseJson() {
+  const script = fs.readFileSync(solverPath, "utf8");
+  // Extract the safeParseJson function source
+  const funcMatch = script.match(
+    /function safeParseJson\(text\) \{[\s\S]*?^}/m,
+  );
+  if (!funcMatch) {
+    throw new Error("Could not find safeParseJson function in solver script");
+  }
+  // Create and return the function
+  const func = new Function("return " + funcMatch[0])();
+  return func;
+}
+
+describe("Captcha Solver Script", () => {
+  it("should exist", () => {
+    expect(fs.existsSync(solverPath)).toBe(true);
+  });
+
+  it("should be valid JavaScript syntax", () => {
+    const script = fs.readFileSync(solverPath, "utf8");
+
+    // This will throw if the syntax is invalid
+    expect(() => {
+      new vm.Script(script, { filename: "solver.js" });
+    }).not.toThrow();
+  });
+
+  it("should contain required functions and variables", () => {
+    const script = fs.readFileSync(solverPath, "utf8");
+
+    // Check for key components
+    expect(script).toContain('require("https")');
+    expect(script).toContain('require("chrome-remote-interface")');
+    expect(script).toContain("detectCaptchaScript");
+    expect(script).toContain("getInjectScript");
+    expect(script).toContain("autoSubmitScript");
+    expect(script).toContain("checkSuccessScript");
+    expect(script).toContain("2captcha.com");
+  });
+
+  it("should handle all supported captcha types", () => {
+    const script = fs.readFileSync(solverPath, "utf8");
+
+    // Check for captcha type handling
+    expect(script).toContain("recaptcha_v2");
+    expect(script).toContain("recaptcha_v3");
+    expect(script).toContain("hcaptcha");
+    expect(script).toContain("turnstile");
+  });
+
+  it("should have proper auto-detection for captcha elements", () => {
+    const script = fs.readFileSync(solverPath, "utf8");
+
+    // Check for DOM selectors used in auto-detection
+    expect(script).toContain(".g-recaptcha[data-sitekey]");
+    expect(script).toContain(".h-captcha[data-sitekey]");
+    expect(script).toContain(".cf-turnstile[data-sitekey]");
+    expect(script).toContain("[data-sitekey]");
+  });
+
+  it("should properly inject tokens into response fields", () => {
+    const script = fs.readFileSync(solverPath, "utf8");
+
+    // Check for token injection selectors
+    expect(script).toContain("[name=g-recaptcha-response]");
+    expect(script).toContain("[name=h-captcha-response]");
+    expect(script).toContain("[name=cf-turnstile-response]");
+    expect(script).toContain("___grecaptcha_cfg");
+  });
+
+  it("should contain safeParseJson function for robust JSON parsing", () => {
+    const script = fs.readFileSync(solverPath, "utf8");
+    expect(script).toContain("function safeParseJson");
+    expect(script).toContain("safeParseJson(await httpsGet");
+  });
+});
+
+describe("safeParseJson", () => {
+  let safeParseJson;
+  let extractionFailed = false;
+
+  // Try to extract the function for testing
+  try {
+    safeParseJson = getSafeParseJson();
+  } catch {
+    extractionFailed = true;
+  }
+
+  // Use it.skipIf to clearly indicate skipped tests
+  const testFn = extractionFailed ? it.skip : it;
+
+  testFn("should parse valid JSON normally", () => {
+    const result = safeParseJson('{"status":1,"request":"abc123"}');
+    expect(result).toEqual({ status: 1, request: "abc123" });
+  });
+
+  testFn("should handle JSON with leading/trailing whitespace", () => {
+    const result = safeParseJson('  {"status":1}  \n');
+    expect(result).toEqual({ status: 1 });
+  });
+
+  testFn("should extract first JSON object from concatenated responses", () => {
+    // This is the exact error case: multiple JSON objects concatenated
+    const result = safeParseJson('{"status":1}{"status":2}');
+    expect(result).toEqual({ status: 1 });
+  });
+
+  testFn("should handle JSON with trailing garbage characters", () => {
+    const result = safeParseJson('{"status":1}xxx');
+    expect(result).toEqual({ status: 1 });
+  });
+
+  testFn("should handle nested objects correctly", () => {
+    const result = safeParseJson('{"data":{"nested":true}}extra');
+    expect(result).toEqual({ data: { nested: true } });
+  });
+
+  testFn("should handle strings containing braces", () => {
+    const result = safeParseJson('{"text":"hello {world}"}extra');
+    expect(result).toEqual({ text: "hello {world}" });
+  });
+
+  testFn("should handle escaped quotes in strings", () => {
+    const result = safeParseJson('{"text":"say \\"hello\\""}extra');
+    expect(result).toEqual({ text: 'say "hello"' });
+  });
+
+  testFn("should throw for responses without JSON", () => {
+    expect(() => safeParseJson("not json at all")).toThrow(
+      "No JSON object found",
+    );
+  });
+
+  testFn("should throw for incomplete JSON", () => {
+    expect(() => safeParseJson('{"incomplete')).toThrow("Invalid JSON");
+  });
+});

package/test/chrome-remote-debugging.test.mjs

@@ -0,0 +1,66 @@
+/**
+ * Test that validates Chrome remote debugging is working
+ * Installs chrome-remote-interface and connects to the active tab
+ */
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../lib/vitest/hooks.mjs";
+
+describe("Chrome Remote Debugging", () => {
+
+  it("should connect to Chrome via CDP and get page title", async (context) => {
+    const testdriver = TestDriver(context);
+    
+    // Launch Chrome with a known URL
+    await testdriver.provision.chrome({
+      url: 'https://example.com',
+    });
+
+    // Take a screenshot to verify Chrome launched
+    await testdriver.screenshot();
+
+    // Install chrome-remote-interface (needs sudo for global install)
+    const installResult = await testdriver.exec(
+      'sh',
+      'sudo npm install -g chrome-remote-interface',
+      60000
+    );
+    console.log('Install result:', installResult);
+
+    // Write the CDP script to a file to avoid quoting issues
+    const cdpScript = `
+const CDP = require('chrome-remote-interface');
+(async () => {
+  try {
+    const client = await CDP();
+    const { Runtime } = client;
+    const result = await Runtime.evaluate({
+      expression: 'document.title'
+    });
+    console.log('PAGE_TITLE:' + result.result.value);
+    await client.close();
+    process.exit(0);
+  } catch (err) {
+    console.error('CDP_ERROR:' + err.message);
+    process.exit(1);
+  }
+})();
+`;
+
+    // Write script to file
+    await testdriver.exec('sh', `cat > /tmp/cdp-test.js << 'SCRIPT'
+${cdpScript}
+SCRIPT`, 5000);
+
+    // Run the CDP script with NODE_PATH set to find globally installed modules
+    const cdpResult = await testdriver.exec(
+      'sh',
+      'NODE_PATH=/usr/lib/node_modules node /tmp/cdp-test.js 2>&1 || echo "CDP_EXIT_CODE:$?"',
+      30000
+    );
+    console.log('CDP result:', cdpResult);
+
+    // Verify we got the page title
+    expect(cdpResult).toContain('PAGE_TITLE:');
+    expect(cdpResult).toContain('Example Domain');
+  });
+});

package/test/duckduckgo/experiment.test.mjs

@@ -0,0 +1,28 @@
+/**
+ * Experiment file - reconnects to existing sandbox
+ * Run AFTER setup.test.mjs passes
+ */
+import { describe, expect, it } from "vitest";
+import { TestDriver } from "../../lib/vitest/hooks.mjs";
+
+describe("Experiment DuckDuckGo", () => {
+  it("should search for apples", async (context) => {
+    const testdriver = TestDriver(context, {
+      reconnect: true, // ← Key: reconnects to last sandbox
+    });
+
+    // NO provision here! The sandbox is already running from setup.test.mjs
+
+    // Find search input and type
+    const searchInput = await testdriver.find("search input");
+    await searchInput.click();
+    await testdriver.type("apples");
+    await testdriver.pressKeys(["enter"]);
+
+    // Assert results
+    const result = await testdriver.assert(
+      "I can see search results for apples",
+    );
+    expect(result).toBeTruthy();
+  });
+});

package/test/duckduckgo/setup.test.mjs

@@ -0,0 +1,29 @@
+/**
+ * Setup file - MINIMAL steps to get to starting state
+ * Only add more steps AFTER this passes!
+ */
+import { afterAll, describe, expect, it } from "vitest";
+import { TestDriver } from "../../lib/vitest/hooks.mjs";
+
+describe("Setup DuckDuckGo", () => {
+  afterAll(async () => {
+    // DO NOT disconnect - keep sandbox alive for reconnect
+    console.log("Sandbox staying alive for 30 seconds (keepAlive)");
+  });
+
+  it("should set up the application state", async (context) => {
+    const testdriver = TestDriver(context);
+
+    await testdriver.provision.chrome({
+      url: "https://duckduckgo.com",
+    });
+
+    // Start with just ONE assertion to verify we're on the right page
+    const result = await testdriver.assert(
+      "I can see the DuckDuckGo search page",
+    );
+    expect(result).toBeTruthy();
+
+    console.log("✅ Setup ready - run experiment.test.mjs now");
+  });
+});

package/test/manual/debug-locate-response.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+/**
+ * Debug script to inspect the full locate API response
+ * Run this with: TD_API_KEY=your_key node debug-locate-response.js
+ */
+
+const TestDriverSDK = require("./sdk.js");
+
+async function debugLocateResponse() {
+  const client = new TestDriverSDK(process.env.TD_API_KEY);
+
+  try {
+    console.log("Connecting to sandbox (Linux)...");
+    await client.connect({ headless: true });
+
+    console.log("Opening a test page...");
+    await client.focusApplication("Google Chrome");
+    await client.type("https://example.com");
+    await client.pressKeys(["enter"]);
+
+    // Wait for page to load
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+
+    console.log("\nFinding an element to inspect the response...");
+    const element = await client.find("the heading that says Example Domain");
+
+    console.log("\n=".repeat(60));
+    console.log("FULL LOCATE API RESPONSE:");
+    console.log("=".repeat(60));
+
+    const response = element.getResponse();
+    console.log(JSON.stringify(response, null, 2));
+
+    console.log("\n=".repeat(60));
+    console.log("RESPONSE KEYS:");
+    console.log("=".repeat(60));
+
+    if (response) {
+      Object.keys(response).forEach((key) => {
+        const value = response[key];
+        const type = Array.isArray(value) ? "array" : typeof value;
+        const preview =
+          typeof value === "string" && value.length > 100
+            ? `${value.substring(0, 100)}... (${value.length} chars)`
+            : typeof value === "object"
+              ? JSON.stringify(value)
+              : value;
+
+        console.log(`  ${key} (${type}): ${preview}`);
+      });
+    }
+
+    console.log("\n=".repeat(60));
+    console.log("ELEMENT PROPERTIES:");
+    console.log("=".repeat(60));
+    console.log("  found:", element.found());
+    console.log("  x:", element.x);
+    console.log("  y:", element.y);
+    console.log("  centerX:", element.centerX);
+    console.log("  centerY:", element.centerY);
+    console.log("  width:", element.width);
+    console.log("  height:", element.height);
+    console.log("  confidence:", element.confidence);
+    console.log("  text:", element.text);
+    console.log("  label:", element.label);
+    console.log(
+      "  screenshot:",
+      element.screenshot ? `${element.screenshot.length} chars` : null,
+    );
+    console.log("  boundingBox:", element.boundingBox);
+
+    await client.disconnect();
+  } catch (error) {
+    console.error("Error:", error.message);
+    console.error(error.stack);
+    await client.disconnect();
+    process.exit(1);
+  }
+}
+
+debugLocateResponse();

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;