testdriverai 7.2.2 → 7.2.9

package/interfaces/cli/commands/init.js

@@ -24,6 +24,7 @@ class InitCommand extends BaseCommand {
 
     console.log(chalk.green("\n✅ Project initialized successfully!\n"));
     this.printNextSteps();
+    process.exit(0);
   }
 
   /**
@@ -79,28 +80,41 @@ class InitCommand extends BaseCommand {
    */
   async promptHidden(question) {
     return new Promise((resolve) => {
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      // Mute output to hide the input
+      process.stdout.write(question);
+      
       const stdin = process.stdin;
-      const muted = {
-        write: () => {},
+      const wasRaw = stdin.isRaw;
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding("utf8");
+
+      let input = "";
+
+      const onData = (char) => {
+        // Handle Ctrl+C
+        if (char === "\u0003") {
+          stdin.setRawMode(wasRaw);
+          process.exit();
+        }
+        // Handle Enter
+        if (char === "\r" || char === "\n") {
+          stdin.setRawMode(wasRaw);
+          stdin.removeListener("data", onData);
+          stdin.pause();
+          console.log(""); // New line after hidden input
+          resolve(input);
+          return;
+        }
+        // Handle Backspace
+        if (char === "\u007F" || char === "\b") {
+          input = input.slice(0, -1);
+          return;
+        }
+        // Add character to input (but don't echo it)
+        input += char;
       };
 
-      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)
-      });
+      stdin.on("data", onData);
     });
   }
 

package/interfaces/cli/lib/base.js

