@testdriverai/agent 7.8.0-canary.10

package/agent/interface.js

@@ -0,0 +1,35 @@
+const { Args, Flags } = require("@oclif/core");
+
+/**
+ * Creates command definitions using oclif format as the single source of truth
+ * @param {Object} agent - The TestDriverAgent instance
+ * @returns {Object} Command definitions object in oclif format
+ */
+function createCommandDefinitions(agent) {
+  return {
+    init: {
+      description: "Initialize a new TestDriver project with Vitest SDK examples",
+      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");
+      },
+    },
+
+    "setup": {
+      description:
+        "Set up TestDriver skills, agents, and MCP server for Claude Code",
+      args: {},
+      flags: {},
+      handler: async () => {
+        throw new Error(
+          "setup should be handled by CLI interface",
+        );
+      },
+    },
+  };
+}
+
+module.exports = { createCommandDefinitions };

package/agent/lib/analytics.js

@@ -0,0 +1,22 @@
+const { createSDK } = require("./sdk");
+
+// Factory function that creates analytics with the provided emitter, config, and session
+const createAnalytics = (emitter, config, sessionInstance) => {
+  const sdk = createSDK(emitter, config, sessionInstance);
+
+  return {
+    track: async (event, data) => {
+      if (!config["TD_ANALYTICS"]) {
+        return;
+      }
+      if (Math.random() <= 0.01) {
+        // Fire-and-forget: don't await analytics calls
+        sdk.req("analytics", { event, data }).catch((err) => {
+          console.warn("Analytics track failed:", err.message);
+        });
+      }
+    },
+  };
+};
+
+module.exports = { createAnalytics };

package/agent/lib/censorship.js

@@ -0,0 +1,75 @@
+// Shared censorship functionality for sensitive data
+// Uses @npmcli/redact for common patterns (URLs, auth headers, etc.)
+// Plus custom logic for environment variables and interpolation vars
+const { redactLog } = require("@npmcli/redact");
+
+let interpolationVars = JSON.parse(process.env.TD_INTERPOLATION_VARS || "{}");
+
+// Handle local `TD_*` variables
+for (const [key, value] of Object.entries(process.env)) {
+  if (key.startsWith("TD_") && key !== "TD_INTERPOLATION_VARS") {
+    interpolationVars[key] = value;
+  }
+}
+
+// Function to censor sensitive data in strings using both npmcli/redact and custom logic
+const censorSensitiveData = (message) => {
+  if (typeof message !== "string") {
+    return message;
+  }
+
+  // First, use npmcli/redact for common patterns:
+  // - URLs with credentials (https://user:pass@host)
+  // - Authorization headers
+  // - Common secret patterns in logs
+  let result = redactLog(message);
+
+  // Then apply our custom interpolation variable redaction
+  // This catches application-specific secrets from TD_* env vars
+  for (let value of Object.values(interpolationVars)) {
+    // Avoid replacing vars that are 0 or 1 characters
+    if (value && value.length >= 2) {
+      result = result.replaceAll(value, "****");
+    }
+  }
+
+  return result;
+};
+
+// Function to censor sensitive data in any value (recursive for objects/arrays)
+const censorSensitiveDataDeep = (value) => {
+  try {
+    if (typeof value === "string") {
+      return censorSensitiveData(value);
+    } else if (Array.isArray(value)) {
+      return value.map(censorSensitiveDataDeep);
+    } else if (value && typeof value === "object") {
+      const result = {};
+      for (const [key, val] of Object.entries(value)) {
+        result[key] = censorSensitiveDataDeep(val);
+      }
+      return result;
+    }
+    return value;
+  } catch {
+    // If we hit any error (like circular reference), just return a safe placeholder
+    return "[Object]";
+  }
+};
+
+// Function to update interpolation variables (for runtime updates)
+const updateInterpolationVars = (newVars) => {
+  interpolationVars = { ...interpolationVars, ...newVars };
+};
+
+// Function to get current interpolation variables (for debugging)
+const getInterpolationVars = () => {
+  return { ...interpolationVars };
+};
+
+module.exports = {
+  censorSensitiveData,
+  censorSensitiveDataDeep,
+  updateInterpolationVars,
+  getInterpolationVars,
+};

package/agent/lib/commander.js

