testdriverai 7.2.3 → 7.2.9

package/.github/workflows/publish.yaml

@@ -1,12 +1,13 @@
-name: Publish Beta
+name: Publish
 permissions:
     contents: write
+    id-token: write  # Required for OIDC
 on:
   push:
     branches: [ main ]
 
 jobs:
-  publish-beta:
+  publish:
     runs-on: ubuntu-latest
     
     steps:
@@ -29,16 +30,23 @@ jobs:
     - name: Install dependencies
       run: npm ci
     
-    - name: Bump version (prerelease beta)
-      run: npm version prerelease --preid=beta --no-git-tag-version
+    - name: Bump version (patch)
+      run: npm version patch --no-git-tag-version
     
     - name: Commit and push version bump
       run: |
         git add package.json package-lock.json
-        git commit -m "chore: bump beta version to $(node -p "require('./package.json').version")"
+        git commit -m "chore: bump version to $(node -p "require('./package.json').version")"
         git push
     
-    - name: Publish to npm under beta tag
-      run: npm publish --tag beta
+    - name: Debug NPM Token
+      run: |
+        echo "NPM_TOKEN is set: ${{ secrets.NPM_TOKEN != '' }}"
+        echo "NPM_TOKEN first 4 chars: ${NPM_TOKEN:0:4}..."
+      env:
+        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+    
+    - name: Publish to npm
+      run: npm publish --tag beta 
       env:
         NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/testdriver.yml

@@ -0,0 +1,36 @@
+name: TestDriver.ai Tests
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20'
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Run TestDriver.ai tests
+      env:
+        TD_API_KEY: ${{ secrets.TD_API_KEY }}
+      run: npx vitest run
+
+    - name: Upload test results
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: test-results
+        path: test-results/
+        retention-days: 30

package/agent/index.js

@@ -17,7 +17,6 @@ const diff = require("diff");
 
 // global utilities
 const generator = require("./lib/generator.js");
-const promptCache = require("./lib/cache.js");
 const theme = require("./lib/theme.js");
 const SourceMapper = require("./lib/source-mapper.js");
 
@@ -110,6 +109,10 @@ class TestDriverAgent extends EventEmitter2 {
     // Create sandbox instance with this agent's emitter, analytics, and session
     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);
+
     // Set the OS for the sandbox to use
     this.sandbox.os = this.sandboxOs;
 
@@ -191,6 +194,15 @@ class TestDriverAgent extends EventEmitter2 {
       this.redraw.cleanup();
     }
 
+    // Close sandbox connection to release the connection slot
+    if (this.sandbox) {
+      try {
+        this.sandbox.close();
+      } catch (err) {
+        // Ignore sandbox close errors during exit
+      }
+    }
+
     shouldRunPostrun =
       !this.hasRunPostrun &&
       (shouldRunPostrun || this.cliArgs?.command == "run");
