@testdriverai/agent 7.8.0-canary.10

package/interfaces/cli/commands/setup.js

@@ -0,0 +1,382 @@
+const { Command } = require("@oclif/core");
+const { createCommandDefinitions } = require("../../../agent/interface.js");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const chalk = require("chalk");
+const { execSync } = require("child_process");
+const readline = require("readline");
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..", "..", "..");
+const CLAUDE_HOME = path.join(os.homedir(), ".claude");
+const CLAUDE_MCP_FILE = path.join(os.homedir(), ".claude.json");
+const CURSOR_MCP_FILE = path.join(os.homedir(), ".cursor", "mcp.json");
+
+const MCP_SERVER_CONFIG = {
+  "testdriver-cloud": {
+    type: "sse",
+    url: "https://replayable-dev-ian-mac-m1-16.ngrok.io/api/v1/mcp",
+    headers: {
+      "x-api-key": "${TD_API_KEY}",
+    },
+    description:
+      "Query TestDriver test runs, test cases, and filters for your team using an API key.",
+  },
+};
+
+const CURSOR_MCP_SERVER_CONFIG = {
+  "testdriver-cloud": {
+    type: "sse",
+    url: "https://replayable-dev-ian-mac-m1-16.ngrok.io/api/v1/mcp",
+    headers: {
+      "x-api-key": "${TD_API_KEY}",
+    },
+    description:
+      "Query TestDriver test runs, test cases, and filters for your team using an API key.",
+  },
+};
+
+class SetupCommand extends Command {
+  async run() {
+    await this.parse(SetupCommand);
+
+    console.log(chalk.cyan("\nSetting up TestDriver for Claude Code...\n"));
+
+    const sourceSkills = path.join(PACKAGE_ROOT, "ai", "skills");
+    const sourceAgents = path.join(PACKAGE_ROOT, "ai", "agents");
+
+    this.installSkills(sourceSkills, path.join(CLAUDE_HOME, "skills"));
+    this.installAgents(sourceAgents, path.join(CLAUDE_HOME, "agents"));
+    this.installClaudeMcp();
+    this.installCursorMcp();
+    await this.promptForApiKey();
+
+    console.log(chalk.green("\nSetup complete!\n"));
+    this.printNextSteps();
+    process.exit(0);
+  }
+
+  /**
+   * Recursively copy a directory's contents
+   */
+  copyDirSync(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        this.copyDirSync(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Install skills to ~/.claude/skills
+   */
+  installSkills(source, dest) {
+    if (!fs.existsSync(source)) {
+      console.log(
+        chalk.yellow("  Skills source not found, skipping: " + source),
+      );
+      return;
+    }
+
+    const skills = fs
+      .readdirSync(source, { withFileTypes: true })
+      .filter((d) => d.isDirectory());
+
+    for (const skill of skills) {
+      const srcDir = path.join(source, skill.name);
+      const destDir = path.join(dest, skill.name);
+      this.copyDirSync(srcDir, destDir);
+    }
+
+    console.log(chalk.green(`  Installed ${skills.length} skills to ${dest}`));
+  }
+
+  /**
+   * Install agents to ~/.claude/agents
+   */
+  installAgents(source, dest) {
+    if (!fs.existsSync(source)) {
+      console.log(
+        chalk.yellow("  Agents source not found, skipping: " + source),
+      );
+      return;
+    }
+
+    fs.mkdirSync(dest, { recursive: true });
+
+    const agents = fs.readdirSync(source).filter((f) => f.endsWith(".md"));
+
+    for (const agent of agents) {
+      fs.copyFileSync(path.join(source, agent), path.join(dest, agent));
+    }
+
+    console.log(
+      chalk.green(`  Installed ${agents.length} agent(s) to ${dest}`),
+    );
+  }
+
+  /**
+   * Add testdriver MCP server to ~/.claude.json
+   */
+  installClaudeMcp() {
+    let config = {};
+
+    if (fs.existsSync(CLAUDE_MCP_FILE)) {
+      try {
+        config = JSON.parse(fs.readFileSync(CLAUDE_MCP_FILE, "utf8"));
+      } catch {
+        // If the file is malformed, start fresh but warn
+        console.log(
+          chalk.yellow(
+            "  Warning: existing ~/.claude.json was not valid JSON, overwriting",
+          ),
+        );
+      }
+    }
+
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+
+    const alreadyConfigured = config.mcpServers["testdriver-cloud"];
+
+    Object.assign(config.mcpServers, MCP_SERVER_CONFIG);
+    fs.writeFileSync(CLAUDE_MCP_FILE, JSON.stringify(config, null, 2) + "\n");
+
+    if (alreadyConfigured) {
+      console.log(
+        chalk.green(`  Updated testdriver MCP server in ${CLAUDE_MCP_FILE}`),
+      );
+    } else {
+      console.log(
+        chalk.green(`  Added testdriver MCP server to ${CLAUDE_MCP_FILE}`),
+      );
+    }
+  }
+
+  /**
+   * Add testdriver MCP server to ~/.cursor/mcp.json
+   */
+  installCursorMcp() {
+    const cursorDir = path.dirname(CURSOR_MCP_FILE);
+    fs.mkdirSync(cursorDir, { recursive: true });
+
+    let config = {};
+
+    if (fs.existsSync(CURSOR_MCP_FILE)) {
+      try {
+        config = JSON.parse(fs.readFileSync(CURSOR_MCP_FILE, "utf8"));
+      } catch {
+        console.log(
+          chalk.yellow(
+            "  Warning: existing ~/.cursor/mcp.json was not valid JSON, overwriting",
+          ),
+        );
+      }
+    }
+
+    if (!config.servers) {
+      config.servers = {};
+    }
+
+    const alreadyConfigured = config.servers["testdriver-cloud"];
+
+    Object.assign(config.servers, CURSOR_MCP_SERVER_CONFIG);
+    fs.writeFileSync(CURSOR_MCP_FILE, JSON.stringify(config, null, 2) + "\n");
+
+    if (alreadyConfigured) {
+      console.log(
+        chalk.green(`  Updated testdriver MCP server in ${CURSOR_MCP_FILE}`),
+      );
+    } else {
+      console.log(
+        chalk.green(`  Added testdriver MCP server to ${CURSOR_MCP_FILE}`),
+      );
+    }
+  }
+
+  /**
+   * Prompt user for API key and save globally to shell profile
+   */
+  async promptForApiKey() {
+    // Check if TD_API_KEY is already set in the environment
+    if (process.env.TD_API_KEY) {
+      console.log(
+        chalk.gray("\n  API key already set in environment, skipping...\n"),
+      );
+      return;
+    }
+
+    console.log(chalk.cyan("\n  Setting up your TestDriver API key...\n"));
+    console.log(
+      chalk.gray("  Get your API key from: https://console.testdriver.ai/team"),
+    );
+
+    const shouldOpen = await this.askYesNo(
+      "  Open API keys page in browser? (Y/n): ",
+    );
+    if (shouldOpen) {
+      try {
+        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"),
+        );
+      }
+    }
+
+    const apiKey = await this.promptHidden(
+      "  Enter your API key (input will be hidden): ",
+    );
+
+    if (apiKey && apiKey.trim()) {
+      this.addToShellProfile("TD_API_KEY", apiKey.trim());
+      process.env.TD_API_KEY = apiKey.trim();
+    } else {
+      console.log(
+        chalk.yellow(
+          "\n  No API key entered. You can set it later:\n",
+        ),
+      );
+      console.log(chalk.gray('     export TD_API_KEY="your_api_key"\n'));
+    }
+  }
+
+  /**
+   * Prompt for hidden input (like password)
+   */
+  async promptHidden(question) {
+    return new Promise((resolve) => {
+      process.stdout.write(question);
+
+      const stdin = process.stdin;
+      const wasRaw = stdin.isRaw;
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding("utf8");
+
+      let input = "";
+
+      const onData = (char) => {
+        if (char === "\u0003") {
+          stdin.setRawMode(wasRaw);
+          process.exit();
+        }
+        if (char === "\r" || char === "\n") {
+          stdin.setRawMode(wasRaw);
+          stdin.removeListener("data", onData);
+          stdin.pause();
+          console.log("");
+          resolve(input);
+          return;
+        }
+        if (char === "\u007F" || char === "\b") {
+          input = input.slice(0, -1);
+          return;
+        }
+        input += char;
+      };
+
+      stdin.on("data", onData);
+    });
+  }
+
+  /**
+   * 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",
+        );
+      });
+    });
+  }
+
+  /**
+   * Add an environment variable export to the user's shell profile
+   */
+  addToShellProfile(key, value) {
+    if (process.platform === "win32") {
+      try {
+        execSync(`setx ${key} "${value}"`, { stdio: "ignore" });
+        console.log(
+          chalk.green(`\n  Set ${key} as user environment variable\n`),
+        );
+      } catch (error) {
+        console.log(
+          chalk.yellow(`\n  Could not set ${key} via setx. You can set it manually:\n`),
+        );
+        console.log(chalk.gray(`     setx ${key} "your_api_key"\n`));
+      }
+      return;
+    }
+
+    const shell = process.env.SHELL || "/bin/bash";
+    const home = os.homedir();
+    let profilePath;
+
+    if (shell.includes("zsh")) {
+      profilePath = path.join(home, ".zshrc");
+    } else {
+      profilePath = path.join(home, ".bashrc");
+    }
+
+    const exportLine = `export ${key}="${value}"`;
+
+    if (fs.existsSync(profilePath)) {
+      const content = fs.readFileSync(profilePath, "utf8");
+      if (content.includes(`export ${key}=`)) {
+        const updated = content.replace(
+          new RegExp(`^export ${key}=.*$`, "m"),
+          exportLine,
+        );
+        fs.writeFileSync(profilePath, updated);
+        console.log(
+          chalk.green(`\n  Updated ${key} in ${profilePath}\n`),
+        );
+        return;
+      }
+    }
+
+    fs.appendFileSync(profilePath, `\n${exportLine}\n`);
+    console.log(
+      chalk.green(`\n  Added ${key} to ${profilePath}\n`),
+    );
+  }
+
+  printNextSteps() {
+    console.log(chalk.cyan("Next steps:\n"));
+    console.log("  1. Restart Claude Code to pick up the new MCP server\n");
+  }
+}
+
+// Get command definition from interface.js
+const tempAgent = { workingDir: process.cwd() };
+const definitions = createCommandDefinitions(tempAgent);
+const commandDef = definitions["setup"];
+
+SetupCommand.description =
+  commandDef?.description ||
+  "Set up TestDriver skills, agents, and MCP for Claude Code";
+SetupCommand.args = commandDef?.args || {};
+SetupCommand.flags = commandDef?.flags || {};
+
+module.exports = SetupCommand;

package/interfaces/cli/lib/base.js

@@ -0,0 +1,285 @@
+/*
+This is an implementation of the TestDriver library. This file should not:
+- modify the agent's state
+- emit events back to the agent
+- etc
+*/
+
+const { Command } = require("@oclif/core");
+const { events } = require("../../../agent/events.js");
+const { createCommandDefinitions } = require("../../../agent/interface.js");
+const { createJUnitReporter } = require("../../junit-reporter.js");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const logger = require("../../logger.js");
+
+async function openBrowser(url) {
+  try {
+    // Use dynamic import for the 'open' package (ES module)
+    const { default: open } = await import("open");
+
+    // Open the browser
+    await open(url, {
+      // Wait for the app to open
+      wait: false,
+      background: true
+    });
+  } catch (error) {
+    console.error("Failed to open browser automatically:", error);
+    console.log(`Please manually open: ${url}`);
+  }
+}
+
+class BaseCommand extends Command {
+  constructor(argv, config) {
+    super(argv, config);
+    this.agent = null; // Initialize as null, create only when needed
+  }
+
+  sendToSandbox(message) {
+    if (!message) return;
+
+    // ensure message is a string
+    if (typeof message !== "string") {
+      message = JSON.stringify(message);
+    }
+
+    this.agent.sandbox.send({
+      type: "output",
+      output: Buffer.from(message).toString("base64"),
+    }).catch(() => {
+      // Silently ignore output send failures to prevent infinite loops
+    });
+  }
+
+  setupEventListeners() {
+    if (!this.logFilePath) {
+      // Create a temp log file for this session
+      this.logFilePath = path.join(
+        os.tmpdir(),
+        `testdriverai-cli-${process.pid}.log`,
+      );
+
+      console.log(`Log file: ${this.logFilePath}`);
+      console.log("");
+      fs.writeFileSync(this.logFilePath, ""); // Initialize the log file
+    }
+
+    // Helper to append log messages to the temp file
+    const appendLog = (level, message) => {
+      const timestamp = new Date().toISOString();
+      fs.appendFileSync(
+        this.logFilePath,
+        `[${timestamp}] [${level}] ${message}\n`,
+      );
+    };
+
+    let isConnected = false;
+    const debugMode = process.env.VERBOSE || process.env.TD_DEBUG;
+
+    // Use pattern matching for log events, but skip log:Debug unless debug mode is enabled
+    this.agent.emitter.on("log:*", (message) => {
+      const event = this.agent.emitter.event;
+
+      if (event === events.log.debug && !debugMode) return;
+
+      if (event === events.log.narration && isConnected) return;
+      console.log(message);
+    });
+
+    // Use pattern matching for error events
+    this.agent.emitter.on("error:*", (data) => {
+      const event = this.agent.emitter.event;
+      console.error(event, ":", data);
+    });
+
+    // Handle status events
+    this.agent.emitter.on("status", (message) => {
+      console.log(`- ${message}`);
+      this.sendToSandbox(`- ${message}`);
+    });
+
+    // Handle sandbox connection with pattern matching for subsequent events
+    this.agent.emitter.once("sandbox:connected", () => {
+      isConnected = true;
+      // Once sandbox is connected, send all log and error events to sandbox
+      this.agent.emitter.on("log:*", (message) => {
+        this.sendToSandbox(message);
+      });
+
+      this.agent.emitter.on("error:*", (message) => {
+        // Don't forward sandbox errors back to sandbox - this creates an infinite loop
+        // (sandbox error → error:* event → sendToSandbox → output message → sandbox error → ...)
+        const event = this.agent.emitter.event;
+        if (event === "error:sandbox") return;
+        this.sendToSandbox(message);
+      });
+    });
+
+    // Handle all other events with wildcard pattern
+    this.agent.emitter.on("**", (data) => {
+      const event = this.agent.emitter.event;
+      appendLog(event, JSON.stringify(data));
+    });
+
+    logger.createMarkdownLogger(this.agent.emitter);
+
+    // Initialize JUnit reporter if junit flag is provided
+    if (this.agent.cliArgs?.options?.junit) {
+      const junitOutputPath = this.agent.cliArgs.options.junit;
+      const mainTestFile = this.agent.thisFile; // Get the main test file from the agent
+      this.junitReporter = createJUnitReporter(
+        this.agent.emitter,
+        junitOutputPath,
+        mainTestFile,
+      );
+      console.log(`JUnit reporting enabled: ${junitOutputPath}`);
+    }
+
+    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
+    let isExiting = false;
+    const cleanupAndExit = async (signal) => {
+      if (isExiting) return;
+      isExiting = true;
+      
+      console.log(`\nReceived ${signal}, cleaning up...`);
+      
+      // Use the agent's exit method for proper cleanup
+      if (this.agent) {
+        try {
+          await this.agent.exit(true, false, false);
+        } catch (err) {
+          console.error("Error during cleanup:", err.message);
+        }
+      } else {
+        // Fallback if no agent
+        if (this.agent?.sandbox) {
+          try {
+            this.agent.sandbox.close();
+          } catch (err) {
+            // Ignore close errors
+          }
+        }
+        process.exit(1);
+      }
+    };
+
+    process.on('SIGINT', () => cleanupAndExit('SIGINT'));
+    process.on('SIGTERM', () => cleanupAndExit('SIGTERM'));
+
+    // 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) => {
+      // Log the rejection but don't let it crash the process
+      console.error("Unhandled Promise Rejection:", reason);
+      // The exit flow should continue normally
+    });
+
+    // Handle show window events
+    this.agent.emitter.on("show-window", async (url) => {
+      console.log("");
+      console.log(`Live test execution: `);
+      console.log(url);
+      if (!this.agent.config.CI) {
+        await openBrowser(url);
+      }
+    });
+  }
+
+  async init() {
+    // Only start debugger for commands that actually need it
+    // Help commands and other static commands don't need the debugger
+  }
+
+  // Extract file path from args or use default
+  normalizeFilePath(file) {
+    const path = require("path");
+    if (!file) {
+      // Use config default if agent is available, otherwise fall back to hardcoded default
+      file = "testdriver/testdriver.yaml";
+    }
+    file = path.join(this.agent.workingDir, file);
+    if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
+      file += ".yaml";
+    }
+    return file;
+  }
+
+  async setupAgent(firstArg, flags) {
+    // Load .env file into process.env for CLI usage
+    require("dotenv").config();
+
+    // Create the agent only when actually needed
+    const TestDriverAgent = require("../../../agent/index.js");
+
+    let args;
+    if (this.id === "generate") {
+      // For generate command, the first parameter is a prompt, not a file
+      args = firstArg ? [firstArg] : [];
+    } else {
+      // For run and other commands, handle file path
+      const filePath = this.id === "run" && flags.path ? flags.path : firstArg;
+      args = filePath ? [filePath] : [];
+    }
+
+    // Prepare CLI args for the agent with all derived options
+    const cliArgs = {
+      command: this.id,
+      args,
+      options: {
+        ...flags,
+        resultFile:
+          flags.summary && typeof flags.summary === "string"
+            ? path.resolve(flags.summary)
+            : null,
+      },
+    };
+
+    // Create agent with explicit process.env and consolidated CLI args
+    this.agent = new TestDriverAgent(process.env, cliArgs);
+    this.setupEventListeners();
+
+    try {
+      // Start the agent's initialization
+      await this.agent.start();
+    } catch (e) {
+      console.error("Failed to start agent:", e);
+      this.agent.emitter.emit(
+        events.error.fatal,
+        "Failed to start agent: " + JSON.stringify(e),
+      );
+      if (this.agent) {
+        await this.agent.exit(true);
+      } else {
+        process.exit(1);
+      }
+    }
+  }
+
+  // Get unified command definition for this command
+  getUnifiedDefinition() {
+    const commandName = this.id;
+    if (!this.agent) {
+      // Create a temporary agent for definition purposes with empty environment
+      const tempAgent = { workingDir: process.cwd() };
+      return createCommandDefinitions(tempAgent)[commandName];
+    }
+    const definitions = createCommandDefinitions(this.agent);
+    return definitions[commandName];
+  }
+}
+
+module.exports = BaseCommand;

package/interfaces/cli.js

@@ -0,0 +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(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);
+  });