@deriv-com/fe-mcp-servers 0.0.13 → 0.0.15

package/dist/maestro-ai/README.md

@@ -273,7 +273,6 @@ Parses and validates acceptance criteria from a ClickUp task for testability.
 ⚠️ **HARD VALIDATION** - Maps acceptance criteria items to UI elements and **FAILS on mismatches**.
 
 This tool performs strict validation of AC against actual UI implementation. If the AC specifies one value but the UI has a different value, this tool will:
-
 1. **FAIL** (`success: false`)
 2. **Report** the exact mismatch
 3. **Block** test generation until resolved

package/dist/maestro-ai/mcp-server.js

@@ -19449,12 +19449,224 @@ ${analysis.shouldCreateTest ? `1. Review the changed UI files above
     }
   };
 }
+function detectProjectBaseUrl(projectPath = process.cwd(), explicitUrl = null) {
+  if (explicitUrl) {
+    const portMatch = explicitUrl.match(/:(\d+)/);
+    return {
+      url: explicitUrl,
+      source: "explicit",
+      port: portMatch ? parseInt(portMatch[1], 10) : 443,
+      https: explicitUrl.startsWith("https")
+    };
+  }
+  let detectedPort = null;
+  let detectedHttps = false;
+  let source = "fallback";
+  const configChecks = [
+    // Vite config
+    {
+      files: ["vite.config.js", "vite.config.ts", "vite.config.mjs"],
+      patterns: [
+        /server\s*:\s*\{[^}]*port\s*:\s*(\d+)/s,
+        /port\s*:\s*(\d+)/,
+        /preview\s*:\s*\{[^}]*port\s*:\s*(\d+)/s
+      ],
+      httpsPatterns: [/https\s*:\s*true/, /server\s*:\s*\{[^}]*https\s*:/s],
+      name: "vite.config"
+    },
+    // Next.js config
+    {
+      files: ["next.config.js", "next.config.mjs", "next.config.ts"],
+      patterns: [/port\s*:\s*(\d+)/, /PORT\s*[=:]\s*(\d+)/],
+      httpsPatterns: [],
+      name: "next.config"
+    },
+    // Webpack config
+    {
+      files: ["webpack.config.js", "webpack.config.ts"],
+      patterns: [
+        /devServer\s*:\s*\{[^}]*port\s*:\s*(\d+)/s,
+        /port\s*:\s*(\d+)/
+      ],
+      httpsPatterns: [/https\s*:\s*true/],
+      name: "webpack.config"
+    },
+    // Angular config
+    {
+      files: ["angular.json"],
+      patterns: [/"port"\s*:\s*(\d+)/, /"ssl"\s*:\s*true/],
+      httpsPatterns: [/"ssl"\s*:\s*true/],
+      name: "angular.json"
+    }
+  ];
+  for (const config2 of configChecks) {
+    for (const fileName of config2.files) {
+      try {
+        const configPath = join(projectPath, fileName);
+        if (existsSync(configPath)) {
+          const content = readFileSync(configPath, "utf-8");
+          for (const pattern of config2.patterns) {
+            const match = content.match(pattern);
+            if (match && match[1]) {
+              detectedPort = parseInt(match[1], 10);
+              source = config2.name;
+              break;
+            }
+          }
+          for (const httpsPattern of config2.httpsPatterns) {
+            if (httpsPattern.test(content)) {
+              detectedHttps = true;
+              break;
+            }
+          }
+          if (detectedPort) break;
+        }
+      } catch {
+      }
+    }
+    if (detectedPort) break;
+  }
+  if (!detectedPort) {
+    try {
+      const packageJsonPath = join(projectPath, "package.json");
+      if (existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        const scripts = packageJson.scripts || {};
+        const scriptKeys = ["dev", "start", "serve", "develop"];
+        for (const key of scriptKeys) {
+          const script = scripts[key];
+          if (script) {
+            const portPatterns = [
+              /--port[=\s]+(\d+)/,
+              /-p[=\s]+(\d+)/,
+              /PORT[=:]\s*(\d+)/,
+              /localhost:(\d+)/,
+              /127\.0\.0\.1:(\d+)/,
+              /:(\d{4,5})\b/
+              // Generic 4-5 digit port
+            ];
+            for (const pattern of portPatterns) {
+              const match = script.match(pattern);
+              if (match && match[1]) {
+                detectedPort = parseInt(match[1], 10);
+                source = `package.json scripts.${key}`;
+                break;
+              }
+            }
+            if (/--https|HTTPS=true|ssl/.test(script)) {
+              detectedHttps = true;
+            }
+            if (detectedPort) break;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (!detectedPort) {
+    const envFiles = [".env", ".env.local", ".env.development", ".env.dev"];
+    for (const envFile of envFiles) {
+      try {
+        const envPath = join(projectPath, envFile);
+        if (existsSync(envPath)) {
+          const content = readFileSync(envPath, "utf-8");
+          const portPatterns = [
+            /^PORT\s*=\s*(\d+)/m,
+            /^VITE_PORT\s*=\s*(\d+)/m,
+            /^DEV_PORT\s*=\s*(\d+)/m,
+            /^SERVER_PORT\s*=\s*(\d+)/m
+          ];
+          for (const pattern of portPatterns) {
+            const match = content.match(pattern);
+            if (match && match[1]) {
+              detectedPort = parseInt(match[1], 10);
+              source = envFile;
+              break;
+            }
+          }
+          if (detectedPort) break;
+        }
+      } catch {
+      }
+    }
+  }
+  if (!detectedPort && process.env.MAESTRO_BASE_URL) {
+    const envUrl = process.env.MAESTRO_BASE_URL;
+    const portMatch = envUrl.match(/:(\d+)/);
+    return {
+      url: envUrl,
+      source: "MAESTRO_BASE_URL env",
+      port: portMatch ? parseInt(portMatch[1], 10) : 443,
+      https: envUrl.startsWith("https")
+    };
+  }
+  if (!detectedPort) {
+    detectedPort = 3e3;
+    source = "fallback (default)";
+  }
+  const protocol = detectedHttps ? "https" : "http";
+  const url2 = `${protocol}://localhost:${detectedPort}`;
+  return {
+    url: url2,
+    source,
+    port: detectedPort,
+    https: detectedHttps
+  };
+}
+function enforceMandatoryTemplate(yaml, name = "", projectPath = process.cwd(), explicitBaseUrl = null) {
+  if (!yaml || typeof yaml !== "string") {
+    yaml = "";
+  }
+  const detected = detectProjectBaseUrl(projectPath, explicitBaseUrl);
+  const detectedUrl = detected.url;
+  const mandatoryHeader = `appId: web
+name: '${name}'
+url: \${BASE_URL}
+
+env:
+    BASE_URL: \${MAESTRO_BASE_URL || "${detectedUrl}"}
+`;
+  const hasAppIdWeb = /^appId:\s*web/m.test(yaml);
+  const hasName = /^name:\s*['"]/m.test(yaml);
+  const hasUrl = /^url:\s*\$\{BASE_URL\}/m.test(yaml);
+  const hasEnv = /^env:\s*$/m.test(yaml);
+  const hasBaseUrl = /BASE_URL:\s*\$\{MAESTRO_BASE_URL/m.test(yaml);
+  if (hasAppIdWeb && hasName && hasUrl && hasEnv && hasBaseUrl) {
+    if (name && yaml.match(/^name:\s*['"]\s*['"]/m)) {
+      yaml = yaml.replace(/^name:\s*['"]\s*['"]/m, `name: '${name}'`);
+    }
+    return yaml;
+  }
+  let testSteps = "";
+  const stepsMatch = yaml.match(/^---\s*\n([\s\S]*)$/m);
+  if (stepsMatch) {
+    testSteps = stepsMatch[1];
+  } else {
+    const stepsStart = yaml.search(
+      /\n(- launchApp|- tapOn|- assertVisible|- inputText|- extendedWaitUntil)/
+    );
+    if (stepsStart > 0) {
+      testSteps = yaml.substring(stepsStart + 1);
+    } else {
+      if (yaml.trim().startsWith("-")) {
+        testSteps = yaml.trim();
+      } else {
+        testSteps = yaml.trim();
+      }
+    }
+  }
+  const enforcedYaml = `${mandatoryHeader}---
+${testSteps.trim()}
+`;
+  return enforcedYaml;
+}
 function writeTestFile(options = {}) {
   const {
     yaml,
     fileName,
     directory = "maestro",
     basePath = process.cwd(),
+    baseUrl = null,
     execute = true,
     deviceId = null,
     env = {},
@@ -19478,6 +19690,14 @@ function writeTestFile(options = {}) {
       message: "\u274C Missing required parameters: yaml and fileName are required"
     };
   }
+  const testName = feature && action ? `${feature} - ${action}` : feature || action || "";
+  const enforcedYaml = enforceMandatoryTemplate(
+    yaml,
+    testName,
+    basePath,
+    baseUrl
+  );
+  const detectedUrl = detectProjectBaseUrl(basePath, baseUrl);
   const normalizedFileName = fileName.endsWith(".yaml") ? fileName : `${fileName}.yaml`;
   const targetDir = join(basePath, directory);
   const filePath = join(targetDir, normalizedFileName);
@@ -19485,16 +19705,19 @@ function writeTestFile(options = {}) {
     if (!existsSync(targetDir)) {
       mkdirSync(targetDir, { recursive: true });
     }
-    writeFileSync(filePath, yaml, "utf-8");
+    writeFileSync(filePath, enforcedYaml, "utf-8");
     const fd = openSync(filePath, "r");
     fsyncSync(fd);
     closeSync(fd);
     const result = {
       success: true,
       filePath,
-      message: `\u2705 Test file written successfully to: ${filePath}`,
-      generation
+      message: `\u2705 Test file written successfully to: ${filePath}
+\u{1F4CD} Base URL: ${detectedUrl.url} (detected from: ${detectedUrl.source})`,
+      generation,
       // Include test generation guidelines and instructions
+      detectedUrl
+      // Include URL detection info
     };
     if (execute) {
       const sleep = (ms) => {
@@ -20978,11 +21201,21 @@ Saves generated test YAML to a file and AUTOMATICALLY RUNS IT. This is the prima
 - The execution result is included in the response
 - This tool internally calls maestro_generate_test to provide guidelines and instructions
 
+## URL Auto-Detection
+Base URL is automatically detected from project config files:
+1. **Explicit baseUrl parameter** (highest priority)
+2. **Config files**: vite.config.js, next.config.js, webpack.config.js, angular.json
+3. **package.json scripts**: --port flags in dev/start scripts
+4. **.env files**: PORT, VITE_PORT, DEV_PORT variables
+5. **MAESTRO_BASE_URL env var**
+6. **Fallback**: http://localhost:3000
+
 ## Parameters
 - yaml: The YAML content to write (required)
 - fileName: Name of the file, e.g., "login_test.yaml" (required)
 - directory: Target directory (default: "maestro")
 - basePath: Project base path (default: current directory)
+- baseUrl: Explicit base URL override (optional, auto-detected if not provided)
 - execute: Whether to auto-execute after writing (default: true)
 - deviceId: Device ID for execution (optional)
 - env: Environment variables for execution (optional)
@@ -20995,8 +21228,9 @@ Saves generated test YAML to a file and AUTOMATICALLY RUNS IT. This is the prima
 ## Output
 - success: boolean
 - filePath: Path where file was written
-- message: Status message
+- message: Status message with detected URL info
 - generation: Test generation guidelines and instructions (from maestro_generate_test)
+- detectedUrl: URL detection info (url, source, port, https)
 - execution: Test execution results (if execute=true)`,
         inputSchema: {
           type: "object",
@@ -21017,6 +21251,10 @@ Saves generated test YAML to a file and AUTOMATICALLY RUNS IT. This is the prima
               type: "string",
               description: "Project base path (default: current directory)"
             },
+            baseUrl: {
+              type: "string",
+              description: "Explicit base URL override (optional). If not provided, auto-detected from project config (vite.config, next.config, package.json scripts, .env files)"
+            },
             execute: {
               type: "boolean",
               description: "Whether to auto-execute the test after writing (default: true)"
@@ -21386,6 +21624,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         fileName,
         directory,
         basePath,
+        baseUrl,
         execute,
         deviceId,
         env,
@@ -21400,6 +21639,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         fileName,
         directory: directory || "maestro",
         basePath: basePath || process.cwd(),
+        baseUrl: baseUrl || null,
+        // Auto-detected from project config if not provided
         execute: execute !== false,
         // defaults to true
         deviceId: deviceId || null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deriv-com/fe-mcp-servers",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Collection of Front-End Model Context Protocol (MCP) servers for reusability and standardization",
   "type": "module",
   "bin": {