@@ -0,0 +1,246 @@
+// translates the yml into commands that can be executed by the system.
+const generator = require("./generator");
+const yaml = require("js-yaml");
+const marky = require("marky");
+const { createSDK } = require("./sdk");
+const { events } = require("../events");
+
+const createCommander = (
+  emitter,
+  commands,
+  analytics,
+  config,
+  outputsInstance,
+  sessionInstance,
+) => {
+  // Create SDK instance with emitter, config, and session
+  const sdk = createSDK(emitter, config, sessionInstance);
+  // replace all occurances of ${OUTPUT.ls} with outputs.get("ls") in every possible property of the `object`
+  // this is a recursive function that will go through all the properties of the object
+  const replaceOutputs = (obj) => {
+    for (let key in obj) {
+      if (typeof obj[key] === "object") {
+        replaceOutputs(obj[key]);
+      } else if (typeof obj[key] === "string") {
+        obj[key] = obj[key].replace(/\${OUTPUT\.(.*?)}/g, (_, match) =>
+          outputsInstance.get(match),
+        );
+      }
+    }
+  };
+
+  // object is a json representation of the individual yml command
+  // the process turns markdown -> yml -> json -> js function execution
+  const run = async (object, depth) => {
+    // success returns null
+    // if this is set, it means that we need to take more action and a new thread is spawned
+    let response = null;
+
+    if (!object?.command) {
+      // Enhanced error with potential location info
+      const error = new Error(`YML is formatted improperly. 
+  
+The input YML is:
+${yaml.dump(object)}
+
+Our test structure is in YAML format. 
+
+- Each step is an object with a key of \`commands\` and a value of an array of commands. 
+- Each command is an object with a key of \`command\` and a value of the command to run.
+
+Here is a simple example:
+
+\`\`\`yaml
+commands:
+  - command: press-keys
+    keys: [command, space]
+\`\`\``);
+
+      error.yamlObject = object;
+      throw error;
+    } else {
+      replaceOutputs(object);
+
+      let copy = JSON.parse(JSON.stringify(object));
+
+      marky.mark(object.command);
+
+      // Emit command status event
+      emitter.emit(events.command.status, {
+        command: object.command,
+        status: "executing",
+        data: object,
+        depth,
+        timestamp: Date.now(),
+      });
+
+      // we speak, log, and take images here because we want to be careful not to render a notification containing the text we're looking for
+      // or to cover the screen of some item we might want
+
+      // this will actually interpret the command and execute it
+      switch (object.command) {
+        case "type":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands.type(object.text, object.delay);
+          break;
+        case "press-keys":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["press-keys"](object.keys);
+          break;
+        case "scroll":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands.scroll(object.direction, object.amount);
+          break;
+        case "wait":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands.wait(object.timeout);
+          break;
+        case "click":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["click"](object.x, object.y, object.action);
+          break;
+        case "hover":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["hover"](object.x, object.y);
+          break;
+        case "drag":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["drag"](object.x, object.y);
+          break;
+        case "hover-text":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["hover-text"]({
+            text: object.text,
+            description: object.description,
+            action: object.action,
+            timeout: object.timeout,
+          });
+          break;
+        case "hover-image":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["hover-image"](
+            object.description,
+            object.action,
+          );
+          break;
+        case "match-image":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["match-image"](
+            object.path,
+            object.action,
+            object.invert,
+          );
+          break;
+        case "wait-for-image":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["wait-for-image"](
+            object.description,
+            object.timeout,
+            object.invert,
+          );
+          break;
+        case "wait-for-text":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          copy.text = "*****";
+          response = await commands["wait-for-text"](
+            object.text,
+            object.timeout,
+            object.method,
+            object.invert,
+          );
+          break;
+        case "scroll-until-text":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          copy.text = "*****";
+          response = await commands["scroll-until-text"](
+            object.text,
+            object.direction,
+            object.distance,
+            object.textMatchMethod,
+            object.method,
+            object.invert,
+          );
+          break;
+        case "scroll-until-image": {
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["scroll-until-image"](
+            object.description,
+            object.direction,
+            object.distance,
+            object.method,
+            object.path,
+            object.invert,
+          );
+          break;
+        }
+        case "focus-application":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands["focus-application"](object.name);
+          break;
+        case "extract": {
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          let value = await commands["extract"](object.description);
+          emitter.emit(events.log.log, value);
+          outputsInstance.set(object.output, value);
+          break;
+        }
+        case "assert":
+          emitter.emit(events.log.log, generator.jsonToManual(object));
+          response = await commands.assert(
+            object.expect,
+            object.async,
+            object.invert,
+          );
+
+          break;
+        case "exec":
+          emitter.emit(
+            events.log.log,
+            generator.jsonToManual({
+              command: object.command,
+              code:
+                object.code.length > 100
+                  ? object.code.slice(0, 100) + "..."
+                  : object.code,
+              lang: object.lang,
+            }),
+          );
+
+          response = await commands.exec(
+            object.lang,
+            object.code,
+            object.timeout || 60 * 3 * 1000,
+          );
+
+          outputsInstance.set(object.output, response);
+
+          break;
+        default: {
+          const error = new Error(`Command not found: ${object.command}`);
+          error.yamlObject = object;
+          throw error;
+        }
+      }
+    }
+
+    let timing = marky.stop(object.command);
+
+    // Emit command progress event
+    emitter.emit(events.command.progress, {
+      command: object.command,
+      status: "completed",
+      timing: timing.duration,
+      data: object,
+      depth,
+      timestamp: Date.now(),
+    });
+
+    analytics.track("command", { data: object, depth, timing });
+
+    return response;
+  };
+
+  return { run };
+};
+
+module.exports = { createCommander };