@chen-rmag/core-infra 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,217 @@
+export interface TestStep {
+    id: string;
+    description: string;
+    status?: "running" | "success" | "error";
+    error?: string;
+    isBreakpoint?: boolean;
+    isAI?: boolean;
+    reusedTestIds?: string[];
+}
+export interface TableData {
+    testId: string;
+    columns: string[];
+    rows: Record<string, string>[];
+    createdAt: number;
+    updatedAt: number;
+}
+export type TestCaseType = 'functional' | 'ui' | 'edge';
+export type TestCasePriority = 'high' | 'medium' | 'low';
+export interface TestParameter {
+    key: string;
+    value: string;
+    description: string;
+}
+export interface TestCase {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    steps: TestStep[];
+    playwrightScript?: string;
+    createdAt: number;
+    updatedAt: number;
+    status: 'draft' | 'ready' | 'completed';
+    path: string;
+    creator?: 'user' | 'ai';
+    table?: TableData;
+    type?: TestCaseType;
+    reusable?: boolean;
+    dependencies?: string[];
+    priority?: TestCasePriority;
+    parameters?: TestParameter[];
+}
+export type LanguageCode = 'en-US' | 'zh-CN';
+export interface DirectoryInfo {
+    id: string;
+    name: string;
+    description?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface TestDirectory {
+    path: string;
+    name: string;
+    info?: DirectoryInfo;
+    children: TestDirectory[];
+    tests: TestCase[];
+}
+export type ModelProvider = 'openai' | 'anthropic' | 'mistral' | 'ollama' | 'openrouter';
+export interface ModelConfig {
+    id: string;
+    name: string;
+    provider: ModelProvider;
+    modelName: string;
+    apiKey?: string;
+    baseURL?: string;
+    temperature?: number;
+    maxTokens?: number;
+    timeout?: number;
+    isDefault?: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface AutomationJob {
+    id: string;
+    name: string;
+    url: string;
+    status: 'idle' | 'exploring' | 'generating' | 'completed' | 'error';
+    progress: number;
+    generatedTests: TestCase[];
+    insights: string[];
+    startedAt?: number;
+    completedAt?: number;
+    error?: string;
+    depth?: number;
+    maxTests?: number;
+}
+export interface ExplorationRecord {
+    id: string;
+    url: string;
+    status: 'pending' | 'running' | 'completed' | 'error';
+    progress: number;
+    currentPhase: string;
+    generatedTests: number;
+    testIds: string[];
+    config: {
+        modelConfigId: string;
+        modelName: string;
+        maxSteps: number;
+        maxTests: number;
+        exploreDepth: number;
+        explorationScope?: string;
+        customData?: Array<{
+            key: string;
+            value: string;
+        }>;
+        language?: LanguageCode;
+    };
+    interactions: Array<{
+        round: number;
+        type: 'exploration' | 'analysis' | 'generation';
+        phase: string;
+        message: string;
+        timestamp: number;
+    }>;
+    artifacts?: any;
+    startedAt: number;
+    completedAt?: number;
+    error?: string;
+}
+export interface MCPServer {
+    name: string;
+    endpoint: string;
+    capabilities: string[];
+    connected: boolean;
+    tools?: string[];
+}
+export interface BrowserCapabilities {
+    browsers: ('chromium' | 'firefox' | 'webkit')[];
+    headless: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    deviceScaleFactor?: number;
+    locale?: string;
+    timezone?: string;
+}
+export interface AppSettings {
+    theme: 'light' | 'dark';
+    aiModel: ModelConfig;
+    defaultBrowser: 'chromium' | 'firefox' | 'webkit';
+    headlessMode: boolean;
+    autoSave: boolean;
+    maxParallelTests: number;
+    screenshots: {
+        enabled: boolean;
+        captureOnError: boolean;
+        captureOnStep: boolean;
+    };
+    timeouts: {
+        navigation: number;
+        action: number;
+        assertion: number;
+    };
+    mcpSettings?: {
+        endpoint: string;
+        useStdio: boolean;
+    };
+}
+export interface TestResult {
+    id: string;
+    testId: string;
+    status: 'passed' | 'failed' | 'skipped';
+    duration: number;
+    executedAt: number;
+    error?: string;
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+    };
+}
+export interface ToolCallInfo {
+    toolCall?: ToolCall;
+    content: string;
+    status?: 'success' | 'error';
+    stepId?: string;
+}
+export type ToolCall = {
+    name: string;
+    args: Record<string, any>;
+    id?: string;
+    content?: string;
+};
+export interface Project {
+    id: string;
+    name: string;
+    description: string;
+    createdAt: number;
+    updatedAt?: number;
+    isActive: boolean;
+}
+export interface TestPlanItem {
+    type: 'test' | 'directory';
+    id: string;
+    name: string;
+    path?: string;
+    directoryPath?: string;
+}
+export interface TestPlan {
+    id: string;
+    name: string;
+    description: string;
+    projectId: string;
+    testIds: string[];
+    createdAt: number;
+    updatedAt: number;
+    status: 'ready' | 'running' | 'completed' | 'failed' | 'partial' | 'stopped';
+    lastExecutedAt?: number;
+    maxConcurrency?: number;
+    browsers?: Array<'chromium' | 'firefox' | 'webkit'>;
+    scheduledAt?: number;
+    passedIds?: string[];
+    failedIds?: string[];
+    skippedIds?: string[];
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@chen-rmag/core-infra",
+  "version": "1.0.0",
+  "description": "Core infrastructure for AI testing framework",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "testing",
+    "ai",
+    "mcp",
+    "infrastructure"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@langchain/anthropic": "^1.3.3",
+    "@langchain/core": "^1.1.12",
+    "@langchain/mistralai": "^1.0.2",
+    "@langchain/openai": "^1.2.0",
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25",
+    "typescript": "^5"
+  }
+}

