@testdriverai/agent 7.8.0-test.38

package/mcp-server/dist/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/mcp-server/dist/provision-types.d.ts

@@ -0,0 +1,290 @@
+/**
+ * Shared provision types for MCP Server
+ * These types mirror the SDK's ProvisionAPI interface
+ *
+ * When adding new provision types to the SDK, add them here as well.
+ * Reference: sdk.d.ts ProvisionAPI interface
+ */
+import { z } from "zod";
+/**
+ * All available provision types
+ * Must match the SDK's ProvisionAPI methods
+ */
+export declare const ProvisionTypes: readonly ["chrome", "chromeExtension", "vscode", "installer", "electron"];
+export type ProvisionType = typeof ProvisionTypes[number];
+/**
+ * Options for provision.chrome
+ * Matches SDK: ProvisionChromeOptions
+ */
+export declare const ProvisionChromeOptionsSchema: z.ZodObject<{
+    /** URL to navigate to (default: 'https://example.com') */
+    url: z.ZodOptional<z.ZodString>;
+    /** Start maximized (default: true) */
+    maximized: z.ZodOptional<z.ZodBoolean>;
+    /** Use guest mode (default: false) */
+    guest: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    url?: string | undefined;
+    maximized?: boolean | undefined;
+    guest?: boolean | undefined;
+}, {
+    url?: string | undefined;
+    maximized?: boolean | undefined;
+    guest?: boolean | undefined;
+}>;
+export type ProvisionChromeOptions = z.infer<typeof ProvisionChromeOptionsSchema>;
+/**
+ * Options for provision.chromeExtension
+ * Matches SDK: ProvisionChromeExtensionOptions
+ */
+export declare const ProvisionChromeExtensionOptionsSchema: z.ZodObject<{
+    /** Local filesystem path to the unpacked extension directory */
+    extensionPath: z.ZodOptional<z.ZodString>;
+    /** Chrome Web Store extension ID */
+    extensionId: z.ZodOptional<z.ZodString>;
+    /** Start maximized (default: true) */
+    maximized: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    maximized?: boolean | undefined;
+    extensionPath?: string | undefined;
+    extensionId?: string | undefined;
+}, {
+    maximized?: boolean | undefined;
+    extensionPath?: string | undefined;
+    extensionId?: string | undefined;
+}>;
+export type ProvisionChromeExtensionOptions = z.infer<typeof ProvisionChromeExtensionOptionsSchema>;
+/**
+ * Options for provision.vscode
+ * Matches SDK: ProvisionVSCodeOptions
+ */
+export declare const ProvisionVSCodeOptionsSchema: z.ZodObject<{
+    /** Path to workspace or folder to open */
+    workspace: z.ZodOptional<z.ZodString>;
+    /** Array of extension IDs to install */
+    extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    workspace?: string | undefined;
+    extensions?: string[] | undefined;
+}, {
+    workspace?: string | undefined;
+    extensions?: string[] | undefined;
+}>;
+export type ProvisionVSCodeOptions = z.infer<typeof ProvisionVSCodeOptionsSchema>;
+/**
+ * Options for provision.installer
+ * Matches SDK: ProvisionInstallerOptions
+ */
+export declare const ProvisionInstallerOptionsSchema: z.ZodObject<{
+    /** URL to download the installer from (required) */
+    url: z.ZodString;
+    /** Filename to save as (auto-detected from URL if not provided) */
+    filename: z.ZodOptional<z.ZodString>;
+    /** Application name to focus after install */
+    appName: z.ZodOptional<z.ZodString>;
+    /** Whether to launch the app after installation (default: true) */
+    launch: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    filename?: string | undefined;
+    appName?: string | undefined;
+    launch?: boolean | undefined;
+}, {
+    url: string;
+    filename?: string | undefined;
+    appName?: string | undefined;
+    launch?: boolean | undefined;
+}>;
+export type ProvisionInstallerOptions = z.infer<typeof ProvisionInstallerOptionsSchema>;
+/**
+ * Options for provision.electron
+ * Matches SDK: ProvisionElectronOptions
+ */
+export declare const ProvisionElectronOptionsSchema: z.ZodObject<{
+    /** Path to Electron app (required) */
+    appPath: z.ZodString;
+    /** Additional electron args */
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    appPath: string;
+    args?: string[] | undefined;
+}, {
+    appPath: string;
+    args?: string[] | undefined;
+}>;
+export type ProvisionElectronOptions = z.infer<typeof ProvisionElectronOptionsSchema>;
+/**
+ * Complete session_start input schema
+ * Supports all provision types with their respective options
+ */
+export declare const SessionStartInputSchema: z.ZodObject<{
+    /** Provision type - determines which application to launch */
+    type: z.ZodDefault<z.ZodEnum<["chrome", "chromeExtension", "vscode", "installer", "electron"]>>;
+    /** URL to navigate to (for chrome/chromeExtension) */
+    url: z.ZodOptional<z.ZodString>;
+    /** Start maximized (for chrome/chromeExtension) */
+    maximized: z.ZodOptional<z.ZodBoolean>;
+    /** Use guest mode (for chrome) */
+    guest: z.ZodOptional<z.ZodBoolean>;
+    /** Local path to unpacked extension (for chromeExtension) */
+    extensionPath: z.ZodOptional<z.ZodString>;
+    /** Chrome Web Store extension ID (for chromeExtension) */
+    extensionId: z.ZodOptional<z.ZodString>;
+    /** Workspace path (for vscode) */
+    workspace: z.ZodOptional<z.ZodString>;
+    /** Extension IDs to install (for vscode) */
+    extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** URL to download installer from (for installer, required when type='installer') */
+    installerUrl: z.ZodOptional<z.ZodString>;
+    /** Filename for installer (for installer) */
+    installerFilename: z.ZodOptional<z.ZodString>;
+    /** App name to focus after install (for installer) */
+    appName: z.ZodOptional<z.ZodString>;
+    /** Launch app after install (for installer) */
+    launch: z.ZodOptional<z.ZodBoolean>;
+    /** Path to Electron app (for electron, required when type='electron') */
+    appPath: z.ZodOptional<z.ZodString>;
+    /** Electron args (for electron) */
+    electronArgs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Operating system for the sandbox */
+    os: z.ZodDefault<z.ZodEnum<["linux", "windows"]>>;
+    /** Keep sandbox alive duration in ms (default: 5 minutes) */
+    keepAlive: z.ZodDefault<z.ZodNumber>;
+    /** Path to test file - when provided, you MUST append generated code to this file after each action */
+    testFile: z.ZodOptional<z.ZodString>;
+    /** Reconnect to last sandbox */
+    reconnect: z.ZodDefault<z.ZodBoolean>;
+    /** API endpoint URL */
+    apiRoot: z.ZodOptional<z.ZodString>;
+    /** Direct IP address of self-hosted instance (bypasses cloud provisioning) */
+    ip: z.ZodOptional<z.ZodString>;
+    /** Sandbox ID to connect to (for debug-on-failure mode). When provided, connects to an existing sandbox instead of creating a new one. Skip provisioning. */
+    sandboxId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "chrome" | "chromeExtension" | "vscode" | "installer" | "electron";
+    os: "linux" | "windows";
+    keepAlive: number;
+    reconnect: boolean;
+    url?: string | undefined;
+    maximized?: boolean | undefined;
+    guest?: boolean | undefined;
+    extensionPath?: string | undefined;
+    extensionId?: string | undefined;
+    workspace?: string | undefined;
+    extensions?: string[] | undefined;
+    appName?: string | undefined;
+    launch?: boolean | undefined;
+    appPath?: string | undefined;
+    installerUrl?: string | undefined;
+    installerFilename?: string | undefined;
+    electronArgs?: string[] | undefined;
+    testFile?: string | undefined;
+    apiRoot?: string | undefined;
+    ip?: string | undefined;
+    sandboxId?: string | undefined;
+}, {
+    url?: string | undefined;
+    maximized?: boolean | undefined;
+    guest?: boolean | undefined;
+    extensionPath?: string | undefined;
+    extensionId?: string | undefined;
+    workspace?: string | undefined;
+    extensions?: string[] | undefined;
+    appName?: string | undefined;
+    launch?: boolean | undefined;
+    appPath?: string | undefined;
+    type?: "chrome" | "chromeExtension" | "vscode" | "installer" | "electron" | undefined;
+    installerUrl?: string | undefined;
+    installerFilename?: string | undefined;
+    electronArgs?: string[] | undefined;
+    os?: "linux" | "windows" | undefined;
+    keepAlive?: number | undefined;
+    testFile?: string | undefined;
+    reconnect?: boolean | undefined;
+    apiRoot?: string | undefined;
+    ip?: string | undefined;
+    sandboxId?: string | undefined;
+}>;
+export type SessionStartInput = z.infer<typeof SessionStartInputSchema>;
+/**
+ * Helper to extract provision-specific options from session start input
+ */
+export declare function getProvisionOptions(params: SessionStartInput): {
+    url: string;
+    maximized: boolean | undefined;
+    guest: boolean | undefined;
+    extensionPath?: undefined;
+    extensionId?: undefined;
+    workspace?: undefined;
+    extensions?: undefined;
+    filename?: undefined;
+    appName?: undefined;
+    launch?: undefined;
+    appPath?: undefined;
+    args?: undefined;
+} | {
+    extensionPath: string | undefined;
+    extensionId: string | undefined;
+    maximized: boolean | undefined;
+    url?: undefined;
+    guest?: undefined;
+    workspace?: undefined;
+    extensions?: undefined;
+    filename?: undefined;
+    appName?: undefined;
+    launch?: undefined;
+    appPath?: undefined;
+    args?: undefined;
+} | {
+    workspace: string | undefined;
+    extensions: string[] | undefined;
+    url?: undefined;
+    maximized?: undefined;
+    guest?: undefined;
+    extensionPath?: undefined;
+    extensionId?: undefined;
+    filename?: undefined;
+    appName?: undefined;
+    launch?: undefined;
+    appPath?: undefined;
+    args?: undefined;
+} | {
+    url: string;
+    filename: string | undefined;
+    appName: string | undefined;
+    launch: boolean | undefined;
+    maximized?: undefined;
+    guest?: undefined;
+    extensionPath?: undefined;
+    extensionId?: undefined;
+    workspace?: undefined;
+    extensions?: undefined;
+    appPath?: undefined;
+    args?: undefined;
+} | {
+    appPath: string;
+    args: string[] | undefined;
+    url?: undefined;
+    maximized?: undefined;
+    guest?: undefined;
+    extensionPath?: undefined;
+    extensionId?: undefined;
+    workspace?: undefined;
+    extensions?: undefined;
+    filename?: undefined;
+    appName?: undefined;
+    launch?: undefined;
+} | {
+    url?: undefined;
+    maximized?: undefined;
+    guest?: undefined;
+    extensionPath?: undefined;
+    extensionId?: undefined;
+    workspace?: undefined;
+    extensions?: undefined;
+    filename?: undefined;
+    appName?: undefined;
+    launch?: undefined;
+    appPath?: undefined;
+    args?: undefined;
+};

