@matware/e2e-runner 1.1.1 → 1.3.0

package/src/dashboard.js

@@ -14,12 +14,15 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { createWebSocketServer } from './websocket.js';
-import { getPoolStatus, waitForPool } from './pool.js';
+import { getPoolUrls, getAggregatedPoolStatus, waitForAnyPool } from './pool-manager.js';
 import { runTestsParallel, loadAllSuites, loadTestSuite, listSuites } from './runner.js';
 import { generateReport, generateJUnitXML, saveReport, persistRun, loadHistory, loadHistoryRun } from './reporter.js';
-import { listProjects as dbListProjects, getProjectRuns as dbGetProjectRuns, getRunDetail as dbGetRunDetail, getAllRuns as dbGetAllRuns, getRunCount as dbGetRunCount, getProjectScreenshotsDir as dbGetProjectScreenshotsDir, getProjectTestsDir as dbGetProjectTestsDir, getProjectCwd as dbGetProjectCwd, lookupScreenshotHash as dbLookupScreenshotHash, closeDb } from './db.js';
+import { listProjects as dbListProjects, listProjectsWithSparklines as dbListProjectsWithSparklines, getProjectRuns as dbGetProjectRuns, getRunDetail as dbGetRunDetail, getAllRuns as dbGetAllRuns, getRunCount as dbGetRunCount, getProjectScreenshotsDir as dbGetProjectScreenshotsDir, getProjectTestsDir as dbGetProjectTestsDir, getProjectCwd as dbGetProjectCwd, lookupScreenshotHash as dbLookupScreenshotHash, ensureProject as dbEnsureProject, getNetworkLogs as dbGetNetworkLogs, listVariables as dbListVariables, setVariable as dbSetVariable, deleteVariable as dbDeleteVariable, closeDb } from './db.js';
 import { loadConfig } from './config.js';
 import { log, colors as C } from './logger.js';
