testdriverai 7.2.63 → 7.2.65

package/agent/index.js

@@ -36,6 +36,7 @@ const { createOutputs } = require("./lib/outputs.js");
 const isValidVersion = require("./lib/valid-version.js");
 const { events, createEmitter } = require("./events.js");
 const { createDebuggerProcess } = require("./lib/debugger.js");
+const logger = require("./lib/logger.js");
 let debuggerProcess = null; // single debugger process for all instances. otherwise they'll fight over ports. this should be in `web` anyway
 let debuggerStarted = false;
 
@@ -110,8 +111,8 @@ class TestDriverAgent extends EventEmitter2 {
     this.sandbox = createSandbox(this.emitter, this.analytics, this.session);
 
     // Attach Sentry log listeners to capture CLI logs as breadcrumbs
-      const sentry = require("../lib/sentry");
-      sentry.attachLogListeners(this.emitter);
+    const sentry = require("../lib/sentry");
+    sentry.attachLogListeners(this.emitter);
 
     // Set the OS for the sandbox to use
     this.sandbox.os = this.sandboxOs;
@@ -191,7 +192,14 @@ class TestDriverAgent extends EventEmitter2 {
   // allows us to save the current state, run lifecycle hooks, and track analytics
   async exit(failed = true, shouldSave = false, shouldRunPostrun = false) {
     const { formatter } = require("../sdk-log-formatter.js");
-    this.emitter.emit(events.log.narration, formatter.getPrefix("disconnect") + " " + theme.yellow.bold("Exiting") + theme.dim("..."), true);
+    this.emitter.emit(
+      events.log.narration,
+      formatter.getPrefix("disconnect") +
+        " " +
+        theme.yellow.bold("Exiting") +
+        theme.dim("..."),
+      true,
+    );
 
     // Clean up redraw interval
     if (this.redraw && this.redraw.cleanup) {
@@ -240,9 +248,7 @@ class TestDriverAgent extends EventEmitter2 {
     if (errorContext) {
       this.emitter.emit(events.error.fatal, errorContext);
     } else {
-      this.emitter.emit(
-        events.error.fatal,error,
-      );
+      this.emitter.emit(events.error.fatal, error);
     }
 
     if (skipPostrun) {
@@ -436,15 +442,12 @@ class TestDriverAgent extends EventEmitter2 {
     let mousePosition = await this.system.getMousePosition();
     let activeWindow = await this.system.activeWin();
 
-    let response = await this.sdk.req(
-      "check",
-      {
-        tasks: this.tasks,
-        images,
-        mousePosition,
-        activeWindow,
-      }
-    );
+    let response = await this.sdk.req("check", {
+      tasks: this.tasks,
+      images,
+      mousePosition,
+      activeWindow,
+    });
 
     // Use log.log (not markdown.static) so output goes through console spy to sandbox
     this.emitter.emit(events.log.log, response.data);
@@ -878,7 +881,7 @@ commands:
     currentTask,
     dry = false,
     validateAndLoop = false,
-    shouldSave = true
+    shouldSave = true,
   ) {
     // Check if execution has been stopped
     if (this.stopped) {
@@ -901,15 +904,12 @@ commands:
 
     this.lastScreenshot = await this.system.captureScreenBase64();
 
-    let message = await this.sdk.req(
-      "input",
-      {
-        input: currentTask,
-        mousePosition: await this.system.getMousePosition(),
-        activeWindow: await this.system.activeWin(),
-        image: this.lastScreenshot,
-      }
-    );
+    let message = await this.sdk.req("input", {
+      input: currentTask,
+      mousePosition: await this.system.getMousePosition(),
+      activeWindow: await this.system.activeWin(),
+      image: this.lastScreenshot,
+    });
 
     this.emitter.emit(events.log.log, message.data);
 
@@ -988,9 +988,9 @@ commands:
       const generateDir = path.join(this.workingDir, "testdriver", "generate");
       if (!fs.existsSync(generateDir)) {
         fs.mkdirSync(generateDir);
-        console.log("Created generate directory:", generateDir);
+        logger.log("Created generate directory:", generateDir);
       } else {
-        console.log("Generate directory already exists:", generateDir);
+        logger.log("Generate directory already exists:", generateDir);
       }
 
       let list = testPrompt.steps;
@@ -1626,8 +1626,8 @@ ${regression}
 
   // Returns the path to the last sandbox file
   getLastSandboxFilePath() {
-    const testdriverDir = path.join(process.cwd(), '.testdriver');
-    return path.join(testdriverDir, 'last-sandbox');
+    const testdriverDir = path.join(process.cwd(), ".testdriver");
+    return path.join(testdriverDir, "last-sandbox");
   }
 
   // Returns full sandbox info from last-sandbox file (no timeout - let API validate)
@@ -1648,7 +1648,7 @@ ${regression}
 
         return {
           sandboxId: sandboxInfo.sandboxId || sandboxInfo.instanceId || null,
-          os: sandboxInfo.os || 'linux',
+          os: sandboxInfo.os || "linux",
           ami: sandboxInfo.ami || null,
           instanceType: sandboxInfo.instanceType || null,
           timestamp: sandboxInfo.timestamp || null,
@@ -1663,7 +1663,7 @@ ${regression}
   // Returns sandboxId to use if AMI/instance type match current requirements
   getRecentSandboxId() {
     const sandboxInfo = this.getLastSandboxId();
-    
+
     if (!sandboxInfo || !sandboxInfo.sandboxId) {
       return null;
     }
@@ -1690,13 +1690,13 @@ ${regression}
   saveLastSandboxId(sandboxId, osType = "linux") {
     const lastSandboxFile = this.getLastSandboxFilePath();
     const testdriverDir = path.dirname(lastSandboxFile);
-    
+
     try {
       // Ensure .testdriver directory exists
       if (!fs.existsSync(testdriverDir)) {
         fs.mkdirSync(testdriverDir, { recursive: true });
       }
-      
+
       const sandboxInfo = {
         sandboxId: sandboxId,
         os: osType,
@@ -1757,15 +1757,9 @@ ${regression}
       // Also clear this.sandboxId to prevent reconnection attempts
       this.sandboxId = null;
       if (!this.config.CI && !this.newSandbox) {
-        this.emitter.emit(
-          events.log.log,
-          theme.dim("--`new` flag detected, will create a new sandbox"),
-        );
+        this.emitter.emit(events.log.log, theme.dim("Creating a new sandbox"));
       } else if (this.newSandbox) {
-        this.emitter.emit(
-          events.log.log,
-          theme.dim("--new-sandbox flag detected, will create a new sandbox"),
-        );
+        this.emitter.emit(events.log.log, theme.dim("Creating a new sandbox"));
       }
     }
 
@@ -1802,7 +1796,7 @@ ${regression}
         theme.dim(`using recent sandbox: ${recentId}`),
       );
       this.sandboxId = recentId;
-      
+
       try {
         let instance = await this.connectToSandboxDirect(
           this.sandboxId,
@@ -1850,13 +1844,17 @@ ${regression}
         console.error("Failed to reconnect to sandbox:", error);
       }
     }
-    
+
     // Create new sandbox (either because createNew is true, or no existing sandbox to connect to)
     if (!this.instance) {
       const { formatter } = require("../sdk-log-formatter.js");
       this.emitter.emit(
         events.log.narration,
-        formatter.getPrefix("connect") + " " + theme.green.bold("Creating") + " " + theme.cyan(`new sandbox...`),
+        formatter.getPrefix("connect") +
+          " " +
+          theme.green.bold("Creating") +
+          " " +
+          theme.cyan(`new sandbox...`),
       );
       // We don't have resiliency/retries baked in, so let's at least give it 1 attempt
       // to see if that fixes the issue.
@@ -1869,11 +1867,12 @@ ${regression}
       });
 
       // Extract the sandbox ID from the newly created sandbox
-      this.sandboxId = newSandbox?.sandbox?.sandboxId || newSandbox?.sandbox?.instanceId;
-      
+      this.sandboxId =
+        newSandbox?.sandbox?.sandboxId || newSandbox?.sandbox?.instanceId;
+
       // Use the configured sandbox OS type
       this.saveLastSandboxId(this.sandboxId, this.sandboxOs);
-      
+
       let instance = await this.connectToSandboxDirect(
         this.sandboxId,
         true, // always persist by default
@@ -2002,7 +2001,6 @@ ${regression}
   }
 
   async renderSandbox(instance, headless = false) {
-
     if (!headless) {
       let url;
 
@@ -2019,7 +2017,7 @@ ${regression}
           "/vnc_lite.html?token=V3b8wG9";
       } else {
         // If we don't have URL or IP, we can't render
-        console.warn("renderSandbox: Missing URL and IP in instance", instance);
+        logger.warn("renderSandbox: Missing URL and IP in instance", instance);
         return;
       }
 
@@ -2056,7 +2054,13 @@ Please check your network connection, TD_API_KEY, or the service status.`,
     }
 
     const { formatter } = require("../sdk-log-formatter.js");
-    this.emitter.emit(events.log.narration, formatter.getPrefix("connect") + " " + theme.green.bold("Authenticating") + theme.dim("..."));
+    this.emitter.emit(
+      events.log.narration,
+      formatter.getPrefix("connect") +
+        " " +
+        theme.green.bold("Authenticating") +
+        theme.dim("..."),
+    );
     let ableToAuth = await this.sandbox.auth(this.config.TD_API_KEY);
 
     if (!ableToAuth) {
@@ -2070,7 +2074,14 @@ Please check your network connection, TD_API_KEY, or the service status.`,
 
   async connectToSandboxDirect(sandboxId, persist = false, keepAlive = null) {
     const { formatter } = require("../sdk-log-formatter.js");
-    this.emitter.emit(events.log.narration, formatter.getPrefix("connect") + " " + theme.green.bold("Connecting") + " " + theme.cyan(`to sandbox...`));
+    this.emitter.emit(
+      events.log.narration,
+      formatter.getPrefix("connect") +
+        " " +
+        theme.green.bold("Connecting") +
+        " " +
+        theme.cyan(`to sandbox...`),
+    );
     let reply = await this.sandbox.connect(sandboxId, persist, keepAlive);
 
     // reply includes { success, url, sandbox: {...} }
@@ -2112,15 +2123,18 @@ Please check your network connection, TD_API_KEY, or the service status.`,
       let response = await this.sandbox.send(sandboxConfig, 60000 * 8);
 
       // Check if queued (all slots in use)
-      if (response.type === 'create.queued') {
+      if (response.type === "create.queued") {
         this.emitter.emit(
           events.log.narration,
-          formatter.getPrefix("queue") + " " + theme.yellow.bold("Waiting") + " " +
-          theme.dim(response.message),
+          formatter.getPrefix("queue") +
+            " " +
+            theme.yellow.bold("Waiting") +
+            " " +
+            theme.dim(response.message),
         );
 
         // Wait then retry
-        await new Promise(resolve => setTimeout(resolve, retryDelay));
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
         continue;
       }
 
@@ -2139,10 +2153,14 @@ Please check your network connection, TD_API_KEY, or the service status.`,
     // should be start of new session
     // If sandbox is connected, get system info; otherwise pass empty objects
     const isSandboxConnected = this.sandbox.apiSocketConnected;
-    
+
     const sessionRes = await this.sdk.req("session/start", {
-      systemInformationOsInfo: isSandboxConnected ? await this.system.getSystemInformationOsInfo() : {},
-      mousePosition: isSandboxConnected ? await this.system.getMousePosition() : {},
+      systemInformationOsInfo: isSandboxConnected
+        ? await this.system.getSystemInformationOsInfo()
+        : {},
+      mousePosition: isSandboxConnected
+        ? await this.system.getMousePosition()
+        : {},
       activeWindow: isSandboxConnected ? await this.system.activeWin() : {},
     });
 
@@ -2153,7 +2171,7 @@ Please check your network connection, TD_API_KEY, or the service status.`,
     }
 
     this.session.set(sessionRes.data.id);
-    
+
     // Set Sentry session trace context for distributed tracing
     // This links CLI errors/logs to the same trace as API calls
     try {

package/agent/interface.js

@@ -1,6 +1,4 @@
-const path = require("path");
 const { Args, Flags } = require("@oclif/core");
-const { events } = require("./events.js");
 
 /**
  * Creates command definitions using oclif format as the single source of truth
@@ -8,265 +6,27 @@ const { events } = require("./events.js");
  * @returns {Object} Command definitions object in oclif format
  */
 function createCommandDefinitions(agent) {
-  const normalizeFilePath = (file) => {
-    if (!file) {
-      file = "testdriver/testdriver.yaml";
-    }
-
-    file = path.join(agent.workingDir, file);
-    if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
-      file += ".yaml";
-    }
-
-    return file;
-  };
-
   return {
-    run: {
-      description: "Run a test file",
-      args: {
-        file: Args.string({
-          description: "Test file to run",
-          default: "testdriver/testdriver.yaml",
-          required: false,
-        }),
-      },
-      flags: {
-        heal: Flags.boolean({
-          description: "Enable automatic error recovery mode",
-          default: false,
-        }),
-        write: Flags.boolean({
-          description: "Save AI modifications to the test file",
-          default: false,
-        }),
-        headless: Flags.boolean({
-          description: "Run in headless mode (no GUI)",
-          default: false,
-        }),
-        new: Flags.boolean({
-          description:
-            "Create a new sandbox instead of reconnecting to an existing one",
-          default: false,
-        }),
-        "sandbox-ami": Flags.string({
-          description: "Specify AMI ID for sandbox instance (e.g., ami-1234)",
-        }),
-        "sandbox-instance": Flags.string({
-          description: "Specify EC2 instance type for sandbox (e.g., i3.metal)",
-        }),
-        ip: Flags.string({
-          description:
-            "Connect directly to a sandbox at the specified IP address",
-        }),
-        summary: Flags.string({
-          description: "Specify output file for summarize results",
-        }),
-        junit: Flags.string({
-          description: "Generate JUnit XML test report to specified file",
-          default: false,
-        }),
-        os: Flags.string({
-          description: "Operating system for the sandbox (windows or linux)",
-          options: ["windows", "linux"],
-          default: "linux",
-        }),
-      },
-      handler: async (args, flags) => {
-        // Use --path flag if provided, otherwise fall back to args.file
-        const file = normalizeFilePath(args.file);
-        const testStartTime = Date.now();
-
-        try {
-          await agent.runLifecycle("prerun");
-          // When run() is called through run.js CLI command, shouldExit should be true
-          const shouldExit = agent.cliArgs?.command === "run";
-          await agent.run(file, flags.write, shouldExit);
-
-          const testEndTime = Date.now();
-          const testDuration = testEndTime - testStartTime;
-
-          // Emit test success event for the entire test execution
-          agent.emitter.emit(events.test.success, {
-            filePath: file,
-            duration: testDuration,
-            timestamp: testEndTime,
-          });
-        } catch (error) {
-          const testEndTime = Date.now();
-          const testDuration = testEndTime - testStartTime;
-
-          // Emit test error event for the entire test execution
-          agent.emitter.emit(events.test.error, {
-            filePath: file,
-            error: error.message,
-            duration: testDuration,
-            timestamp: testEndTime,
-          });
-
-          throw error; // Re-throw to maintain existing error handling
-        }
-      },
-    },
-
-    edit: {
-      description: "Edit a test file interactively",
-      args: {
-        file: Args.string({
-          description: "Test file to edit",
-          default: "testdriver/testdriver.yaml",
-          required: false,
-        }),
-      },
-      flags: {
-        heal: Flags.boolean({
-          description: "Enable automatic error recovery mode",
-          default: false,
-        }),
-        headless: Flags.boolean({
-          description: "Run in headless mode",
-          default: false,
-        }),
-        new: Flags.boolean({
-          description:
-            "Create a new sandbox instead of reconnecting to an existing one",
-          default: false,
-        }),
-        "sandbox-ami": Flags.string({
-          description: "Specify AMI ID for sandbox instance (e.g., ami-1234)",
-        }),
-        "sandbox-instance": Flags.string({
-          description: "Specify EC2 instance type for sandbox (e.g., i3.metal)",
-        }),
-        ip: Flags.string({
-          description:
-            "Connect directly to a sandbox at the specified IP address",
-        }),
-        summary: Flags.string({
-          description: "Specify output file for summarize results",
-        }),
-        os: Flags.string({
-          description: "Operating system for the sandbox (windows or linux)",
-          options: ["windows", "linux"],
-          default: "windows",
-        }),
-      },
-      handler: async () => {
-        // Edit mode is handled by the CLI interface via factory.js
-        // This handler should not be called directly
-        throw new Error("Edit mode should be handled by CLI interface");
-      },
-    },
-
-    // Interactive commands that can be used within edit mode
-    explore: {
-      description: "Explore and interact with the current environment",
-      args: {
-        prompt: Args.string({
-          description: "What you want to explore or do",
-          required: false,
-        }),
-      },
-      flags: {},
-      handler: async (args) => {
-        await agent.exploratoryLoop(args.prompt || "", false, true, true);
-      },
-    },
-
-    save: {
-      description: "Save the current test script",
-      args: {
-        filename: Args.string({
-          description: "Optional filename to save to",
-          required: false,
-        }),
-      },
-      flags: {},
-      handler: async (args) => {
-        await agent.save(args.filename);
-      },
-    },
-
-    exit: {
-      description: "Exit the TestDriver agent",
-      args: {},
-      flags: {},
-      handler: async () => {
-        await agent.exit(false);
-      },
-    },
-
-    help: {
-      description: "Show help information",
-      args: {},
-      flags: {},
-      handler: async () => {
-        agent.showHelp();
-      },
-    },
-
-    version: {
-      description: "Show version information",
+    init: {
+      description: "Initialize a new TestDriver project with Vitest SDK examples",
       args: {},
       flags: {},
       handler: async () => {
-        const packageJson = require("../package.json");
-        console.log(`TestDriver.ai v${packageJson.version}`);
-      },
-    },
-
-    generate: {
-      description: "Generate test files based on current screen state",
-      args: {
-        prompt: Args.string({
-          description: "Multi-line text prompt describing what to generate",
-          required: false,
-        }),
-      },
-      flags: {
-        count: Flags.integer({
-          description: "Number of test files to generate",
-          default: 3,
-        }),
-        headless: Flags.boolean({
-          description: "Run in headless mode (no GUI)",
-          default: false,
-        }),
-        new: Flags.boolean({
-          description:
-            "Create a new sandbox instead of reconnecting to an existing one",
-          default: false,
-        }),
-        "sandbox-ami": Flags.string({
-          description: "Specify AMI ID for sandbox instance (e.g., ami-1234)",
-        }),
-        "sandbox-instance": Flags.string({
-          description: "Specify EC2 instance type for sandbox (e.g., i3.metal)",
-        }),
-        ip: Flags.string({
-          description:
-            "Connect directly to a sandbox at the specified IP address",
-        }),
-        os: Flags.string({
-          description: "Operating system for the sandbox (windows or linux)",
-          options: ["windows", "linux"],
-          default: "linux",
-        }),
-      },
-      handler: async (args, flags) => {
-        // Call generate with the count and prompt
-        await agent.generate(flags.count || 3, args.prompt);
+        // This handler is special - it doesn't need an agent instance
+        // It just scaffolds files, so it will be handled by the CLI command
+        throw new Error("Init mode should be handled by CLI interface");
       },
     },
 
-    init: {
-      description: "Initialize a new TestDriver project with Vitest SDK examples",
+    "setup": {
+      description:
+        "Set up TestDriver skills, agents, and MCP server for Claude Code",
       args: {},
       flags: {},
       handler: async () => {
-        // This handler is special - it doesn't need an agent instance
-        // It just scaffolds files, so it will be handled by the CLI command
-        throw new Error("Init mode should be handled by CLI interface");
+        throw new Error(
+          "setup should be handled by CLI interface",
+        );
       },
     },
   };

package/agent/lib/debugger-server.js

@@ -3,6 +3,7 @@ const http = require("http");
 const path = require("path");
 const fs = require("fs");
 const { eventsArray } = require("../events.js");
+const logger = require("./logger");
 
 let server = null;
 let wss = null;
@@ -131,7 +132,7 @@ function stopDebugger() {
   }
 
   clients.clear();
-  console.log("Debugger server stopped");
+  logger.log("Debugger server stopped");
 }
 
 module.exports = {

package/agent/lib/logger.js

@@ -0,0 +1,56 @@
+/**
+ * Logger utility for TestDriver
+ * 
+ * By default, outputs to stdout (console.log).
+ * When TD_STDIO=stderr is set, outputs to stderr (console.error).
+ * This is necessary for MCP servers which use stdout exclusively for JSON-RPC.
+ */
+
+const useStderr = process.env.TD_STDIO === 'stderr';
+
+/**
+ * Log a message - uses stdout by default, stderr if TD_STDIO=stderr
+ * @param {...any} args - Arguments to log
+ */
+function log(...args) {
+  if (useStderr) {
+    console.error(...args);
+  } else {
+    console.log(...args);
+  }
+}
+
+/**
+ * Log an error - always uses stderr
+ * @param {...any} args - Arguments to log
+ */
+function error(...args) {
+  console.error(...args);
+}
+
+/**
+ * Log a warning - uses stdout by default, stderr if TD_STDIO=stderr
+ * @param {...any} args - Arguments to log
+ */
+function warn(...args) {
+  if (useStderr) {
+    console.error(...args);
+  } else {
+    console.warn(...args);
+  }
+}
+
+/**
+ * Check if logger is configured to use stderr
+ * @returns {boolean}
+ */
+function isStderrMode() {
+  return useStderr;
+}
+
+module.exports = {
+  log,
+  error,
+  warn,
+  isStderrMode,
+};