@@ -356,7 +368,7 @@ class TestDriverAgent extends EventEmitter2 {
           image,
         },
         (chunk) => {
-          if (chunk.type === "data") {
+          if (chunk.type === "data" && chunk.data) {
             this.emitter.emit(events.log.markdown.chunk, streamId, chunk.data);
           }
         },
@@ -420,9 +432,6 @@ class TestDriverAgent extends EventEmitter2 {
     let mousePosition = await this.system.getMousePosition();
     let activeWindow = await this.system.activeWin();
 
-    const streamId = `check-${Date.now()}`;
-    this.emitter.emit(events.log.markdown.start, streamId);
-
     let response = await this.sdk.req(
       "check",
       {
@@ -430,15 +439,10 @@ class TestDriverAgent extends EventEmitter2 {
         images,
         mousePosition,
         activeWindow,
-      },
-      (chunk) => {
-        if (chunk.type === "data") {
-          this.emitter.emit(events.log.markdown.chunk, streamId, chunk.data);
-        }
-      },
+      }
     );
 
-    this.emitter.emit(events.log.markdown.end, streamId);
+    this.emitter.emit(events.log.markdown.static, response.data);
 
     this.lastScreenshot = thisScreenshot;
 
@@ -869,8 +873,7 @@ commands:
     currentTask,
     dry = false,
     validateAndLoop = false,
-    shouldSave = true,
-    useCache = true,
+    shouldSave = true
   ) {
     // Check if execution has been stopped
     if (this.stopped) {
@@ -889,56 +892,10 @@ commands:
 
     this.tasks.push(currentTask);
 
-    // Check cache first (if enabled via parameter)
-    const cachedYaml = useCache ? promptCache.readCache(currentTask) : null;
-
-    if (cachedYaml) {
-      // Cache hit - load and execute the cached YAML file
-      this.emitter.emit(
-        events.log.debug,
-        `Using cached response for prompt: "${currentTask}"`,
-      );
-      this.emitter.emit(events.log.log, theme.dim("(using cached response)"));
-
-      try {
-        // Load the YAML using hydrateFromYML
-        const parsed = await generator.hydrateFromYML(
-          cachedYaml,
-          this.sessionInstance,
-        );
-
-        // Execute the commands from the first step
-        if (parsed.steps && parsed.steps.length > 0) {
-          const step = parsed.steps[0];
-          if (step.commands) {
-            await this.executeCommands(
-              step.commands,
-              0,
-              false,
-              dry,
-              shouldSave,
-            );
-          }
-        }
-      } catch (err) {
-        this.emitter.emit(
-          events.log.debug,
-          `Error loading cached YAML: ${err.message}, falling back to API`,
-        );
-        // Fall through to make API call if cache is invalid
-      }
-
-      return;
-    }
-
-    // Cache miss - call the API
     this.emitter.emit(events.log.narration, theme.dim("thinking..."), true);
 
     this.lastScreenshot = await this.system.captureScreenBase64();
 
-    const streamId = `input-${Date.now()}`;
-    this.emitter.emit(events.log.markdown.start, streamId);
-
     let message = await this.sdk.req(
       "input",
       {
@@ -946,59 +903,12 @@ commands:
         mousePosition: await this.system.getMousePosition(),
         activeWindow: await this.system.activeWin(),
         image: this.lastScreenshot,
-      },
-      (chunk) => {
-        if (chunk.type === "data") {
-          this.emitter.emit(events.log.markdown.chunk, streamId, chunk.data);
-        }
-      },
+      }
     );
 
-    this.emitter.emit(events.log.markdown.end, streamId);
+    this.emitter.emit(events.log.log, message.data);
 
     if (message && message.data) {
-      // Save the YAML to cache (if enabled)
-      if (useCache) {
-        try {
-          // Extract YAML code blocks from the markdown response
-          const codeblocks = await this.parser.findCodeBlocks(message.data);
-          if (codeblocks && codeblocks.length > 0) {
-            // Parse commands from all code blocks
-            const allCommands = [];
-            for (const block of codeblocks) {
-              const commands = await this.parser.getCommands(block);
-              allCommands.push(...commands);
-            }
-
-            // Create a proper step with prompt
-            const step = {
-              prompt: currentTask,
-              commands: allCommands,
-            };
-
-            // Use dumpToYML to create a valid testdriver yaml file
-            const yamlContent = await generator.dumpToYML(
-              [step],
-              this.sessionInstance,
-            );
-
-            const cachePath = promptCache.writeCache(currentTask, yamlContent);
-            if (cachePath) {
-              this.emitter.emit(
-                events.log.debug,
-                `Cached YAML saved to: ${cachePath}`,
-              );
-            }
-          }
-        } catch (err) {
-          // If we can't extract YAML, just skip caching
-          this.emitter.emit(
-            events.log.debug,
-            `Could not cache response: ${err.message}`,
-          );
-        }
-      }
-
       await this.aiExecute(message.data, validateAndLoop, dry, shouldSave);
       this.emitter.emit(
         events.log.debug,
@@ -2200,6 +2110,15 @@ 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 {
+      const sentry = require("../lib/sentry");
+      sentry.setSessionTraceContext(sessionRes.data.id);
+    } catch (e) {
+      // Sentry module may not be available, ignore
+    }
   }
 
   // Helper method to find testdriver directory by traversing up from a file path

package/bin/testdriverai.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+// Initialize Sentry first, before any other modules
+const sentry = require("../lib/sentry");
+
 // Set process priority if possible
 const os = require("os");
 try {
@@ -10,5 +13,10 @@ try {
   // Ignore if not permitted
 }
 
+// Ensure Sentry flushes on exit
+process.on("beforeExit", async () => {
+  await sentry.flush();
+});
+
 // Run the CLI
 require("../interfaces/cli.js");

package/debugger/index.html

@@ -307,9 +307,46 @@
         text-align: center;
         user-select: none;
       }
+
+      .close-button {
+        position: fixed;
+        top: 12px;
+        right: 12px;
+        z-index: 100;
+        background: rgba(0, 0, 0, 0.8);
+        border: 1px solid #444;
+        color: #fff;
+        padding: 8px 16px;
+        border-radius: 6px;
+        cursor: pointer;
+        font-size: 13px;
+        font-weight: 500;
+        pointer-events: auto;
+        transition: all 0.2s ease;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+      }
+
+      .close-button:hover {
+        background: rgba(220, 53, 69, 0.9);
+        border-color: #dc3545;
+      }
+
+      .close-button svg {
+        width: 14px;
+        height: 14px;
+        fill: currentColor;
+      }
     </style>
   </head>
   <body>
+    <!-- Close window button -->
+    <button class="close-button" onclick="window.close()" title="Close this window">
+      <svg viewBox="0 0 24 24"><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg>
+      Close
+    </button>
+
     <!-- Loading screen -->
     <div class="loading-screen" id="loading-screen">
       <div class="testdriver-logo">

package/docs/v7/_drafts/architecture.mdx

@@ -44,7 +44,6 @@ This system provides comprehensive test execution tracking, linking test runs wi
 │         │                │                                   │
 │         │ • TdTestRun    │                                   │
 │         │ • TdTestCase   │                                   │
-│         │ • TdSandbox    │                                   │
 │         │ • Replay       │                                   │
 │         └────────────────┘                                   │
 │                                                               │
@@ -95,7 +94,6 @@ Represents a complete test suite execution (e.g., `npx vitest run`).
 
 **Relationships:**
 - `team`: Owner team
-- `sandbox`: TdSandbox where tests ran
 - `testCases`: Collection of TdTestCase
 - `replays`: Associated Replay records
 
@@ -114,36 +112,13 @@ Represents an individual test within a test run.
 
 **Relationships:**
 - `testRun`: Parent TdTestRun
-- `replay`: Associated Replay record
-
-### TdSandbox
-Represents a spawned VM/sandbox instance.
-
-**Key Fields:**
-- `sandboxId`: Unique identifier
-- `platform`: windows | mac | linux
-- `status`: provisioning | ready | running | stopped | terminated
-- `instanceId`, `instanceType`: AWS EC2 details
-- `ipAddress`, `vncUrl`, `wsUrl`: Connection details
-- `spawnTime`, `readyTime`, `terminateTime`: Lifecycle timestamps
-- `dashcamAuth`: Whether dashcam was authenticated
-- `dashcamProjectId`: Dashcam project for replays
-
-**Relationships:**
-- `team`: Owner team
-- `user`: User who spawned it
-- `testRuns`: Tests that ran on this sandbox
-- `replays`: Dashcam recordings from this sandbox
-
-**Note:** Sandbox creation/updates happen via WebSocket (not REST API) as part of the sandbox provisioning flow.
-
+- `replay`: Associated Replay recor
 ### Replay (Extended)
 Existing model extended with test run associations.
 
 **New Fields:**
 - `tdTestRun`: Associated test run
 - `tdTestCase`: Associated test case
-- `tdSandbox`: Sandbox where recorded
 
 ## API Endpoints
 

package/docs/v7/_drafts/quick-start-test-recording.mdx

@@ -185,7 +185,6 @@ await client.completeTestRun({
 **API (Backend)**
 - `api/models/TdTestRun.js` - Test run model
 - `api/models/TdTestCase.js` - Test case model
-- `api/models/TdSandbox.js` - Sandbox tracking model
 - `api/controllers/testdriver/testdriver-test-run-create.js` - Create test run endpoint
 - `api/controllers/testdriver/testdriver-test-run-complete.js` - Complete test run endpoint
 - `api/controllers/testdriver/testdriver-test-case-create.js` - Record test case endpoint

package/docs/v7/_drafts/test-recording.mdx

@@ -376,12 +376,6 @@ const run2 = await client.createTestRun({
 - Associated dashcam replay
 - Timing and duration
 
-### TdSandbox
-- VM/sandbox lifecycle tracking
-- Platform and OS information
-- Dashcam integration status
-- Cost and usage metrics
-
 ### Replay
 - Dashcam recordings
 - Linked to test runs and cases

package/docs/v7/api/act.mdx

@@ -3,6 +3,7 @@ title: "act()"
 sidebarTitle: "act"
 description: "Execute natural language tasks using AI"
 icon: "wand-magic-sparkles"
+tag: beta
 ---
 
 ## Overview

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,