testdriverai 7.1.0 → 7.1.1

package/interfaces/cli/commands/init.js

@@ -0,0 +1,358 @@
+const BaseCommand = require("../lib/base.js");
+const { createCommandDefinitions } = require("../../../agent/interface.js");
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const { execSync } = require("child_process");
+const readline = require("readline");
+
+/**
+ * Init command - scaffolds Vitest SDK example tests for TestDriver
+ */
+class InitCommand extends BaseCommand {
+  async run() {
+    await this.parse(InitCommand);
+
+    console.log(chalk.cyan("\n🚀 Initializing TestDriver project...\n"));
+
+    await this.setupPackageJson();
+    await this.createVitestExample();
+    await this.createGitHubWorkflow();
+    await this.createGitignore();
+    await this.installDependencies();
+    await this.promptForApiKey();
+
+    console.log(chalk.green("\n✅ Project initialized successfully!\n"));
+    this.printNextSteps();
+  }
+
+  /**
+   * Prompt user for API key and save to .env
+   */
+  async promptForApiKey() {
+    const envPath = path.join(process.cwd(), ".env");
+
+    // Check if .env already exists with TD_API_KEY
+    if (fs.existsSync(envPath)) {
+      const envContent = fs.readFileSync(envPath, "utf8");
+      if (envContent.includes("TD_API_KEY=")) {
+        console.log(chalk.gray("\n  API key already configured in .env, skipping...\n"));
+        return;
+      }
+    }
+
+    console.log(chalk.cyan("  Setting up your TestDriver API key...\n"));
+    console.log(chalk.gray("  Get your API key from: https://console.testdriver.ai/team"));
+
+    // Ask if user wants to open the browser
+    const shouldOpen = await this.askYesNo("  Open API keys page in browser? (Y/n): ");
+    if (shouldOpen) {
+      try {
+        // Dynamic import for ES module
+        const open = (await import("open")).default;
+        await open("https://console.testdriver.ai/team");
+        console.log(chalk.gray("  Opening browser...\n"));
+      } catch (error) {
+        console.log(chalk.yellow("  ⚠️  Could not open browser automatically\n"));
+      }
+    }
+
+    // Prompt for API key with hidden input
+    const apiKey = await this.promptHidden("  Enter your API key (input will be hidden): ");
+
+    if (apiKey && apiKey.trim()) {
+      // Save to .env
+      const envContent = fs.existsSync(envPath)
+        ? fs.readFileSync(envPath, "utf8") + "\n"
+        : "";
+
+      fs.writeFileSync(envPath, envContent + `TD_API_KEY=${apiKey.trim()}\n`);
+      console.log(chalk.green("\n  ✓ API key saved to .env\n"));
+    } else {
+      console.log(chalk.yellow("\n  ⚠️  No API key entered. You can add it later to .env:\n"));
+      console.log(chalk.gray("     TD_API_KEY=your_api_key\n"));
+    }
+  }
+
+  /**
+   * Prompt for hidden input (like password)
+   */
+  async promptHidden(question) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      // Mute output to hide the input
+      const stdin = process.stdin;
+      const muted = {
+        write: () => {},
+      };
+
+      rl.question(question, (answer) => {
+        rl.close();
+        stdin.removeListener("data", muted.write);
+        console.log(""); // New line after hidden input
+        resolve(answer);
+      });
+
+      // Mute stdin to hide input
+      stdin.on("data", (char) => {
+        // Don't write to output (hides the input)
+      });
+    });
+  }
+
+  /**
+   * Ask a yes/no question
+   */
+  async askYesNo(question) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      rl.question(question, (answer) => {
+        rl.close();
+        const normalized = answer.toLowerCase().trim();
+        resolve(normalized === "" || normalized === "y" || normalized === "yes");
+      });
+    });
+  }
+
+  /**
+   * Setup package.json if it doesn't exist
+   */
+  async setupPackageJson() {
+    const packageJsonPath = path.join(process.cwd(), "package.json");
+
+    if (!fs.existsSync(packageJsonPath)) {
+      console.log(chalk.gray("  Creating package.json..."));
+
+      const packageJson = {
+        name: path.basename(process.cwd()),
+        version: "1.0.0",
+        description: "TestDriver.ai test suite",
+        type: "module",
+        scripts: {
+          test: "vitest run",
+          "test:watch": "vitest",
+          "test:ui": "vitest --ui"
+        },
+        keywords: ["testdriver", "testing", "e2e"],
+        author: "",
+        license: "ISC"
+      };
+
+      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+      console.log(chalk.green(`  Created package.json`));
+    } else {
+      console.log(chalk.gray("  package.json already exists, skipping..."));
+    }
+  }
+
+  /**
+   * Create a Vitest SDK example
+   */
+  async createVitestExample() {
+    const testDir = path.join(process.cwd(), "tests");
+    const testFile = path.join(testDir, "example.test.js");
+    const configFile = path.join(process.cwd(), "vitest.config.js");
+
+    // Create test directory if it doesn't exist
+    if (!fs.existsSync(testDir)) {
+      fs.mkdirSync(testDir, { recursive: true });
+      console.log(chalk.gray(`  Created directory: ${testDir}`));
+    }
+
+    // Create example Vitest test
+    const vitestContent = `import { test, expect } from 'vitest';
+import { chrome } from 'testdriverai/presets';
+
+test('should navigate to example.com and find elements', async (context) => {
+  // The chrome preset handles connection, browser launch, and cleanup automatically
+  const { testdriver } = await chrome(context, {
+    url: 'https://example.com'
+    // apiKey automatically read from process.env.TD_API_KEY via .env file
+  });
+
+  // Find and verify elements
+  const heading = await testdriver.find('heading that says Example Domain');
+  expect(heading.found()).toBe(true);
+
+  const link = await testdriver.find('More information link');
+  expect(link.found()).toBe(true);
+});
+`;
+
+    fs.writeFileSync(testFile, vitestContent);
+    console.log(chalk.green(`  Created test file: ${testFile}`));
+
+    // Create vitest config if it doesn't exist
+    if (!fs.existsSync(configFile)) {
+      const configContent = `import { defineConfig } from 'vitest/config';
+import TestDriver from 'testdriverai/vitest';
+import dotenv from 'dotenv';
+
+// Load environment variables from .env file
+dotenv.config();
+
+export default defineConfig({
+  plugins: [TestDriver()],
+  test: {
+    testTimeout: 120000,
+    hookTimeout: 120000,
+  },
+});
+`;
+
+      fs.writeFileSync(configFile, configContent);
+      console.log(chalk.green(`  Created config file: ${configFile}`));
+    }
+
+  }
+
+  /**
+   * Create or update .gitignore to include .env
+   */
+  async createGitignore() {
+    const gitignorePath = path.join(process.cwd(), ".gitignore");
+
+    let gitignoreContent = "";
+    if (fs.existsSync(gitignorePath)) {
+      gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
+
+      // Check if .env is already in .gitignore
+      if (gitignoreContent.includes(".env")) {
+        console.log(chalk.gray("  .env already in .gitignore, skipping..."));
+        return;
+      }
+    }
+
+    // Add common ignores including .env
+    const ignoresToAdd = [
+      "",
+      "# TestDriver.ai",
+      ".env",
+      "node_modules/",
+      "test-results/",
+      "*.log",
+    ];
+
+    const newContent = gitignoreContent.trim()
+      ? gitignoreContent + "\n" + ignoresToAdd.join("\n") + "\n"
+      : ignoresToAdd.join("\n") + "\n";
+
+    fs.writeFileSync(gitignorePath, newContent);
+    console.log(chalk.green("  Updated .gitignore"));
+  }
+
+  /**
+   * Create GitHub Actions workflow
+   */
+  async createGitHubWorkflow() {
+    const workflowDir = path.join(process.cwd(), ".github", "workflows");
+    const workflowFile = path.join(workflowDir, "testdriver.yml");
+
+    // Create .github/workflows directory if it doesn't exist
+    if (!fs.existsSync(workflowDir)) {
+      fs.mkdirSync(workflowDir, { recursive: true });
+      console.log(chalk.gray(`  Created directory: ${workflowDir}`));
+    }
+
+    if (!fs.existsSync(workflowFile)) {
+      const workflowContent = `name: TestDriver.ai Tests
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20'
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Run TestDriver.ai tests
+      env:
+        TD_API_KEY: \${{ secrets.TD_API_KEY }}
+      run: npm test
+
+    - name: Upload test results
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: test-results
+        path: test-results/
+        retention-days: 30
+`;
+
+      fs.writeFileSync(workflowFile, workflowContent);
+      console.log(chalk.green(`  Created GitHub workflow: ${workflowFile}`));
+    } else {
+      console.log(chalk.gray("  GitHub workflow already exists, skipping..."));
+    }
+  }
+
+  /**
+   * Install dependencies
+   */
+  async installDependencies() {
+    console.log(chalk.cyan("\n  Installing dependencies...\n"));
+
+    try {
+      execSync("npm install -D vitest testdriverai && npm install dotenv", {
+        cwd: process.cwd(),
+        stdio: "inherit"
+      });
+      console.log(chalk.green("\n  Dependencies installed successfully!"));
+    } catch (error) {
+      console.log(
+        chalk.yellow(
+          "\n⚠️  Failed to install dependencies automatically. Please run:",
+        ),
+      );
+      console.log(chalk.gray("     npm install -D vitest testdriverai"));
+      console.log(chalk.gray("     npm install dotenv\n"));
+    }
+  }
+
+  /**
+   * Print next steps
+   */
+  printNextSteps() {
+    console.log(chalk.cyan("Next steps:\n"));
+    console.log("  1. Run your tests:");
+    console.log(chalk.gray("     npm test\n"));
+    console.log("  2. For CI/CD, add TD_API_KEY to your GitHub repository secrets");
+    console.log(chalk.gray("     Settings → Secrets → Actions → New repository secret\n"));
+    console.log(
+      chalk.cyan("Learn more at https://docs.testdriver.ai/getting-started\n"),
+    );
+  }
+}
+
+// Get command definition from interface.js
+const tempAgent = { workingDir: process.cwd() };
+const definitions = createCommandDefinitions(tempAgent);
+const commandDef = definitions["init"];
+
+InitCommand.description = commandDef?.description || "";
+InitCommand.args = commandDef?.args || {};
+InitCommand.flags = commandDef?.flags || {};
+
+module.exports = InitCommand;