@@ -23,6 +23,7 @@ async function openBrowser(url) {
     await open(url, {
       // Wait for the app to open
       wait: false,
+      background: true
     });
   } catch (error) {
     console.error("Failed to open browser automatically:", error);
@@ -131,9 +132,32 @@ class BaseCommand extends Command {
     }
 
     this.agent.emitter.on("exit", (exitCode) => {
+      // Ensure sandbox is closed before exiting
+      if (this.agent?.sandbox) {
+        try {
+          this.agent.sandbox.close();
+        } catch (err) {
+          // Ignore close errors
+        }
+      }
       process.exit(exitCode);
     });
 
+    // Handle process signals to ensure clean disconnection
+    const cleanupAndExit = () => {
+      if (this.agent?.sandbox) {
+        try {
+          this.agent.sandbox.close();
+        } catch (err) {
+          // Ignore close errors
+        }
+      }
+      process.exit(1);
+    };
+
+    process.on('SIGINT', cleanupAndExit);
+    process.on('SIGTERM', cleanupAndExit);
+
     // Handle unhandled promise rejections to prevent them from interfering with the exit flow
     // This is particularly important when JavaScript execution in VM contexts leaves dangling promises
     process.on("unhandledRejection", (reason) => {

package/interfaces/cli.js

@@ -1,13 +1,20 @@
 #!/usr/bin/env node
 
 const { run } = require("@oclif/core");
+const sentry = require("../lib/sentry");
 
 // Run oclif (with default command handling built-in)
 run()
   .then(() => {
     // Success
   })
-  .catch((error) => {
+  .catch(async (error) => {
+    // Capture error in Sentry
+    sentry.captureException(error, {
+      tags: { component: "cli-init" },
+    });
+    await sentry.flush();
+
     console.error("Failed to start TestDriver.ai agent:", error);
     process.exit(1);
   });

package/interfaces/logger.js

@@ -300,6 +300,9 @@ marked.use(
 );
 
 const createMarkdownLogger = (emitter) => {
+  // Indent prefix for streaming AI thoughts - makes it visually distinct and scoped
+  const streamIndent = "";
+
   const markedParsePartial = (markdown, start = 0, end = 0) => {
     let result = markdown.trimEnd().split("\n").slice(start, end);
     if (end <= 0) {
@@ -307,7 +310,8 @@ const createMarkdownLogger = (emitter) => {
     }
     result = result.join("\n");
 
-    return marked.parse(result).replace(/^/gm, spaceChar).trimEnd();
+    // Use streamIndent for streaming output to make it visually scoped
+    return marked.parse(result).replace(/^/gm, streamIndent).trimEnd();
   };
 
   // Event-based markdown streaming with buffering
@@ -360,7 +364,8 @@ const createMarkdownLogger = (emitter) => {
       diff = censorSensitiveDataDeep(diff);
       process.stdout.write(diff);
     }
-    process.stdout.write("\n\n");
+    // Use console.log for the final newlines so it gets captured by vitest
+    console.log("");
 
     // Clean up the stream
     activeStreams.delete(streamId);
@@ -384,7 +389,7 @@ const createMarkdownLogger = (emitter) => {
   });
 };
 
-const spaceChar = "    ";
+const spaceChar = "   ";
 
 module.exports = {
   logger,

package/interfaces/vitest-plugin.mjs

@@ -1,8 +1,6 @@
 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";
 
@@ -662,76 +660,19 @@ class TestDriverReporter {
     
     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;
+    // Read test metadata from Vitest's task.meta (set in test hooks)
+    const meta = test.meta();
+    logger.debug(`Test meta for ${test.id}:`, meta);
 
-    const testResultFile = path.join(
-      os.tmpdir(),
-      "testdriver-results",
-      `${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;
-        const absolutePath =
-          testResult.testFile ||
-          test.file?.filepath ||
-          test.file?.name ||
-          "unknown";
-        // Make path relative to project root
-        testFile = pluginState.projectRoot && absolutePath !== "unknown"
-          ? path.relative(pluginState.projectRoot, absolutePath)
-          : absolutePath;
-        testOrder =
-          testResult.testOrder !== undefined ? testResult.testOrder : 0;
-        // Don't override duration from file - use Vitest's result.duration
-        // duration is already set above from result.duration
-
-        // Update test run platform from first test that reports it
-        if (platform && !pluginState.detectedPlatform) {
-          pluginState.detectedPlatform = platform;
-        }
+    const dashcamUrl = meta.dashcamUrl || null;
+    const sessionId = meta.sessionId || null;
+    const platform = meta.platform || null;
+    const sandboxId = meta.sandboxId || null;
+    let testFile = meta.testFile || "unknown";
+    const testOrder = meta.testOrder !== undefined ? meta.testOrder : 0;
 
-        // Clean up the file after reading
-        try {
-          fs.unlinkSync(testResultFile);
-        } catch {
-          // Ignore cleanup errors
-        }
-      } else {
-        logger.debug(`No result file found for test: ${test.id}`);
-        // Fallback to test object properties - try multiple sources
-        // In Vitest, the file path is on test.module.task.filepath
-        const absolutePath =
-          test.module?.task?.filepath ||
-          test.module?.file?.filepath ||
-          test.module?.file?.name ||
-          test.file?.filepath ||
-          test.file?.name ||
-          test.suite?.file?.filepath ||
-          test.suite?.file?.name ||
-          test.location?.file ||
-          "unknown";
-        // Make path relative to project root
-        testFile = pluginState.projectRoot && absolutePath !== "unknown"
-          ? path.relative(pluginState.projectRoot, absolutePath)
-          : absolutePath;
-        logger.debug(`Resolved testFile: ${testFile}`);
-      }
-    } catch (error) {
-      logger.error("Failed to read test result file:", error.message);
-      // Fallback to test object properties - try multiple sources
-      // In Vitest, the file path is on test.module.task.filepath
+    // If testFile not in meta, fallback to test object properties
+    if (testFile === "unknown") {
       const absolutePath =
         test.module?.task?.filepath ||
         test.module?.file?.filepath ||
@@ -742,13 +683,17 @@ class TestDriverReporter {
         test.suite?.file?.name ||
         test.location?.file ||
         "unknown";
-      // Make path relative to project root
       testFile = pluginState.projectRoot && absolutePath !== "unknown"
         ? path.relative(pluginState.projectRoot, absolutePath)
         : absolutePath;
       logger.debug(`Resolved testFile from fallback: ${testFile}`);
     }
 
+    // Update test run platform from first test that reports it
+    if (platform && !pluginState.detectedPlatform) {
+      pluginState.detectedPlatform = platform;
+    }
+
     // Get test run info from environment variables
     const testRunId = process.env.TD_TEST_RUN_ID;
     const token = process.env.TD_TEST_RUN_TOKEN;

package/lib/sentry.js

@@ -0,0 +1,343 @@
+/**
+ * Sentry initialization for TestDriver CLI
+ *
+ * This module initializes Sentry for error tracking and performance monitoring.
+ * It should be required at the very beginning of the CLI entry point.
+ * 
+ * Distributed Tracing:
+ * The CLI uses session-based trace IDs (MD5 hash of session ID) to link
+ * CLI traces with API traces. Call setSessionTraceContext() after establishing
+ * a session to ensure all CLI errors/logs are linked to the same trace.
+ */
+
+const Sentry = require("@sentry/node");
+const crypto = require("crypto");
+const os = require("os");
+const { version } = require("../package.json");
+
+// Store the current session's trace context
+let currentTraceId = null;
+let currentSessionId = null;
+
+// Track if we've attached listeners to avoid duplicates
+let emitterAttached = false;
+
+const isEnabled = () => {
+
+  // Disable if explicitly disabled
+  if (process.env.TD_TELEMETRY === "false") {
+    return false;
+  }
+  return true;
+};
+
+if (isEnabled()) {
+  Sentry.init({
+    dsn:
+      process.env.SENTRY_DSN ||
+      "https://452bd5a00dbd83a38ee8813e11c57694@o4510262629236736.ingest.us.sentry.io/4510480443637760",
+    environment: process.env.NODE_ENV || "development",
+    release: `testdriverai@${version}`,
+    sampleRate: 1.0,
+    tracesSampleRate: 1.0, // Sample 20% of transactions for performance
+    enableLogs: true,
+    integrations: [
+      Sentry.httpIntegration(),
+      Sentry.nodeContextIntegration(),
+    ],
+    // Set initial context
+    initialScope: {
+      tags: {
+        platform: os.platform(),
+        arch: os.arch(),
+        nodeVersion: process.version,
+      },
+    },
+    // Filter out common non-errors
+    beforeSend(event, hint) {
+
+      console.log('sending sentry event', event);
+
+      const error = hint.originalException;
+
+      // Don't send user-initiated exits
+      if (error && error.message && error.message.includes("User cancelled")) {
+        return null;
+      }
+
+      return event;
+    },
+  });
+}
+
+/**
+ * Set user context for Sentry
+ * @param {Object} user - User object with id, email, etc.
+ */
+function setUser(user) {
+  if (!isEnabled()) return;
+  Sentry.setUser(user);
+}
+
+/**
+ * Set additional context
+ * @param {string} name - Context name
+ * @param {Object} context - Context data
+ */
+function setContext(name, context) {
+  if (!isEnabled()) return;
+  Sentry.setContext(name, context);
+}
+
+/**
+ * Set a tag
+ * @param {string} key - Tag key
+ * @param {string} value - Tag value
+ */
+function setTag(key, value) {
+  if (!isEnabled()) return;
+  Sentry.setTag(key, value);
+}
+
+/**
+ * Capture an exception
+ * @param {Error} error - The error to capture
+ * @param {Object} context - Additional context
+ */
+function captureException(error, context = {}) {
+  if (!isEnabled()) return;
+
+  Sentry.withScope((scope) => {
+    // Link to session trace if available
+    if (currentTraceId && currentSessionId) {
+      scope.setTag("session", currentSessionId);
+      scope.setContext("trace", {
+        trace_id: currentTraceId,
+        session_id: currentSessionId,
+      });
+    }
+    
+    if (context.tags) {
+      Object.entries(context.tags).forEach(([key, value]) => {
+        scope.setTag(key, value);
+      });
+    }
+    if (context.extra) {
+      Object.entries(context.extra).forEach(([key, value]) => {
+        scope.setExtra(key, value);
+      });
+    }
+    Sentry.captureException(error);
+  });
+}
+
+/**
+ * Capture a message
+ * @param {string} message - The message to capture
+ * @param {string} level - Severity level (info, warning, error)
+ */
+function captureMessage(message, level = "info") {
+  if (!isEnabled()) return;
+  
+  Sentry.withScope((scope) => {
+    // Link to session trace if available
+    if (currentTraceId && currentSessionId) {
+      scope.setTag("session", currentSessionId);
+      scope.setContext("trace", {
+        trace_id: currentTraceId,
+        session_id: currentSessionId,
+      });
+    }
+    Sentry.captureMessage(message, level);
+  });
+}
+
+/**
+ * Set the session trace context for distributed tracing
+ * This links CLI errors/logs to the same trace as API calls
+ * @param {string} sessionId - The session ID
+ */
+function setSessionTraceContext(sessionId) {
+  if (!isEnabled() || !sessionId) return;
+  
+  // Derive trace ID from session ID (same algorithm as API)
+  currentTraceId = crypto.createHash("md5").update(sessionId).digest("hex");
+  currentSessionId = sessionId;
+  
+  // Set as global tag so all events include it
+  Sentry.setTag("session", sessionId);
+  Sentry.setTag("trace_id", currentTraceId);
+  
+  // Try to set propagation context for trace linking (may not be available in all versions)
+  try {
+    const scope = Sentry.getCurrentScope();
+    if (scope && typeof scope.setPropagationContext === 'function') {
+      scope.setPropagationContext({
+        traceId: currentTraceId,
+        spanId: currentTraceId.substring(0, 16),
+        sampled: true,
+      });
+    }
+  } catch (e) {
+    // Ignore errors - propagation context may not be supported
+    console.log('Could not set propagation context:', e.message);
+  }
+}
+
+/**
+ * Clear the session trace context
+ */
+function clearSessionTraceContext() {
+  currentTraceId = null;
+  currentSessionId = null;
+}
+
+/**
+ * Get the current trace ID (for debugging)
+ * @returns {string|null} Current trace ID or null
+ */
+function getTraceId() {
+  return currentTraceId;
+}
+
+/**
+ * Attach log listeners to an emitter to capture CLI logs as Sentry breadcrumbs
+ * @param {EventEmitter} emitter - The event emitter to listen to
+ */
+function attachLogListeners(emitter) {
+
+  if (!isEnabled() || !emitter || emitterAttached) return;
+  
+  // Check if Sentry.logger is available
+  if (!Sentry.logger) {
+    console.log('Sentry.logger not available, skipping log listeners');
+    return;
+  }
+  
+  emitterAttached = true;
+
+  // Helper to strip ANSI codes for cleaner logs
+  const stripAnsi = (str) => {
+    if (typeof str !== 'string') return String(str);
+    return str.replace(/\x1B[[(?);]{0,2}(;?\d)*./g, '');
+  };
+
+  // Helper to get current log attributes with trace context
+  const getLogAttributes = (extra = {}) => {
+    const attrs = { ...extra };
+    if (currentSessionId) {
+      attrs['session.id'] = currentSessionId;
+    }
+    if (currentTraceId) {
+      attrs['sentry.trace.trace_id'] = currentTraceId;
+    }
+    // Get current user from Sentry scope
+    try {
+      const user = Sentry.getCurrentScope().getUser();
+      if (user) {
+        if (user.id) attrs['user.id'] = user.id;
+        if (user.email) attrs['user.email'] = user.email;
+        if (user.username) attrs['user.name'] = user.username;
+      }
+    } catch (e) {
+      // Ignore errors getting user
+    }
+    return attrs;
+  };
+  
+  // Capture log:log as info logs
+  emitter.on('log:log', (message) => {
+    Sentry.logger.info(stripAnsi(message), getLogAttributes({ category: 'cli.log' }));
+  });
+  
+  // Capture log:warn as warning logs
+  emitter.on('log:warn', (message) => {
+    Sentry.logger.warn(stripAnsi(message), getLogAttributes({ category: 'cli.warn' }));
+  });
+  
+  // Capture log:debug as debug logs (only in verbose mode)
+  if (process.env.VERBOSE || process.env.DEBUG || process.env.TD_DEBUG) {
+    emitter.on('log:debug', (message) => {
+      Sentry.logger.debug(stripAnsi(message), getLogAttributes({ category: 'cli.debug' }));
+    });
+  }
+  
+  // Capture command events
+  emitter.on('command:start', (data) => {
+    Sentry.logger.info(`Command started: ${data?.command || data?.name || 'unknown'}`, getLogAttributes({
+      category: 'cli.command',
+      ...data,
+    }));
+  });
+  
+  emitter.on('command:error', (data) => {
+    Sentry.logger.error(`Command error: ${data?.message || data?.error || 'unknown'}`, getLogAttributes({
+      category: 'cli.command',
+      ...data,
+    }));
+  });
+  
+  // Capture step events
+  emitter.on('step:start', (data) => {
+    Sentry.logger.info(`Step started: ${data?.step || data?.name || 'unknown'}`, getLogAttributes({
+      category: 'cli.step',
+    }));
+  });
+  
+  emitter.on('step:error', (data) => {
+    Sentry.logger.error(`Step error: ${data?.message || data?.error || 'unknown'}`, getLogAttributes({
+      category: 'cli.step',
+      ...data,
+    }));
+  });
+  
+  // Capture test events
+  emitter.on('test:start', (data) => {
+    Sentry.logger.info(`Test started: ${data?.name || 'unknown'}`, getLogAttributes({
+      category: 'cli.test',
+    }));
+  });
+  
+  emitter.on('test:error', (data) => {
+    Sentry.logger.error(`Test error: ${data?.message || data?.error || 'unknown'}`, getLogAttributes({
+      category: 'cli.test',
+      ...data,
+    }));
+  });
+}
+
+/**
+ * Start a new transaction for performance monitoring
+ * @param {string} name - Transaction name
+ * @param {string} op - Operation type
+ * @returns {Object} Transaction object
+ */
+function startTransaction(name, op = "cli") {
+  if (!isEnabled()) return null;
+  return Sentry.startSpan({ name, op });
+}
+
+/**
+ * Flush pending events before process exit
+ * @param {number} timeout - Timeout in milliseconds
+ */
+async function flush(timeout = 2000) {
+  if (!isEnabled()) return;
+  await Sentry.flush(timeout);
+}
+
+module.exports = {
+  Sentry,
+  isEnabled,
+  setUser,
+  setContext,
+  setTag,
+  captureException,
+  captureMessage,
+  setSessionTraceContext,
+  clearSessionTraceContext,
+  getTraceId,
+  attachLogListeners,
+  startTransaction,
+  flush,
+};