package/mcp-server/dist/provision-types.js

@@ -0,0 +1,174 @@
+/**
+ * Shared provision types for MCP Server
+ * These types mirror the SDK's ProvisionAPI interface
+ *
+ * When adding new provision types to the SDK, add them here as well.
+ * Reference: sdk.d.ts ProvisionAPI interface
+ */
+import { z } from "zod";
+// ====================================
+// Provision Type Definitions
+// ====================================
+/**
+ * All available provision types
+ * Must match the SDK's ProvisionAPI methods
+ */
+export const ProvisionTypes = ["chrome", "chromeExtension", "vscode", "installer", "electron"];
+// ====================================
+// Provision Options Schemas
+// ====================================
+/**
+ * Options for provision.chrome
+ * Matches SDK: ProvisionChromeOptions
+ */
+export const ProvisionChromeOptionsSchema = z.object({
+    /** URL to navigate to (default: 'https://example.com') */
+    url: z.string().optional().describe("URL to navigate to"),
+    /** Start maximized (default: true) */
+    maximized: z.boolean().optional().describe("Start maximized"),
+    /** Use guest mode (default: false) */
+    guest: z.boolean().optional().describe("Use guest mode"),
+});
+/**
+ * Options for provision.chromeExtension
+ * Matches SDK: ProvisionChromeExtensionOptions
+ */
+export const ProvisionChromeExtensionOptionsSchema = z.object({
+    /** Local filesystem path to the unpacked extension directory */
+    extensionPath: z.string().optional().describe("Path to unpacked extension directory"),
+    /** Chrome Web Store extension ID */
+    extensionId: z.string().optional().describe("Chrome Web Store extension ID"),
+    /** Start maximized (default: true) */
+    maximized: z.boolean().optional().describe("Start maximized"),
+});
+/**
+ * Options for provision.vscode
+ * Matches SDK: ProvisionVSCodeOptions
+ */
+export const ProvisionVSCodeOptionsSchema = z.object({
+    /** Path to workspace or folder to open */
+    workspace: z.string().optional().describe("Path to workspace or folder to open"),
+    /** Array of extension IDs to install */
+    extensions: z.array(z.string()).optional().describe("Extension IDs to install"),
+});
+/**
+ * Options for provision.installer
+ * Matches SDK: ProvisionInstallerOptions
+ */
+export const ProvisionInstallerOptionsSchema = z.object({
+    /** URL to download the installer from (required) */
+    url: z.string().describe("URL to download the installer from"),
+    /** Filename to save as (auto-detected from URL if not provided) */
+    filename: z.string().optional().describe("Filename to save as"),
+    /** Application name to focus after install */
+    appName: z.string().optional().describe("Application name to focus after install"),
+    /** Whether to launch the app after installation (default: true) */
+    launch: z.boolean().optional().describe("Launch app after installation"),
+});
+/**
+ * Options for provision.electron
+ * Matches SDK: ProvisionElectronOptions
+ */
+export const ProvisionElectronOptionsSchema = z.object({
+    /** Path to Electron app (required) */
+    appPath: z.string().describe("Path to Electron app"),
+    /** Additional electron args */
+    args: z.array(z.string()).optional().describe("Additional Electron arguments"),
+});
+// ====================================
+// Session Start Input Schema
+// ====================================
+/**
+ * Complete session_start input schema
+ * Supports all provision types with their respective options
+ */
+export const SessionStartInputSchema = z.object({
+    /** Provision type - determines which application to launch */
+    type: z.enum(ProvisionTypes).default("chrome").describe("Provision type: 'chrome' (browser), 'chromeExtension' (browser with extension), 'vscode' (VS Code), 'installer' (download and install app), 'electron' (Electron app)"),
+    // Chrome options
+    /** URL to navigate to (for chrome/chromeExtension) */
+    url: z.string().optional().describe("URL to navigate to (for chrome)"),
+    /** Start maximized (for chrome/chromeExtension) */
+    maximized: z.boolean().optional().describe("Start browser maximized"),
+    /** Use guest mode (for chrome) */
+    guest: z.boolean().optional().describe("Use Chrome guest mode"),
+    // Chrome extension options
+    /** Local path to unpacked extension (for chromeExtension) */
+    extensionPath: z.string().optional().describe("Path to unpacked extension directory"),
+    /** Chrome Web Store extension ID (for chromeExtension) */
+    extensionId: z.string().optional().describe("Chrome Web Store extension ID"),
+    // VSCode options
+    /** Workspace path (for vscode) */
+    workspace: z.string().optional().describe("Path to workspace or folder (for vscode)"),
+    /** Extension IDs to install (for vscode) */
+    extensions: z.array(z.string()).optional().describe("VSCode extension IDs to install"),
+    // Installer options
+    /** URL to download installer from (for installer, required when type='installer') */
+    installerUrl: z.string().optional().describe("URL to download installer from"),
+    /** Filename for installer (for installer) */
+    installerFilename: z.string().optional().describe("Filename for downloaded installer"),
+    /** App name to focus after install (for installer) */
+    appName: z.string().optional().describe("App name to focus after installation"),
+    /** Launch app after install (for installer) */
+    launch: z.boolean().optional().describe("Launch app after installation"),
+    // Electron options
+    /** Path to Electron app (for electron, required when type='electron') */
+    appPath: z.string().optional().describe("Path to Electron app"),
+    /** Electron args (for electron) */
+    electronArgs: z.array(z.string()).optional().describe("Additional Electron arguments"),
+    // Common session options
+    /** Operating system for the sandbox */
+    os: z.enum(["linux", "windows"]).default("linux").describe("Sandbox OS"),
+    /** Keep sandbox alive duration in ms (default: 5 minutes) */
+    keepAlive: z.number().default(300000).describe("Keep sandbox alive for this many ms"),
+    /** Path to test file - when provided, you MUST append generated code to this file after each action */
+    testFile: z.string().optional().describe("Path to test file. When provided, append generated code from each action to this file immediately."),
+    /** Reconnect to last sandbox */
+    reconnect: z.boolean().default(false).describe("Reconnect to last sandbox"),
+    /** API endpoint URL */
+    apiRoot: z.string().optional().describe("API endpoint URL"),
+    // Self-hosted connection options
+    /** Direct IP address of self-hosted instance (bypasses cloud provisioning) */
+    ip: z.string().optional().describe("Direct IP address of self-hosted Windows instance (e.g., from AWS). When provided, connects directly to this IP instead of using cloud provisioning."),
+    // Debug mode - connect to existing sandbox
+    /** Sandbox ID to connect to (for debug-on-failure mode). When provided, connects to an existing sandbox instead of creating a new one. Skip provisioning. */
+    sandboxId: z.string().optional().describe("Existing sandbox ID to connect to (from debug-on-failure mode). Skips provisioning."),
+});
+/**
+ * Helper to extract provision-specific options from session start input
+ */
+export function getProvisionOptions(params) {
+    switch (params.type) {
+        case "chrome":
+            return {
+                url: params.url || "https://example.com",
+                maximized: params.maximized,
+                guest: params.guest,
+            };
+        case "chromeExtension":
+            return {
+                extensionPath: params.extensionPath,
+                extensionId: params.extensionId,
+                maximized: params.maximized,
+            };
+        case "vscode":
+            return {
+                workspace: params.workspace,
+                extensions: params.extensions,
+            };
+        case "installer":
+            return {
+                url: params.installerUrl || "",
+                filename: params.installerFilename,
+                appName: params.appName,
+                launch: params.launch,
+            };
+        case "electron":
+            return {
+                appPath: params.appPath || "",
+                args: params.electronArgs,
+            };
+        default:
+            return {};
+    }
+}

package/mcp-server/dist/server.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * TestDriver MCP Server
+ * Enables AI agents to iteratively build tests with visual feedback
+ */
+export {};