package/interfaces/vitest-plugin.mjs

@@ -1,9 +1,14 @@
+import { execSync } from "child_process";
 import crypto from "crypto";
 import fs from "fs";
+import { createRequire } from "module";
 import os from "os";
 import path from "path";
 import { setTestRunInfo } from "./shared-test-state.mjs";
 
+// Use createRequire to import CommonJS modules without esbuild processing
+const require = createRequire(import.meta.url);
+
 /**
  * Simple logger for the vitest plugin
  * Supports log levels: debug, info, warn, error
@@ -218,6 +223,126 @@ export async function recordTestCaseDirect(token, apiRoot, testCaseData) {
   return await response.json();
 }
 
+// Import TestDriverSDK using require to avoid esbuild transformation issues
+const TestDriverSDK = require('../sdk.js');
+
+/**
+ * Create a TestDriver client for use in beforeAll/beforeEach hooks
+ * This is for the shared instance pattern where one driver is used across multiple tests
+ * 
+ * @param {object} options - TestDriver options
+ * @param {string} [options.apiKey] - TestDriver API key (defaults to process.env.TD_API_KEY)
+ * @param {boolean} [options.headless] - Run sandbox in headless mode
+ * @returns {Promise<TestDriver>} Connected TestDriver client instance
+ * 
+ * @example
+ * let testdriver;
+ * beforeAll(async () => {
+ *   testdriver = await createTestDriver({ headless: true });
+ *   await testdriver.provision.chrome({ url: 'https://example.com' });
+ * });
+ */
+export async function createTestDriver(options = {}) {
+  // Get global plugin options if available
+  const pluginOptions = globalThis.__testdriverPlugin?.state?.testDriverOptions || {};
+  
+  // Merge options: plugin global options < test-specific options
+  const mergedOptions = { ...pluginOptions, ...options };
+  
+  // Extract TestDriver-specific options
+  const apiKey = mergedOptions.apiKey || process.env.TD_API_KEY;
+  
+  // Build config for TestDriverSDK constructor
+  const config = { ...mergedOptions };
+  delete config.apiKey;
+  
+  // Use TD_API_ROOT from environment if not provided in config
+  if (!config.apiRoot && process.env.TD_API_ROOT) {
+    config.apiRoot = process.env.TD_API_ROOT;
+  }
+  
+  const testdriver = new TestDriverSDK(apiKey, config);
+  
+  // Connect to sandbox
+  console.log('[testdriver] Connecting to sandbox...');
+  await testdriver.auth();
+  await testdriver.connect();
+  console.log('[testdriver] ✅ Connected to sandbox');
+  
+  return testdriver;
+}
+
+/**
+ * Register a test with a shared TestDriver instance
+ * Call this at the start of each test to associate the test context with the driver
+ * 
+ * @param {TestDriver} testdriver - TestDriver client instance from createTestDriver
+ * @param {object} context - Vitest test context (from async (context) => {})
+ * 
+ * @example
+ * it("step01: verify login", async (context) => {
+ *   registerTest(testdriver, context);
+ *   const result = await testdriver.assert("login form visible");
+ * });
+ */
+export function registerTest(testdriver, context) {
+  if (!testdriver) {
+    throw new Error('registerTest() requires a TestDriver instance');
+  }
+  if (!context || !context.task) {
+    throw new Error('registerTest() requires Vitest context. Pass the context parameter from your test function.');
+  }
+  
+  testdriver.__vitestContext = context.task;
+  logger.debug(`Registered test: ${context.task.name}`);
+}
+
+/**
+ * Clean up a TestDriver client created with createTestDriver
+ * Call this in afterAll to properly disconnect and stop recordings
+ * 
+ * @param {TestDriver} testdriver - TestDriver client instance
+ * 
+ * @example
+ * afterAll(async () => {
+ *   await cleanupTestDriver(testdriver);
+ * });
+ */
+export async function cleanupTestDriver(testdriver) {
+  if (!testdriver) {
+    return;
+  }
+  
+  console.log('[testdriver] Cleaning up TestDriver client...');
+  
+  try {
+    // Stop dashcam if it was started
+    if (testdriver._dashcam && testdriver._dashcam.recording) {
+      try {
+        const dashcamUrl = await testdriver.dashcam.stop();
+        console.log('🎥 Dashcam URL:', dashcamUrl);
+        
+        // Register dashcam URL in memory for the reporter
+        if (dashcamUrl && globalThis.__testdriverPlugin?.registerDashcamUrl) {
+          const testId = testdriver.__vitestContext?.id || 'unknown';
+          const platform = testdriver.os || 'linux';
+          globalThis.__testdriverPlugin.registerDashcamUrl(testId, dashcamUrl, platform);
+        }
+      } catch (error) {
+        console.error('❌ Failed to stop dashcam:', error.message);
+        if (error.name === 'NotFoundError' || error.responseData?.error === 'NotFoundError') {
+          console.log('   ℹ️  Sandbox session already terminated - dashcam stop skipped');
+        }
+      }
+    }
+    
+    await testdriver.disconnect();
+    console.log('✅ Client disconnected');
+  } catch (error) {
+    console.error('Error disconnecting client:', error);
+  }
+}
+
 /**
  * Handle process termination and mark test run as cancelled
  */
