testdriverai 7.0.0 → 7.1.1

package/interfaces/vitest-plugin.mjs

@@ -1,9 +1,46 @@
+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
+ * Control via TD_LOG_LEVEL environment variable (default: "info")
+ * Set TD_LOG_LEVEL=debug for verbose output
+ */
+const LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+const currentLogLevel = LOG_LEVELS[process.env.TD_LOG_LEVEL?.toLowerCase()] ?? LOG_LEVELS.info;
+
+const logger = {
+  debug: (...args) => {
+    if (currentLogLevel <= LOG_LEVELS.debug) {
+      console.log("[TestDriver]", ...args);
+    }
+  },
+  info: (...args) => {
+    if (currentLogLevel <= LOG_LEVELS.info) {
+      console.log("[TestDriver]", ...args);
+    }
+  },
+  warn: (...args) => {
+    if (currentLogLevel <= LOG_LEVELS.warn) {
+      console.warn("[TestDriver]", ...args);
+    }
+  },
+  error: (...args) => {
+    if (currentLogLevel <= LOG_LEVELS.error) {
+      console.error("[TestDriver]", ...args);
+    }
+  },
+};
+
 /**
  * Timeout wrapper for promises
  * @param {Promise} promise - Promise to wrap
@@ -58,6 +95,7 @@ function withTimeout(promise, timeoutMs, operationName) {
 export const pluginState = {
   testRun: null,
   testRunId: null,
+  testRunCompleted: false,
   client: null,
   startTime: null,
   testCases: new Map(),
@@ -68,6 +106,8 @@ export const pluginState = {
   gitInfo: {},
   apiKey: null,
   apiRoot: null,
+  // TestDriver options to pass to all instances
+  testDriverOptions: {},
   // Dashcam URL tracking (in-memory, no files needed!)
   dashcamUrls: new Map(), // testId -> dashcamUrl
   lastDashcamUrl: null, // Fallback for when test ID isn't available
@@ -77,7 +117,7 @@ export const pluginState = {
 
 // Export functions that can be used by the reporter or tests
 export function registerDashcamUrl(testId, url, platform) {
-  console.log(`[Plugin] Registering dashcam URL for test ${testId}:`, url);
+  logger.debug(`Registering dashcam URL for test ${testId}:`, url);
   pluginState.dashcamUrls.set(testId, { url, platform });
   pluginState.lastDashcamUrl = url;
 }
@@ -96,7 +136,7 @@ export function getSuiteTestRun(suiteId) {
 }
 
 export function setSuiteTestRun(suiteId, runData) {
-  console.log(`[Plugin] Setting test run for suite ${suiteId}:`, runData);
+  logger.debug(`Setting test run for suite ${suiteId}:`, runData);
   pluginState.suiteTestRuns.set(suiteId, runData);
 }
 
@@ -183,23 +223,223 @@ 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
+ */
+async function handleProcessExit() {
+  if (!pluginState.testRun || !pluginState.testRunId) {
+    return;
+  }
+
+  logger.info("Process interrupted, marking test run as cancelled...");
+
+  try {
+    const stats = {
+      totalTests: pluginState.testCases.size,
+      passedTests: 0,
+      failedTests: 0,
+      skippedTests: 0,
+    };
+
+    const completeData = {
+      runId: pluginState.testRunId,
+      status: "cancelled",
+      totalTests: stats.totalTests,
+      passedTests: stats.passedTests,
+      failedTests: stats.failedTests,
+      skippedTests: stats.skippedTests,
+      duration: Date.now() - pluginState.startTime,
+    };
+
+    // Update platform if detected
+    const platform = getPlatform();
+    if (platform) {
+      completeData.platform = platform;
+    }
+
+    await completeTestRun(completeData);
+    logger.info("✅ Test run marked as cancelled");
+  } catch (error) {
+    logger.error("Failed to mark test run as cancelled:", error.message);
+  }
+}
+
+// Set up process exit handlers
+let exitHandlersRegistered = false;
+
+function registerExitHandlers() {
+  if (exitHandlersRegistered) return;
+  exitHandlersRegistered = true;
+
+  // Handle Ctrl+C
+  process.on("SIGINT", async () => {
+    await handleProcessExit();
+    process.exit(130); // Standard exit code for SIGINT
+  });
+
+  // Handle kill command
+  process.on("SIGTERM", async () => {
+    await handleProcessExit();
+    process.exit(143); // Standard exit code for SIGTERM
+  });
+
+  // Handle unexpected exits
+  process.on("beforeExit", async () => {
+    // Only handle if test run is still running (hasn't been completed normally)
+    if (pluginState.testRun && !pluginState.testRunCompleted) {
+      await handleProcessExit();
+    }
+  });
+}
+
 /**
  * Create the TestDriver Vitest plugin
  * 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();
+  
+  // Store TestDriver-specific options (excluding plugin-specific ones)
+  const { apiKey, apiRoot, ...testDriverOptions } = options;
+  pluginState.testDriverOptions = testDriverOptions;
+
+  // Register process exit handlers to handle cancellation
+  registerExitHandlers();
 
   // Note: globalThis setup happens in vitestSetup.mjs for worker processes
-  console.log(
-    "[TestDriver Plugin] 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);
+  }
 
   return new TestDriverReporter(options);
 }
@@ -211,35 +451,51 @@ export default function testDriverPlugin(options = {}) {
 class TestDriverReporter {
   constructor(options = {}) {
     this.options = options;
-    console.log("[TestDriver Reporter] Created");
+    logger.debug("Reporter created with options:", { hasApiKey: !!options.apiKey, hasApiRoot: !!options.apiRoot });
   }
 
   async onInit(ctx) {
     this.ctx = ctx;
-    console.log("[TestDriver Reporter] 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();
   }
 
   async initializeTestRun() {
-    console.log("[TestDriver Reporter] Initializing test run...");
+    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) {
-      console.log(
-        "[TestDriver Reporter] 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();
       pluginState.startTime = Date.now();
+      pluginState.testRunCompleted = false; // Reset completion flag
 
       // Create test run via direct API call
       const testRunData = {
@@ -248,6 +504,8 @@ class TestDriverReporter {
         ...pluginState.gitInfo,
       };
 
+      // Session ID will be added from the first test result file that includes it
+
       // Only add ciProvider if it's not null
       if (pluginState.ciProvider) {
         testRunData.ciProvider = pluginState.ciProvider;
@@ -257,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;
@@ -274,39 +534,35 @@ class TestDriverReporter {
         startTime: pluginState.startTime,
       });
 
-      console.log(
-        `[TestDriver Reporter] Test run created: ${pluginState.testRunId}`,
-      );
+      logger.info(`Test run created: ${pluginState.testRunId}`);
     } catch (error) {
-      console.error(
-        "[TestDriver Reporter] Failed to initialize:",
-        error.message,
-      );
+      logger.error("Failed to initialize:", error.message);
       pluginState.apiKey = null;
       pluginState.token = null;
     }
   }
 
   async onTestRunEnd(testModules, unhandledErrors, reason) {
-    console.log("[TestDriver Reporter] Test run ending with reason:", 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) {
-      console.log("[TestDriver Reporter] Skipping completion - no API key");
+      logger.warn("Skipping completion - no API key (was it cleared after init failure?)");
       return;
     }
 
     if (!pluginState.testRun) {
-      console.log(
-        "[TestDriver Reporter] 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);
 
-      console.log(`[TestDriver Reporter] Stats:`, stats);
+      logger.debug("Stats:", stats);
 
       // Determine overall status based on reason and stats
       let status = "passed";
@@ -319,9 +575,7 @@ class TestDriverReporter {
       }
 
       // Complete test run via API
-      console.log(
-        `[TestDriver Reporter] Completing test run ${pluginState.testRunId} with status: ${status}`,
-      );
+      logger.debug(`Completing test run ${pluginState.testRunId} with status: ${status}`);
 
       const completeData = {
         runId: pluginState.testRunId,
@@ -337,39 +591,28 @@ class TestDriverReporter {
       const platform = getPlatform();
       if (platform) {
         completeData.platform = platform;
-        console.log(
-          `[TestDriver Reporter] Updating test run with platform: ${platform}`,
-        );
+        logger.debug(`Updating test run with platform: ${platform}`);
       }
 
       // Wait for any pending operations (shouldn't be any, but just in case)
       if (pluginState.pendingTestCaseRecords.size > 0) {
-        console.log(
-          `[TestDriver Reporter] Waiting for ${pluginState.pendingTestCaseRecords.size} pending operations...`,
-        );
+        logger.debug(`Waiting for ${pluginState.pendingTestCaseRecords.size} pending operations...`);
         await Promise.all(Array.from(pluginState.pendingTestCaseRecords));
       }
 
       // Test cases are reported directly from teardownTest
-      console.log(
-        `[TestDriver Reporter] All test cases reported from teardown`,
-      );
+      logger.debug("All test cases reported from teardown");
 
       const completeResponse = await completeTestRun(completeData);
-      console.log(
-        `[TestDriver Reporter] ✅ Test run completion API response:`,
-        completeResponse,
-      );
+      logger.debug("Test run completion API response:", completeResponse);
 
-      console.log(
-        `[TestDriver Reporter] Test run completed: ${stats.passedTests}/${stats.totalTests} passed`,
-      );
+      // Mark test run as completed to prevent duplicate completion
+      pluginState.testRunCompleted = true;
+
+      logger.info(`✅ Test run completed: ${stats.passedTests}/${stats.totalTests} passed`);
     } catch (error) {
-      console.error(
-        "[TestDriver Reporter] Failed to complete test run:",
-        error.message,
-      );
-      console.error("[TestDriver Reporter] Error stack:", error.stack);
+      logger.error("Failed to complete test run:", error.message);
+      logger.debug("Error stack:", error.stack);
     }
   }
 
@@ -396,15 +639,19 @@ class TestDriverReporter {
           ? "skipped"
           : "failed";
 
-    console.log(
-      `[TestDriver Reporter] Test case completed: ${test.name} (${status})`,
-    );
+    logger.info(`Test case completed: ${test.name} (${status})`);
+
+    // Calculate duration from tracked start time
+    const testCase = pluginState.testCases.get(test.id);
+    const duration = testCase ? Date.now() - testCase.startTime : 0;
+    
+    logger.debug(`Calculated duration: ${duration}ms (startTime: ${testCase?.startTime}, now: ${Date.now()})`);
 
     // Read test metadata from file (cross-process communication)
     let dashcamUrl = null;
+    let sessionId = null;
     let testFile = "unknown";
     let testOrder = 0;
-    let duration = result.duration || 0;
 
     const testResultFile = path.join(
       os.tmpdir(),
@@ -412,11 +659,15 @@ class TestDriverReporter {
       `${test.id}.json`,
     );
 
+    logger.debug(`Looking for test result file with test.id: ${test.id}`);
+    logger.debug(`Test result file path: ${testResultFile}`);
+
     try {
       if (fs.existsSync(testResultFile)) {
         const testResult = JSON.parse(fs.readFileSync(testResultFile, "utf-8"));
         dashcamUrl = testResult.dashcamUrl || null;
         const platform = testResult.platform || null;
+        sessionId = testResult.sessionId || null;
         testFile =
           testResult.testFile ||
           test.file?.filepath ||
@@ -424,18 +675,15 @@ class TestDriverReporter {
           "unknown";
         testOrder =
           testResult.testOrder !== undefined ? testResult.testOrder : 0;
-        duration = testResult.duration || result.duration || 0;
+        // Don't override duration from file - use Vitest's result.duration
+        // duration is already set above from result.duration
 
-        console.log(
-          `[TestDriver Reporter] ✅ Read from file - dashcam: ${dashcamUrl}, platform: ${platform}, testFile: ${testFile}, testOrder: ${testOrder}, duration: ${duration}ms`,
-        );
+        logger.debug(`Read from file - dashcam: ${dashcamUrl}, platform: ${platform}, sessionId: ${sessionId}, testFile: ${testFile}, testOrder: ${testOrder}, duration: ${duration}ms`);
 
         // Update test run platform from first test that reports it
         if (platform && !pluginState.detectedPlatform) {
           pluginState.detectedPlatform = platform;
-          console.log(
-            `[TestDriver Reporter] 🖥️  Detected platform from test: ${platform}`,
-          );
+          logger.debug(`Detected platform from test: ${platform}`);
         }
 
         // Clean up the file after reading
@@ -445,37 +693,36 @@ class TestDriverReporter {
           // Ignore cleanup errors
         }
       } else {
-        console.log(
-          `[TestDriver Reporter] ⚠️  No result file found for test: ${test.id}`,
-        );
+        logger.debug(`No result file found for test: ${test.id}`);
         // Fallback to test object properties - try multiple sources
-        // In Vitest, the file path is typically on the module, not the test itself
-        const module = test.module || test.suite;
+        // In Vitest, the file path is on test.module.task.filepath
         testFile =
+          test.module?.task?.filepath ||
+          test.module?.file?.filepath ||
+          test.module?.file?.name ||
           test.file?.filepath ||
           test.file?.name ||
-          module?.file?.filepath ||
-          module?.file?.name ||
+          test.suite?.file?.filepath ||
+          test.suite?.file?.name ||
           test.location?.file ||
           "unknown";
-        console.log(
-          `[TestDriver Reporter] 📂 Resolved testFile for skipped test: ${testFile}`,
-        );
+        logger.debug(`Resolved testFile: ${testFile}`);
       }
     } catch (error) {
-      console.error(
-        `[TestDriver Reporter] ❌ Failed to read test result file:`,
-        error.message,
-      );
+      logger.error("Failed to read test result file:", error.message);
       // Fallback to test object properties - try multiple sources
-      const module = test.module || test.suite;
+      // In Vitest, the file path is on test.module.task.filepath
       testFile =
+        test.module?.task?.filepath ||
+        test.module?.file?.filepath ||
+        test.module?.file?.name ||
         test.file?.filepath ||
         test.file?.name ||
-        module?.file?.filepath ||
-        module?.file?.name ||
+        test.suite?.file?.filepath ||
+        test.suite?.file?.name ||
         test.location?.file ||
         "unknown";
+      logger.debug(`Resolved testFile from fallback: ${testFile}`);
     }
 
     // Get test run info from environment variables
@@ -483,9 +730,7 @@ class TestDriverReporter {
     const token = process.env.TD_TEST_RUN_TOKEN;
 
     if (!testRunId || !token) {
-      console.warn(
-        `[TestDriver Reporter] ⚠️  Test run not initialized, skipping test case recording for: ${test.name}`,
-      );
+      logger.warn(`Test run not initialized, skipping test case recording for: ${test.name}`);
       return;
     }
 
@@ -519,6 +764,11 @@ class TestDriverReporter {
         retries: result.retryCount || 0,
       };
 
+      // Add sessionId if available
+      if (sessionId) {
+        testCaseData.sessionId = sessionId;
+      }
+
       // Only include replayUrl if we have a valid dashcam URL
       if (dashcamUrl) {
         testCaseData.replayUrl = dashcamUrl;
@@ -528,9 +778,7 @@ class TestDriverReporter {
       if (errorMessage) testCaseData.errorMessage = errorMessage;
       if (errorStack) testCaseData.errorStack = errorStack;
 
-      console.log(
-        `[TestDriver Reporter] Recording test case: ${test.name} (${status}) with testFile: ${testFile}, testOrder: ${testOrder}, duration: ${duration}ms, replay: ${dashcamUrl ? "yes" : "no"}`,
-      );
+      logger.debug(`Recording test case: ${test.name} (${status}) with testFile: ${testFile}, testOrder: ${testOrder}, duration: ${duration}ms, replay: ${dashcamUrl ? "yes" : "no"}`);
 
       const testCaseResponse = await recordTestCaseDirect(
         token,
@@ -541,17 +789,10 @@ class TestDriverReporter {
       const testCaseDbId = testCaseResponse.data?.id;
       const testRunDbId = process.env.TD_TEST_RUN_DB_ID;
 
-      console.log(
-        `[TestDriver Reporter] ✅ Reported test case to API${dashcamUrl ? " with dashcam URL" : ""}`,
-      );
-      console.log(
-        `[TestDriver Reporter] 🔗 View test: ${pluginState.apiRoot.replace("testdriver-api.onrender.com", "app.testdriver.ai")}/test-runs/${testRunDbId}/${testCaseDbId}`,
-      );
+      logger.debug(`Reported test case to API${dashcamUrl ? " with dashcam URL" : ""}`);
+      logger.info(`🔗 View test: ${pluginState.apiRoot.replace("testdriver-api.onrender.com", "console.testdriver.ai")}/runs/${testRunDbId}/${testCaseDbId}`);
     } catch (error) {
-      console.error(
-        `[TestDriver Reporter] ❌ Failed to report test case:`,
-        error.message,
-      );
+      logger.error("Failed to report test case:", error.message);
     }
   }
 }
@@ -571,13 +812,11 @@ function getSuiteName() {
 function getPlatform() {
   // First try to get platform from SDK client detected during test execution
   if (pluginState.detectedPlatform) {
-    console.log(
-      `[TestDriver Plugin] Using platform from SDK client: ${pluginState.detectedPlatform}`,
-    );
+    logger.debug(`Using platform from SDK client: ${pluginState.detectedPlatform}`);
     return pluginState.detectedPlatform;
   }
 
-  console.log(`[TestDriver Plugin] Platform not yet detected from client`);
+  logger.debug("Platform not yet detected from client");
   return null;
 }
 
@@ -594,9 +833,7 @@ function detectPlatformFromTest(test) {
     else if (platform === "linux") platform = "linux";
 
     pluginState.detectedPlatform = platform;
-    console.log(
-      `[TestDriver Plugin] Detected platform from test context: ${platform}`,
-    );
+    logger.debug(`Detected platform from test context: ${platform}`);
   }
 }
 
@@ -657,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;
 }