+import { getLearningsSummary, getFlakySummary, getSelectorStability, getPageHealth, getApiHealth, getErrorPatterns, getTestTrends, getRunInsights, getHealthSnapshot } from './learner-sqlite.js';
+import { handleSyncRoutes } from './sync/hub-routes.js';
+import { migrateSyncSchema } from './sync/schema.js';
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -37,6 +40,12 @@ export async function startDashboard(config) {
   const port = config.dashboardPort || 8484;
   const MAX_BODY = 1024 * 1024; // 1MB limit for POST bodies
   const dashboardHtml = fs.readFileSync(path.join(__dirname, '..', 'templates', 'dashboard.html'), 'utf-8');
+  
+  // Migrate sync schema if in hub mode
+  if (config.sync?.mode === 'hub') {
+    migrateSyncSchema();
+    log(`${C.cyan}[sync]${C.reset} Hub mode enabled`);
+  }
 
   let currentRun = null; // { running: true, runId, report } or null
   let latestReport = null;
@@ -85,7 +94,7 @@ export async function startDashboard(config) {
     if (origin && allowedOrigins.includes(origin)) {
       res.setHeader('Access-Control-Allow-Origin', origin);
     }
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept, Mcp-Session-Id');
 
     if (req.method === 'OPTIONS') {
@@ -95,6 +104,12 @@ export async function startDashboard(config) {
     }
 
     try {
+      // Handle sync routes if in hub mode
+      if (config.sync?.mode === 'hub' && pathname.startsWith('/api/sync')) {
+        const handled = await handleSyncRoutes(req, res, config, pathname);
+        if (handled) return;
+      }
+      
       // Serve dashboard HTML
       if (pathname === '/' || pathname === '/index.html') {
         res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
@@ -104,9 +119,11 @@ export async function startDashboard(config) {
 
       // API: pool status + dashboard state
       if (pathname === '/api/status') {
-        const poolStatus = await getPoolStatus(config.poolUrl);
+        const poolUrls = getPoolUrls(config);
+        const aggregated = await getAggregatedPoolStatus(poolUrls);
         jsonResponse(res, {
-          pool: poolStatus,
+          pool: aggregated,
+          poolUrls,
           dashboard: {
             running: currentRun?.running || false,
             wsClients: wss.clientCount,
@@ -114,8 +131,10 @@ export async function startDashboard(config) {
           config: {
             baseUrl: config.baseUrl,
             poolUrl: config.poolUrl,
+            poolUrls,
             concurrency: config.concurrency,
             testsDir: config.testsDir,
+            sync: config.sync || { mode: 'standalone' },
           },
         });
         return;
@@ -161,6 +180,17 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: DB — projects overview with sparklines (Watch view)
+      if (pathname === '/api/db/projects/overview') {
+        try {
+          const limit = parseInt(url.searchParams.get('limit') || '20', 10);
+          jsonResponse(res, dbListProjectsWithSparklines(limit));
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
       // API: DB — runs for a project
       const projectRunsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/runs$/);
       if (projectRunsMatch) {
@@ -204,6 +234,77 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: DB — network logs for a run (filterable)
+      const networkLogsMatch = pathname.match(/^\/api\/db\/runs\/(\d+)\/network-logs$/);
+      if (networkLogsMatch) {
+        try {
+          const runDbId = parseInt(networkLogsMatch[1], 10);
+          const filters = {};
+          if (url.searchParams.has('testName')) filters.testName = url.searchParams.get('testName');
+          if (url.searchParams.has('method')) filters.method = url.searchParams.get('method');
+          if (url.searchParams.has('statusMin')) filters.statusMin = parseInt(url.searchParams.get('statusMin'), 10);
+          if (url.searchParams.has('statusMax')) filters.statusMax = parseInt(url.searchParams.get('statusMax'), 10);
+          if (url.searchParams.has('urlPattern')) filters.urlPattern = url.searchParams.get('urlPattern');
+          if (url.searchParams.get('errorsOnly') === 'true') filters.errorsOnly = true;
+          if (url.searchParams.get('includeHeaders') === 'true') filters.includeHeaders = true;
+          if (url.searchParams.get('includeBodies') === 'true') filters.includeBodies = true;
+          jsonResponse(res, dbGetNetworkLogs(runDbId, filters));
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — run insights (health + contextual insights)
+      const runInsightsMatch = pathname.match(/^\/api\/db\/runs\/(\d+)\/insights$/);
+      if (runInsightsMatch) {
+        try {
+          const runDbId = parseInt(runInsightsMatch[1], 10);
+          const detail = dbGetRunDetail(runDbId);
+          if (!detail) { jsonResponse(res, { error: 'Run not found' }, 404); return; }
+
+          const projectId = detail.projectId || null;
+          const health = projectId ? getHealthSnapshot(projectId) : null;
+
+          // Build a minimal report object for getRunInsights
+          const results = (detail.results || []).map(r => ({
+            name: r.name,
+            success: r.success,
+            actions: r.actions || [],
+          }));
+          const insights = projectId ? getRunInsights(projectId, { results }) : [];
+
+          jsonResponse(res, { health, insights });
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — project health snapshot
+      const projectHealthMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/health$/);
+      if (projectHealthMatch) {
+        try {
+          const projectId = parseInt(projectHealthMatch[1], 10);
+          const health = getHealthSnapshot(projectId);
+          jsonResponse(res, health || {});
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — cross-project health snapshot
+      if (pathname === '/api/db/health') {
+        try {
+          const health = getHealthSnapshot(null);
+          jsonResponse(res, health || {});
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
       // API: DB — project screenshots list
       const projectScreenshotsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/screenshots$/);
       if (projectScreenshotsMatch) {
@@ -239,6 +340,175 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: DB — suite detail (tests + actions)
+      const suiteDetailMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/suites\/(.+)$/);
+      if (suiteDetailMatch) {
+        try {
+          const projectId = parseInt(suiteDetailMatch[1], 10);
+          const suiteName = decodeURIComponent(suiteDetailMatch[2]);
+          const dir = dbGetProjectTestsDir(projectId);
+          if (!dir || !fs.existsSync(dir)) {
+            jsonResponse(res, { error: 'Tests directory not found' }, 404);
+            return;
+          }
+          const { tests, hooks } = loadTestSuite(suiteName, dir);
+          jsonResponse(res, { name: suiteName, tests, hooks });
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — cross-project learnings (when no project selected)
+      const crossLearningsMatch = pathname.match(/^\/api\/db\/learnings(?:\/(\w+))?$/);
+      if (crossLearningsMatch) {
+        try {
+          const category = crossLearningsMatch[1] || 'summary';
+          const days = parseInt(url.searchParams.get('days') || '30', 10);
+          let data;
+          switch (category) {
+            case 'summary': {
+              const summary = getLearningsSummary(null);
+              const trends = getTestTrends(null, 7);
+              data = { ...summary, recentTrend: trends };
+              break;
+            }
+            default:
+              jsonResponse(res, { error: `Unknown learnings category: ${category}` }, 400);
+              return;
+          }
+          jsonResponse(res, data);
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — project modules list
+      const projectModulesMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/modules$/);
+      if (projectModulesMatch) {
+        try {
+          const projectId = parseInt(projectModulesMatch[1], 10);
+          const projectCwd = dbGetProjectCwd(projectId);
+          if (!projectCwd) { jsonResponse(res, []); return; }
+          const modulesDir = path.join(projectCwd, 'e2e', 'modules');
+          if (!fs.existsSync(modulesDir)) { jsonResponse(res, []); return; }
+          const files = fs.readdirSync(modulesDir).filter(f => f.endsWith('.json')).sort();
+          const modules = files.map(f => {
+            try {
+              const data = JSON.parse(fs.readFileSync(path.join(modulesDir, f), 'utf-8'));
+              return {
+                name: f.replace('.json', ''),
+                file: f,
+                description: data.description || null,
+                params: data.params || [],
+                actionCount: Array.isArray(data.actions) ? data.actions.length : 0,
+              };
+            } catch { return { name: f.replace('.json', ''), file: f, description: null, params: [], actionCount: 0 }; }
+          });
+          jsonResponse(res, modules);
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — project variables (list)
+      const projectVarsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/variables$/);
+      if (projectVarsMatch && req.method === 'GET') {
+        try {
+          const projectId = parseInt(projectVarsMatch[1], 10);
+          jsonResponse(res, dbListVariables(projectId));
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — project variables (set/upsert)
+      if (projectVarsMatch && req.method === 'PUT') {
+        let body = '';
+        let oversize = false;
+        req.on('data', chunk => { body += chunk; if (body.length > MAX_BODY) { oversize = true; req.destroy(); } });
+        req.on('end', () => {
+          if (oversize) { jsonResponse(res, { error: 'Payload too large' }, 413); return; }
+          try {
+            const projectId = parseInt(projectVarsMatch[1], 10);
+            const { scope, key, value } = JSON.parse(body);
+            if (!key || value === undefined) { jsonResponse(res, { error: 'Missing key or value' }, 400); return; }
+            dbSetVariable(projectId, scope || 'project', key, value);
+            jsonResponse(res, { ok: true });
+          } catch (error) {
+            jsonResponse(res, { error: error.message }, 500);
+          }
+        });
+        return;
+      }
+
+      // API: DB — project variables (delete)
+      const varDeleteMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/variables\/([^/]+)\/([^/]+)$/);
+      if (varDeleteMatch && req.method === 'DELETE') {
+        try {
+          const projectId = parseInt(varDeleteMatch[1], 10);
+          const scope = decodeURIComponent(varDeleteMatch[2]);
+          const key = decodeURIComponent(varDeleteMatch[3]);
+          const deleted = dbDeleteVariable(projectId, scope, key);
+          if (deleted) {
+            jsonResponse(res, { ok: true });
+          } else {
+            jsonResponse(res, { error: 'Variable not found' }, 404);
+          }
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
+      // API: DB — project learnings (summary or specific category)
+      const learningsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/learnings(?:\/(\w+))?$/);
+      if (learningsMatch) {
+        try {
+          const projectId = parseInt(learningsMatch[1], 10);
+          const category = learningsMatch[2] || 'summary';
+          const days = parseInt(url.searchParams.get('days') || '30', 10);
+
+          let data;
+          switch (category) {
+            case 'summary': {
+              const summary = getLearningsSummary(projectId);
+              const trends = getTestTrends(projectId, 7);
+              data = { ...summary, recentTrend: trends };
+              break;
+            }
+            case 'flaky':
+              data = getFlakySummary(projectId, days);
+              break;
+            case 'selectors':
+              data = getSelectorStability(projectId, days);
+              break;
+            case 'pages':
+              data = getPageHealth(projectId, days);
+              break;
+            case 'apis':
+              data = getApiHealth(projectId, days);
+              break;
+            case 'errors':
+              data = getErrorPatterns(projectId);
+              break;
+            case 'trends':
+              data = getTestTrends(projectId, days);
+              break;
+            default:
+              jsonResponse(res, { error: `Unknown learnings category: ${category}` }, 400);
+              return;
+          }
+          jsonResponse(res, data);
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
       // API: serve screenshot by hash (e.g. /api/screenshot-hash/a3f2b1c9)
       const ssHashMatch = pathname.match(/^\/api\/screenshot-hash\/([a-f0-9]{8})$/);
       if (ssHashMatch) {
@@ -262,7 +532,7 @@ export async function startDashboard(config) {
           const ext = path.extname(realPath).toLowerCase();
           const mimeTypes = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp' };
           if (!mimeTypes[ext]) { jsonResponse(res, { error: 'Not an image' }, 400); return; }
-          res.writeHead(200, { 'Content-Type': mimeTypes[ext] });
+          res.writeHead(200, { 'Content-Type': mimeTypes[ext], 'Cache-Control': 'no-store' });
           fs.createReadStream(realPath).pipe(res);
         } catch (error) {
           jsonResponse(res, { error: error.message }, 500);
@@ -302,7 +572,7 @@ export async function startDashboard(config) {
           jsonResponse(res, { error: 'Not an image' }, 400);
           return;
         }
-        res.writeHead(200, { 'Content-Type': mimeTypes[ext] });
+        res.writeHead(200, { 'Content-Type': mimeTypes[ext], 'Cache-Control': 'no-store' });
         fs.createReadStream(realPath).pipe(res);
         return;
       }
@@ -347,7 +617,7 @@ export async function startDashboard(config) {
           return;
         }
         if (fs.existsSync(resolvedPath)) {
-          res.writeHead(200, { 'Content-Type': imageMimeTypes[ext] });
+          res.writeHead(200, { 'Content-Type': imageMimeTypes[ext], 'Cache-Control': 'no-store' });
           fs.createReadStream(resolvedPath).pipe(res);
         } else {
           jsonResponse(res, { error: 'Not found' }, 404);
@@ -453,11 +723,12 @@ export async function startDashboard(config) {
     },
   });
 
-  // Pool status polling
+  // Pool status polling (aggregated across all pools)
+  const poolUrls = getPoolUrls(config);
   const pollInterval = setInterval(async () => {
     try {
-      const status = await getPoolStatus(config.poolUrl);
-      wss.broadcast(JSON.stringify({ event: 'pool:status', data: status }));
+      const aggregated = await getAggregatedPoolStatus(poolUrls);
+      wss.broadcast(JSON.stringify({ event: 'pool:status', data: aggregated }));
     } catch { /* */ }
   }, 5000);
 
@@ -484,7 +755,8 @@ export async function startDashboard(config) {
         const projectCwd = dbGetProjectCwd(params.projectId);
         if (!projectCwd) throw new Error('Project not found');
         runConfig = await loadConfig({}, projectCwd);
-        // Inherit pool URL from dashboard config (pool is shared)
+        // Inherit pool URLs from dashboard config (pool is shared)
+        runConfig._poolUrls = getPoolUrls(config);
         runConfig.poolUrl = config.poolUrl;
       } else {
         runConfig = { ...config };
@@ -504,15 +776,15 @@ export async function startDashboard(config) {
       if (params.suite) {
         ({ tests, hooks } = loadTestSuite(params.suite, runConfig.testsDir));
       } else {
-        ({ tests, hooks } = loadAllSuites(runConfig.testsDir));
+        ({ tests, hooks } = loadAllSuites(runConfig.testsDir, runConfig.modulesDir, runConfig.exclude));
       }
 
-      await waitForPool(runConfig.poolUrl);
+      await waitForAnyPool(getPoolUrls(runConfig));
       const results = await runTestsParallel(tests, runConfig, hooks || {});
       const report = generateReport(results);
       const suiteName = params.suite || null;
       saveReport(report, runConfig.screenshotsDir, runConfig);
-      persistRun(report, runConfig, suiteName);
+      await persistRun(report, runConfig, suiteName);
       latestReport = report;
       currentRun = { running: false };
     } catch (error) {
@@ -521,8 +793,18 @@ export async function startDashboard(config) {
     }
   }
 
-  return new Promise((resolve) => {
-    const host = config.dashboardHost || '127.0.0.1';
+  return new Promise((resolve, reject) => {
+    const host = config.dashboardHost || process.env.DASHBOARD_HOST || '0.0.0.0';
+
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        log('❌', `${C.red}Port ${port} is already in use. Try a different port with --port <number>.${C.reset}`);
+        reject(new Error(`Port ${port} is already in use`));
+      } else {
+        reject(err);
+      }
+    });
+
     server.listen(port, host, () => {
       log('🖥️', `${C.bold}Dashboard${C.reset} running at ${C.cyan}http://${host}:${port}${C.reset}`);