testdriverai 7.3.2 → 7.3.3

package/mcp-server/src/session.ts

@@ -0,0 +1,194 @@
+/**
+ * Session state management for TestDriver MCP Server
+ * Tracks sandbox sessions for MCP server
+ */
+
+export interface SessionState {
+  sessionId: string;
+  sandboxId: string | null;
+  status: "initializing" | "active" | "expired" | "error";
+  os: "linux" | "windows";
+  resolution: string;
+  createdAt: number;
+  expiresAt: number;
+  keepAlive: number;
+  testFile: string | null;
+  lastScreenshot: string | null;
+  errorMessage?: string;
+}
+
+// Generate unique session ID
+function generateSessionId(): string {
+  return `td-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+
+/**
+ * Session Manager - handles session state for MCP server
+ */
+export class SessionManager {
+  private sessions: Map<string, SessionState> = new Map();
+  private currentSessionId: string | null = null;
+
+  /**
+   * Create a new session
+   */
+  createSession(options: {
+    sandboxId?: string;
+    os?: "linux" | "windows";
+    resolution?: string;
+    keepAlive?: number;
+    testFile?: string;
+  }): SessionState {
+    const sessionId = generateSessionId();
+    const keepAlive = options.keepAlive ?? 300000; // Default 5 minutes
+
+    const session: SessionState = {
+      sessionId,
+      sandboxId: options.sandboxId ?? null,
+      status: "initializing",
+      os: options.os ?? "linux",
+      resolution: options.resolution ?? "1366x768",
+      createdAt: Date.now(),
+      expiresAt: Date.now() + keepAlive,
+      keepAlive,
+      testFile: options.testFile ?? null,
+      lastScreenshot: null,
+    };
+
+    this.sessions.set(sessionId, session);
+    this.currentSessionId = sessionId;
+
+    return session;
+  }
+
+  /**
+   * Get the current active session
+   */
+  getCurrentSession(): SessionState | null {
+    if (!this.currentSessionId) return null;
+    return this.sessions.get(this.currentSessionId) ?? null;
+  }
+
+  /**
+   * Get a session by ID
+   */
+  getSession(sessionId: string): SessionState | null {
+    return this.sessions.get(sessionId) ?? null;
+  }
+
+  /**
+   * Update session state
+   */
+  updateSession(
+    sessionId: string,
+    updates: Partial<SessionState>
+  ): SessionState | null {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+
+    const updated = { ...session, ...updates };
+    this.sessions.set(sessionId, updated);
+    return updated;
+  }
+
+  /**
+   * Mark session as active with sandbox ID
+   */
+  activateSession(sessionId: string, sandboxId: string): SessionState | null {
+    return this.updateSession(sessionId, {
+      sandboxId,
+      status: "active",
+    });
+  }
+
+  /**
+   * Extend session expiry time by adding additional milliseconds
+   */
+  extendSession(sessionId: string, additionalMs: number): SessionState | null {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+
+    return this.updateSession(sessionId, {
+      expiresAt: session.expiresAt + additionalMs,
+    });
+  }
+
+  /**
+   * Refresh session expiry to reset the keepAlive timer from now
+   * Called on each command to keep session alive during active use
+   */
+  refreshSession(sessionId: string): SessionState | null {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+
+    return this.updateSession(sessionId, {
+      expiresAt: Date.now() + session.keepAlive,
+    });
+  }
+
+  /**
+   * Check if session is still valid
+   */
+  isSessionValid(sessionId: string): boolean {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    if (session.status === "expired" || session.status === "error") return false;
+    if (Date.now() > session.expiresAt) {
+      this.updateSession(sessionId, { status: "expired" });
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Get time remaining until session expires
+   */
+  getTimeRemaining(sessionId: string): number {
+    const session = this.sessions.get(sessionId);
+    if (!session) return 0;
+    return Math.max(0, session.expiresAt - Date.now());
+  }
+
+  /**
+   * Mark session as expired/ended
+   */
+  endSession(sessionId: string): void {
+    this.updateSession(sessionId, { status: "expired" });
+    if (this.currentSessionId === sessionId) {
+      this.currentSessionId = null;
+    }
+  }
+
+  /**
+   * Delete a session
+   */
+  deleteSession(sessionId: string): boolean {
+    if (this.currentSessionId === sessionId) {
+      this.currentSessionId = null;
+    }
+    return this.sessions.delete(sessionId);
+  }
+
+  /**
+   * Get session summary for status reporting
+   */
+  getSessionSummary(sessionId: string): {
+    sessionId: string;
+    status: string;
+    sandboxId: string | null;
+    timeRemaining: number;
+  } | null {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+
+    return {
+      sessionId: session.sessionId,
+      status: session.status,
+      sandboxId: session.sandboxId,
+      timeRemaining: this.getTimeRemaining(sessionId),
+    };
+  }
+}
+
+// Singleton instance
+export const sessionManager = new SessionManager();

package/mcp-server/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "src/mcp-app.ts", "src/mcp-app.css"]
+}

package/mcp-server/vite.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from "vite";
+import { viteSingleFile } from "vite-plugin-singlefile";
+
+const INPUT = process.env.INPUT;
+if (!INPUT) {
+  throw new Error("INPUT environment variable is not set");
+}
+
+const isDevelopment = process.env.NODE_ENV === "development";
+
+export default defineConfig({
+  plugins: [viteSingleFile()],
+  build: {
+    sourcemap: isDevelopment ? "inline" : undefined,
+    cssMinify: !isDevelopment,
+    minify: !isDevelopment,
+    rollupOptions: {
+      input: INPUT,
+    },
+    outDir: "dist",
+    emptyOutDir: false,
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testdriverai",
-  "version": "7.3.2",
+  "version": "7.3.3",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",
@@ -147,20 +147,5 @@
     ],
     "topicSeparator": " ",
     "default": "init"
-  },
-  "files": [
-    "agent/",
-    "bin/",
-    "ai/skills/",
-    "ai/agents/",
-    "debugger/",
-    "interfaces/",
-    "lib/",
-    "mcp-server/dist/",
-    "sdk.js",
-    "sdk.d.ts",
-    "sdk-log-formatter.js",
-    "index.js",
-    "schema.json"
-  ]
+  }
 }

package/scripts/generate-skills.js

@@ -0,0 +1,94 @@
+const fs = require("fs");
+const path = require("path");
+
+const docsDir = path.resolve(__dirname, "../docs/v7");
+const skillsDir = path.resolve(__dirname, "../ai/skills");
+
+console.log(`Generating skills from ${docsDir} to ${skillsDir}`);
+
+if (!fs.existsSync(skillsDir)) {
+  fs.mkdirSync(skillsDir, { recursive: true });
+}
+
+// Function to clean up markdown content
+function processContent(content) {
+  // Remove frontmatter
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
+  const match = content.match(frontmatterRegex);
+
+  let description = "";
+  let body = content;
+
+  if (match) {
+    const frontmatter = match[1];
+    // Parse description
+    const descMatch = frontmatter.match(/description:\s*["']?(.*?)["']?$/m);
+    if (descMatch) {
+      description = descMatch[1];
+    }
+
+    // Remove frontmatter from body
+    body = content.replace(frontmatterRegex, "").trim();
+  }
+
+  return { description, body };
+}
+
+// Read all MDX files
+let count = 0;
+
+// Function to process a directory
+function processDirectory(sourceDir) {
+  if (!fs.existsSync(sourceDir)) {
+    console.log(`Directory not found: ${sourceDir}`);
+    return;
+  }
+
+  const files = fs.readdirSync(sourceDir);
+
+  files.forEach((file) => {
+    if (!file.endsWith(".mdx") && !file.endsWith(".md")) return;
+
+    const filePath = path.join(sourceDir, file);
+    if (fs.lstatSync(filePath).isDirectory()) return;
+
+    // Use filename handling for both .md and .mdx
+    const skillName = path.basename(file, path.extname(file));
+    const skillPath = path.join(skillsDir, `testdriver:${skillName}`);
+
+    // Read content
+    const content = fs.readFileSync(filePath, "utf-8");
+    const { description, body } = processContent(content);
+
+    // Ensure description exists
+    const finalDescription = description || `TestDriver ${skillName} skill`;
+
+    // Ensure skill directory exists
+    if (!fs.existsSync(skillPath)) {
+      fs.mkdirSync(skillPath, { recursive: true });
+    }
+
+    // Create SKILL.md content
+    const skillContent = `---
+name: testdriver:${skillName}
+description: ${finalDescription}
+---
+<!-- Generated from ${file}. DO NOT EDIT. -->
+
+${body}
+`;
+
+    fs.writeFileSync(path.join(skillPath, "SKILL.md"), skillContent);
+    count++;
+  });
+}
+
+// Process docs
+processDirectory(docsDir);
+
+// Process agents
+const agentsDir = path.resolve(__dirname, "../ai/agents");
+console.log(`Generating skills from ${agentsDir} to ${skillsDir}`);
+processDirectory(agentsDir);
+
+console.log(`Successfully generated ${count} skills.`);