@@ -292,10 +417,10 @@ function registerExitHandlers() {
  * This sets up global state and provides the registration API
  */
 export default function testDriverPlugin(options = {}) {
-  // Initialize plugin state with options
-  pluginState.apiKey = options.apiKey;
+  // Store options but don't read env vars yet - they may not be loaded
+  // Environment variables will be read in onInit after setupFiles run
   pluginState.apiRoot =
-    options.apiRoot || process.env.TD_API_ROOT || "http://localhost:1337";
+    options.apiRoot || process.env.TD_API_ROOT || "https://testdriver-api.onrender.com";
   pluginState.ciProvider = detectCI();
   pluginState.gitInfo = getGitInfo();
   
@@ -307,7 +432,11 @@ export default function testDriverPlugin(options = {}) {
   registerExitHandlers();
 
   // Note: globalThis setup happens in vitestSetup.mjs for worker processes
-  logger.debug("Initialized with API root:", pluginState.apiRoot);
+  logger.debug("TestDriver plugin initializing...");
+  logger.debug("API root:", pluginState.apiRoot);
+  logger.debug("API key from options:", !!options.apiKey);
+  logger.debug("API key from env (at config time):", !!process.env.TD_API_KEY);
+  logger.debug("CI Provider:", pluginState.ciProvider || "none");
   if (Object.keys(testDriverOptions).length > 0) {
     logger.debug("Global TestDriver options:", testDriverOptions);
   }
@@ -322,12 +451,22 @@ export default function testDriverPlugin(options = {}) {
 class TestDriverReporter {
   constructor(options = {}) {
     this.options = options;
-    logger.debug("Reporter created");
+    logger.debug("Reporter created with options:", { hasApiKey: !!options.apiKey, hasApiRoot: !!options.apiRoot });
   }
 
   async onInit(ctx) {
     this.ctx = ctx;
-    logger.debug("onInit called");
+    logger.debug("onInit called - UPDATED VERSION");
+
+    // NOW read the API key and API root (after setupFiles have run, including dotenv/config)
+    pluginState.apiKey = this.options.apiKey || process.env.TD_API_KEY;
+    pluginState.apiRoot = this.options.apiRoot || process.env.TD_API_ROOT || "https://testdriver-api.onrender.com";
+    logger.debug("API key from options:", !!this.options.apiKey);
+    logger.debug("API key from env (at onInit):", !!process.env.TD_API_KEY);
+    logger.debug("API root from options:", this.options.apiRoot);
+    logger.debug("API root from env (at onInit):", process.env.TD_API_ROOT);
+    logger.debug("Final API key set:", !!pluginState.apiKey);
+    logger.debug("Final API root set:", pluginState.apiRoot);
 
     // Initialize test run
     await this.initializeTestRun();
@@ -335,16 +474,23 @@ class TestDriverReporter {
 
   async initializeTestRun() {
     logger.debug("Initializing test run...");
+    logger.debug("Current API key in pluginState:", !!pluginState.apiKey);
+    logger.debug("Current API root in pluginState:", pluginState.apiRoot);
 
     // Check if we should enable the reporter
     if (!pluginState.apiKey) {
-      logger.debug("No API key provided, skipping test recording");
+      logger.warn("No API key provided, skipping test recording");
+      logger.debug("API key sources - options:", !!this.options.apiKey, "env:", !!process.env.TD_API_KEY);
       return;
     }
 
+    logger.info("Starting test run initialization with API key...");
+
     try {
       // Exchange API key for JWT token
+      logger.debug("Authenticating with API...");
       await authenticate();
+      logger.debug("Authentication successful, token received");
 
       // Generate unique run ID
       pluginState.testRunId = generateRunId();
@@ -369,7 +515,9 @@ class TestDriverReporter {
       // Default to linux if no tests write platform info
       testRunData.platform = "linux";
 
+      logger.debug("Creating test run with data:", testRunData);
       pluginState.testRun = await createTestRun(testRunData);
+      logger.debug("Test run created successfully:", pluginState.testRun);
 
       // Store in environment variables for worker processes to access
       process.env.TD_TEST_RUN_ID = pluginState.testRunId;
@@ -396,17 +544,20 @@ class TestDriverReporter {
 
   async onTestRunEnd(testModules, unhandledErrors, reason) {
     logger.debug("Test run ending with reason:", reason);
+    logger.debug("Plugin state - API key present:", !!pluginState.apiKey, "Test run present:", !!pluginState.testRun);
 
     if (!pluginState.apiKey) {
-      logger.debug("Skipping completion - no API key");
+      logger.warn("Skipping completion - no API key (was it cleared after init failure?)");
       return;
     }
 
     if (!pluginState.testRun) {
-      logger.debug("Skipping completion - no test run created");
+      logger.warn("Skipping completion - no test run created (check initialization logs)");
       return;
     }
 
+    logger.info("Completing test run...");
+
     try {
       // Calculate statistics from testModules
       const stats = calculateStatsFromModules(testModules);
@@ -639,7 +790,7 @@ class TestDriverReporter {
       const testRunDbId = process.env.TD_TEST_RUN_DB_ID;
 
       logger.debug(`Reported test case to API${dashcamUrl ? " with dashcam URL" : ""}`);
-      logger.info(`🔗 View test: ${pluginState.apiRoot.replace("testdriver-api.onrender.com", "app.testdriver.ai")}/runs/${testRunDbId}/${testCaseDbId}`);
+      logger.info(`🔗 View test: ${pluginState.apiRoot.replace("testdriver-api.onrender.com", "console.testdriver.ai")}/runs/${testRunDbId}/${testCaseDbId}`);
     } catch (error) {
       logger.error("Failed to report test case:", error.message);
     }
@@ -743,6 +894,59 @@ function getGitInfo() {
     if (process.env.CIRCLE_USERNAME) info.author = process.env.CIRCLE_USERNAME;
   }
 
+  // If not in CI or if commit info is missing, try to get it from local git
+  if (!info.commit) {
+    try {
+      info.commit = execSync("git rev-parse HEAD", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+    } catch (e) {
+      // Git command failed, ignore
+    }
+  }
+
+  if (!info.branch) {
+    try {
+      info.branch = execSync("git rev-parse --abbrev-ref HEAD", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+    } catch (e) {
+      // Git command failed, ignore
+    }
+  }
+
+  if (!info.author) {
+    try {
+      info.author = execSync("git config user.name", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+    } catch (e) {
+      // Git command failed, ignore
+    }
+  }
+
+  if (!info.repo) {
+    try {
+      const remoteUrl = execSync("git config --get remote.origin.url", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+
+      // Extract repo from git URL (supports both SSH and HTTPS)
+      // SSH: git@github.com:user/repo.git
+      // HTTPS: https://github.com/user/repo.git
+      const match = remoteUrl.match(/[:/]([^/:]+\/[^/:]+?)(\.git)?$/);
+      if (match) {
+        info.repo = match[1];
+      }
+    } catch (e) {
+      // Git command failed, ignore
+    }
+  }
+
   return info;
 }