package/src/directory-validator.ts

@@ -0,0 +1,98 @@
+/**
+ * Directory name validation utility
+ * Validates directory names against file system restrictions
+ */
+
+/**
+ * Windows and Linux forbidden characters in file/directory names
+ * Windows: < > : " | ? * and control characters
+ * Linux: only / and null character, but we also exclude other common problematic chars
+ * We use a stricter set to ensure cross-platform compatibility
+ */
+const FORBIDDEN_CHARS = /[<>:"|?*\\\/\x00]/;
+const RESERVED_NAMES = [
+  'CON', 'PRN', 'AUX', 'NUL', // Standard Windows reserved names
+  'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
+  'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9',
+];
+
+/**
+ * Validate a directory name
+ * @param name - Directory name to validate
+ * @returns { valid: boolean; error?: string }
+ */
+export function validateDirectoryName(name: string): { valid: boolean; error?: string } {
+  if (!name || name.trim().length === 0) {
+    return { valid: false, error: 'Directory name cannot be empty' };
+  }
+
+  // Check length
+  if (name.length > 255) {
+    return { valid: false, error: 'Directory name cannot exceed 255 characters' };
+  }
+
+  // Check for forbidden characters
+  if (FORBIDDEN_CHARS.test(name)) {
+    return {
+      valid: false,
+      error: 'Directory name cannot contain the following characters: < > : " | ? * \\ / and control characters',
+    };
+  }
+
+  // Check for leading/trailing spaces (problematic on Windows)
+  if (name !== name.trim() || name.startsWith('.') || name.endsWith('.')) {
+    return {
+      valid: false,
+      error: 'Directory name cannot start or end with spaces or dots',
+    };
+  }
+
+  // Check for reserved names (Windows)
+  const upperName = name.toUpperCase();
+  if (RESERVED_NAMES.includes(upperName)) {
+    return {
+      valid: false,
+      error: `"${name}" is a system reserved name and cannot be used as a directory name`,
+    };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Validate a directory path (multiple levels)
+ * @param path - Directory path like 'folder1/folder2/folder3'
+ * @returns { valid: boolean; error?: string }
+ */
+export function validateDirectoryPath(path: string): { valid: boolean; error?: string } {
+  if (!path) {
+    // Empty path is valid (root level)
+    return { valid: true };
+  }
+
+  const parts = path.split('/').filter(p => p.length > 0);
+
+  // Check max 3 levels
+  if (parts.length > 3) {
+    return { valid: false, error: 'Directory depth cannot exceed 3 levels' };
+  }
+
+  // Validate each part
+  for (const part of parts) {
+    const validation = validateDirectoryName(part);
+    if (!validation.valid) {
+      return validation;
+    }
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Normalize directory name (basic cleanup)
+ * @param name - Raw directory name
+ * @returns Normalized name
+ */
+export function normalizeDirectoryName(name: string): string {
+  return name.trim().replace(/\s+/g, ' ');
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+import 'server-only';
+
+// Types
+export * from './types';
+
+// MCP
+export type { MCPTool, MCPConfig } from './mcp/mcp-client';
+export { MCPClient } from './mcp/mcp-client';
+export type { ToolGroup } from './mcp/index';
+export { AbstractGroupedMCPManager, type GroupedMCPManager } from './mcp/index';
+export { MCPManager } from './mcp/mcp-manager';
+export type { PlaywrightMCPOpts } from './mcp/playwright-mcp-manager';
+export { PlaywrightMCPManager } from './mcp/playwright-mcp-manager';
+export { FileMCPManager } from './mcp/file-mcp-manager';
+
+// Repositories
+export * from './repositories';
+
+// Model
+export { createModel, convertToZodSchema } from './model';
+
+// Storage Service
+export { StorageService } from './storageService';
+
+// Directory Validator
+export { validateDirectoryName, validateDirectoryPath, normalizeDirectoryName } from './directory-validator';

package/src/mcp/file-mcp-manager.ts

@@ -0,0 +1,50 @@
+/**
+ * MCP (Model Context Protocol) Client for Playwright integration
+ * Integrates with https://github.com/microsoft/playwright-mcp
+ */
+
+import { MCPClient, MCPConfig } from './mcp-client';
+import { AbstractGroupedMCPManager } from '.';
+
+export class FileMCPManager extends AbstractGroupedMCPManager {
+  private client?: MCPClient;
+
+  constructor() {
+    const groups = [
+      {
+        name: 'file_mcp',
+        description: 'Read, write files on the filesystem',
+        loadByDefault: false,
+      }
+    ];
+    super(groups);
+  }
+
+  async start(forced: boolean = false): Promise<void> {
+    const client = this.createClient();
+    this.client = client;
+    await client.connect(forced);
+  }
+
+  getClient(): MCPClient {
+    if (!this.client) {
+      throw new Error("MCP Client is not started yet");
+    }
+    return this.client;
+  }
+
+  private createClient(): MCPClient {
+    // Build args with headless mode
+    const args = [
+      '@cotestdev/mcp-files',
+    ];
+
+    const mcpConfig: MCPConfig = {
+      cmd: 'npx',
+      args: args,
+      env: { ...process.env } as Record<string, string>,
+    }
+
+    return new MCPClient(mcpConfig);
+  }
+}

package/src/mcp/index.ts

@@ -0,0 +1,35 @@
+import { MCPClient } from "./mcp-client";
+
+export interface ToolGroup {
+    name: string;
+    description: string;
+    tools?: string[];
+    loadByDefault: boolean;
+}
+
+export interface GroupedMCPManager {
+    groups: ToolGroup[];
+    start(forced?: boolean): Promise<void>;
+    getToolGroupInfo(): Record<string, string>;
+    getClient(): MCPClient;
+}
+
+export abstract class AbstractGroupedMCPManager implements GroupedMCPManager {
+    groups: ToolGroup[];
+
+    constructor(groups: ToolGroup[]) {
+        this.groups = groups;
+    }
+
+    abstract start(forced: boolean): Promise<void>;
+
+    abstract getClient(): MCPClient
+
+    getToolGroupInfo(): Record<string, string> {
+        const result: Record<string, string> = {};
+        for (const group of this.groups) {
+            result[group.name] = group.description;
+        }
+        return result;
+    }
+}

package/src/mcp/mcp-client.ts

@@ -0,0 +1,209 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * MCP (Model Context Protocol) Client for Playwright integration
+ * Integrates with https://github.com/microsoft/playwright-mcp
+ */
+
+import { ToolCall } from '../types';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export interface MCPConfig {
+  cmd?: string;
+  args: string[];
+  url?: string;
+  env?: Record<string, string>;
+}
+
+export class MCPClient {
+  private client: Client | null = null;
+  private connected = false;
+  private connecting = false;
+  private transport: StdioClientTransport | null = null;
+  private availableTools: MCPTool[] = [];
+  private config: MCPConfig;
+
+  constructor(config: MCPConfig) {
+    this.config = config;
+  }
+
+  getConfig(): MCPConfig {
+    return this.config;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async doCallTool(name: string, args: Record<string, any>, signal: AbortSignal) {
+    if (!this.client || !this.connected) {
+      throw new Error('MCP Client is not connected');
+    }
+
+    // Check if signal is aborted before calling
+    if (signal?.aborted) {
+      throw new Error('Operation was aborted');
+    }
+
+    // Ensure signal has throwIfAborted method for compatibility
+    if (signal && typeof signal.throwIfAborted !== 'function') {
+      // Polyfill for older environments
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (signal as any).throwIfAborted = function () {
+        if (this.aborted) {
+          throw new Error('Operation was aborted');
+        }
+      };
+    }
+
+    return await this.client.callTool({ name, arguments: args }, undefined, { signal });
+  }
+
+  async callTool(toolCall: ToolCall, signal: AbortSignal): Promise<any> {
+    let toolName = toolCall.name;
+    let args = toolCall.args;
+    if (toolName === 'call_tool') {
+      toolName = toolCall.args.tool_name;
+      args = toolCall.args.args;
+    }
+
+    console.log('Executing tool:', toolName, 'with input:', args);
+
+    const result = await this.doCallTool(toolName, args, signal);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const isError = (result as any).isError;
+    if (isError) {
+      console.warn('Tool:', toolCall.name, ' has error:', result.content);
+    } else {
+      console.log('Tool:', toolCall.name, ' executed');
+    }
+
+    return result;
+  }
+
+  async connect(forced: boolean = false): Promise<void> {
+    const limit = 3;
+    let attempts = 0;
+
+    if (!forced && (this.connected || this.connecting)) {
+      console.log('MCP Client is connecting or connected');
+      return;
+    }
+
+    await this.disconnect();
+
+    this.connecting = true;
+
+    while (attempts < limit) {
+      try {
+        await this.doConnect();
+        break;
+      } catch (error) {
+        attempts++;
+        console.error(`MCP Client connection attempt ${attempts} failed:`, error);
+      }
+    }
+
+    this.connecting = false;
+  }
+
+  async doConnect(): Promise<void> {
+    // Create stdio transport - it automatically spawns the playwright-mcp process
+    this.transport = new StdioClientTransport({
+      command: this.config.cmd || 'npx',
+      args: this.config.args,
+      env: {
+        ...this.config.env,
+      } as Record<string, string>,
+    });
+
+    this.client = new Client(
+      {
+        name: 'test-agent-client',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {},
+      }
+    );
+
+    await this.client.connect(this.transport, { timeout: 120000 });
+    this.connected = true;
+
+    // Load available tools
+    await this.loadAvailableTools();
+    console.log(`Connected to MCP server with ${this.availableTools.length} tools`);
+  }
+
+  private async loadAvailableTools(): Promise<void> {
+    if (!this.client) return;
+
+    const response = await this.client.listTools();
+    this.availableTools = response.tools.map((tool: Tool) => ({
+      name: tool.name,
+      description: tool.description || '',
+      inputSchema: normalizeInputSchema(tool.name, tool.inputSchema),
+    }));
+  }
+
+  getAvailableTools(): MCPTool[] {
+    return this.availableTools;
+  }
+
+  getToolByName(name: string): MCPTool | undefined {
+    return this.availableTools.find((t) => t.name === name);
+  }
+
+  getToolsDescription(): string {
+    return this.availableTools.map((t) => `- ${t.name}: ${t.description}`).join('\n');
+  }
+
+  async disconnect(): Promise<void> {
+    try {
+      if (this.client) {
+        await this.client.close();
+      }
+      this.connected = false;
+      this.availableTools = [];
+      this.transport = null;
+      this.client = null;
+      console.log('Disconnected from MCP server');
+    } catch (error) {
+      console.error('Error disconnecting from MCP server:', error);
+    }
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+}
+
+function normalizeInputSchema(name: string, inputSchema: unknown): Record<string, unknown> {
+  const schema = (inputSchema ?? {}) as Record<string, unknown>;
+
+  // Ensure the schema is explicitly an object schema so MCP SDK validation passes
+  const properties = (schema as { properties?: Record<string, unknown> }).properties || {};
+  const required = Array.isArray((schema as { required?: unknown }).required)
+    ? ((schema as { required?: unknown }).required as string[])
+    : [];
+
+  if (schema.type === 'object') {
+    return {
+      type: 'object',
+      properties,
+      required,
+      additionalProperties: schema.additionalProperties ?? false,
+    } as Record<string, unknown>;
+  }
+
+  return {
+    type: 'object',
+    properties,
+    required,
+    additionalProperties: false,
+  } as Record<string, unknown>;
+}