@matware/e2e-runner 1.3.0 → 1.5.0

package/src/dashboard.js

@@ -16,11 +16,13 @@ import { createRequire } from 'module';
 import { createWebSocketServer } from './websocket.js';
 import { getPoolUrls, getAggregatedPoolStatus, waitForAnyPool } from './pool-manager.js';
 import { runTestsParallel, loadAllSuites, loadTestSuite, listSuites } from './runner.js';
+import { runModuleAnalysis } from './module-analysis.js';
 import { generateReport, generateJUnitXML, saveReport, persistRun, loadHistory, loadHistoryRun } from './reporter.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 { getLearningsSummary, getFlakySummary, getSelectorStability, getPageHealth, getApiHealth, getErrorPatterns, getTestTrends, getRunInsights, getHealthSnapshot, getActionHealthScores } from './learner-sqlite.js';
+import { compareImages, isBlankImage } from './visual-diff.js';
 import { handleSyncRoutes } from './sync/hub-routes.js';
 import { migrateSyncSchema } from './sync/schema.js';
 
@@ -88,11 +90,16 @@ export async function startDashboard(config) {
     const url = new URL(req.url, `http://localhost:${port}`);
     const pathname = url.pathname;
 
-    // CORS — restrict to same-origin (localhost on dashboard port)
+    // CORS — allow same-origin (Origin's host matches the Host header)
+    // and the explicit whitelist (localhost/127.0.0.1 on dashboard port).
     const allowedOrigins = [`http://localhost:${port}`, `http://127.0.0.1:${port}`];
     const origin = req.headers.origin;
-    if (origin && allowedOrigins.includes(origin)) {
-      res.setHeader('Access-Control-Allow-Origin', origin);
+    if (origin) {
+      let allowOrigin = allowedOrigins.includes(origin);
+      if (!allowOrigin && req.headers.host) {
+        try { allowOrigin = new URL(origin).host === req.headers.host; } catch { /* */ }
+      }
+      if (allowOrigin) res.setHeader('Access-Control-Allow-Origin', origin);
     }
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept, Mcp-Session-Id');
@@ -120,7 +127,7 @@ export async function startDashboard(config) {
       // API: pool status + dashboard state
       if (pathname === '/api/status') {
         const poolUrls = getPoolUrls(config);
-        const aggregated = await getAggregatedPoolStatus(poolUrls);
+        const aggregated = await getAggregatedPoolStatus(poolUrls, { poolDriver: config.poolDriver, maxSessions: config.maxSessions });
         jsonResponse(res, {
           pool: aggregated,
           poolUrls,
@@ -305,6 +312,38 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: DB — project config warnings (Docker hostname detection)
+      const configWarningsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/config-warnings$/);
+      if (configWarningsMatch) {
+        try {
+          const projectId = parseInt(configWarningsMatch[1], 10);
+          const projectCwd = dbGetProjectCwd(projectId);
+          if (!projectCwd) { jsonResponse(res, { warnings: [] }); return; }
+          const cfg = await loadConfig({}, projectCwd);
+          const warnings = [];
+          const checkDockerHostname = (url, label) => {
+            try {
+              const parsed = new URL(url);
+              if (!parsed.hostname.includes('.') && parsed.hostname !== 'localhost' && parsed.hostname !== '127') {
+                warnings.push({
+                  type: 'docker-hostname',
+                  field: label,
+                  hostname: parsed.hostname,
+                  url,
+                  message: `"${parsed.hostname}" looks like a Docker-internal hostname. The runner will auto-fallback to localhost for auth, but baseUrl requests go through Chrome in Docker (which can resolve it). If tests fail with ENOTFOUND, ensure Chrome pool is on the same Docker network.`,
+                });
+              }
+            } catch {}
+          };
+          if (cfg.baseUrl) checkDockerHostname(cfg.baseUrl, 'baseUrl');
+          if (cfg.authLoginEndpoint) checkDockerHostname(cfg.authLoginEndpoint, 'authLoginEndpoint');
+          jsonResponse(res, { warnings });
+        } catch (error) {
+          jsonResponse(res, { warnings: [], error: error.message });
+        }
+        return;
+      }
+
       // API: DB — project screenshots list
       const projectScreenshotsMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/screenshots$/);
       if (projectScreenshotsMatch) {
@@ -323,6 +362,28 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: DB — scan a project's screenshots for blank (uniform-color) images
+      const blankScanMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/screenshots\/blank-scan$/);
+      if (blankScanMatch) {
+        try {
+          const projectId = parseInt(blankScanMatch[1], 10);
+          const dir = dbGetProjectScreenshotsDir(projectId);
+          if (!dir || !fs.existsSync(dir)) { jsonResponse(res, { blanks: [], scanned: 0 }); return; }
+          // Only PNGs are decodable; other formats are skipped (never flagged).
+          const files = fs.readdirSync(dir).filter(f => /\.png$/i.test(f)).sort();
+          const blanks = [];
+          for (const f of files) {
+            const fp = path.join(dir, f);
+            const r = isBlankImage(fp);
+            if (r.blank) blanks.push({ name: f, path: fp, color: r.color, brightness: r.brightness });
+          }
+          jsonResponse(res, { blanks, scanned: files.length });
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
       // API: DB — project suites list
       const projectSuitesMatch = pathname.match(/^\/api\/db\/projects\/(\d+)\/suites$/);
       if (projectSuitesMatch) {
@@ -425,6 +486,68 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: Tools — proxy to MCP tool handlers
+      // Generic helper: resolve projectId from POST body → cwd, then call dispatchTool.
+      if (pathname.startsWith('/api/tool/') && req.method === 'POST') {
+        const tool = pathname.replace('/api/tool/', '');
+        const map = { capture: 'e2e_capture', analyze: 'e2e_analyze', 'issue-verify': 'e2e_issue' };
+        const mcpName = map[tool];
+        if (!mcpName) { jsonResponse(res, { error: 'Unknown tool: ' + tool }, 400); return; }
+        let body = '';
+        let oversize = false;
+        req.on('data', chunk => { body += chunk; if (body.length > MAX_BODY) { oversize = true; req.destroy(); } });
+        req.on('end', async () => {
+          if (oversize) { jsonResponse(res, { error: 'Payload too large' }, 413); return; }
+          try {
+            const args = body ? JSON.parse(body) : {};
+            if (args.projectId) {
+              const pcwd = dbGetProjectCwd(parseInt(args.projectId, 10));
+              if (pcwd) args.cwd = pcwd;
+              delete args.projectId;
+            }
+            if (tool === 'issue-verify') args.mode = 'verify';
+            const result = await dispatchTool(mcpName, args);
+            // dispatchTool returns MCP-style { content:[{type,text}], isError? }.
+            // Convert to a friendlier shape for the dashboard.
+            let payload = result;
+            if (result && Array.isArray(result.content)) {
+              const text = result.content.map(c => c.text || '').join('\n');
+              let parsed = null; try { parsed = JSON.parse(text); } catch { /* */ }
+              payload = parsed || { text };
+              if (result.isError) payload.error = payload.error || payload.text || 'Tool returned error';
+            }
+            jsonResponse(res, payload);
+          } catch (error) {
+            jsonResponse(res, { error: error.message }, 500);
+          }
+        });
+        return;
+      }
+
+      // API: Tools — module analysis
+      // Reads all tests + modules in a project, finds repeated 3-8-action
+      // subsequences that appear in 2+ tests (extraction candidates), and
+      // counts current module usage. Returns a report ready for the
+      // dashboard to display + a prompt the user can paste into Claude Code
+      // to ask the test-improver agent for deeper analysis.
+      const modAnalysisMatch = pathname.match(/^\/api\/tools\/module-analysis\/(\d+)$/);
+      if (modAnalysisMatch) {
+        try {
+          const projectId = parseInt(modAnalysisMatch[1], 10);
+          const cwd = dbGetProjectCwd(projectId);
+          const testsDir = dbGetProjectTestsDir(projectId);
+          if (!cwd || !testsDir || !fs.existsSync(testsDir)) {
+            jsonResponse(res, { error: 'Project tests directory not found' }, 404);
+            return;
+          }
+          const modulesDir = path.join(cwd, 'e2e', 'modules');
+          jsonResponse(res, runModuleAnalysis(testsDir, modulesDir, projectId));
+        } catch (error) {
+          jsonResponse(res, { error: error.message }, 500);
+        }
+        return;
+      }
+
       // API: DB — project variables (set/upsert)
       if (projectVarsMatch && req.method === 'PUT') {
         let body = '';
@@ -498,6 +621,9 @@ export async function startDashboard(config) {
             case 'trends':
               data = getTestTrends(projectId, days);
               break;
+            case 'actions':
+              data = getActionHealthScores(projectId, days);
+              break;
             default:
               jsonResponse(res, { error: `Unknown learnings category: ${category}` }, 400);
               return;
@@ -509,6 +635,71 @@ export async function startDashboard(config) {
         return;
       }
 
+      // API: delete screenshots — { paths: [...] }, each validated against known dirs
+      if (pathname === '/api/screenshots/delete' && req.method === 'POST') {
+        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 { paths } = body ? JSON.parse(body) : {};
+            if (!Array.isArray(paths) || !paths.length) { jsonResponse(res, { error: 'Missing paths array' }, 400); return; }
+            // Build the allow-list of directories deletions may touch.
+            const allowedDirs = [path.resolve(config.screenshotsDir)];
+            try {
+              for (const p of dbListProjects()) {
+                const dir = p.screenshots_dir || path.join(p.cwd, 'e2e', 'screenshots');
+                allowedDirs.push(path.resolve(dir));
+              }
+            } catch { /* db may be unavailable */ }
+            let deleted = 0;
+            const failed = [];
+            for (const raw of paths) {
+              try {
+                if (typeof raw !== 'string' || !path.isAbsolute(raw)) { failed.push({ path: raw, error: 'Invalid path' }); continue; }
+                const real = fs.realpathSync(raw);
+                const inAllowed = allowedDirs.some(dir => real.startsWith(dir + path.sep) || real === dir);
+                if (!inAllowed) { failed.push({ path: raw, error: 'Access denied' }); continue; }
+                if (!/\.(png|jpg|jpeg|gif|webp)$/i.test(real)) { failed.push({ path: raw, error: 'Not an image' }); continue; }
+                fs.unlinkSync(real);
+                deleted++;
+              } catch (e) {
+                failed.push({ path: raw, error: e.message });
+              }
+            }
+            jsonResponse(res, { deleted, failed });
+          } catch (error) {
+            jsonResponse(res, { error: error.message }, 500);
+          }
+        });
+        return;
+      }
+
+      // API: visual diff — compare two screenshots on demand
+      if (pathname === '/api/visual-diff') {
+        try {
+          const baseline = url.searchParams.get('baseline');
+          const current = url.searchParams.get('current');
+          const thresholdParam = url.searchParams.get('threshold');
+          if (!baseline || !current) {
+            jsonResponse(res, { error: 'Missing baseline or current parameter' }, 400); return;
+          }
+          if (!fs.existsSync(baseline)) { jsonResponse(res, { error: `Baseline not found: ${baseline}` }, 404); return; }
+          if (!fs.existsSync(current)) { jsonResponse(res, { error: `Current not found: ${current}` }, 404); return; }
+
+          const diffPath = path.join(config.screenshotsDir, `api-diff-${Date.now()}.png`);
+          const result = compareImages(baseline, current, {
+            threshold: thresholdParam ? parseFloat(thresholdParam) : 0.1,
+            diffOutputPath: diffPath,
+          });
+          jsonResponse(res, { ...result, diffImagePath: diffPath });
+        } 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) {
@@ -663,7 +854,9 @@ export async function startDashboard(config) {
           if (oversize) { jsonResponse(res, { error: 'Payload too large' }, 413); return; }
           try {
             const data = JSON.parse(body);
-            bufferLiveEvent(data);
+            if (data.event !== 'test:frame') {
+              bufferLiveEvent(data);
+            }
             wss.broadcast(JSON.stringify(data));
           } catch { /* */ }
           jsonResponse(res, { ok: true });
@@ -711,8 +904,9 @@ export async function startDashboard(config) {
     }
   }, 30000);
 
+  const devOrigins = process.env.NODE_ENV === 'production' ? [] : ['http://localhost:5173', 'http://127.0.0.1:5173'];
   const wss = createWebSocketServer(server, {
-    allowedOrigins: [`http://localhost:${port}`, `http://127.0.0.1:${port}`],
+    allowedOrigins: [`http://localhost:${port}`, `http://127.0.0.1:${port}`, ...devOrigins],
     onConnect(socket) {
       // Replay live state for new/reconnected clients
       for (const rid of Object.keys(liveEventBuffers)) {
@@ -727,7 +921,7 @@ export async function startDashboard(config) {
   const poolUrls = getPoolUrls(config);
   const pollInterval = setInterval(async () => {
     try {
-      const aggregated = await getAggregatedPoolStatus(poolUrls);
+      const aggregated = await getAggregatedPoolStatus(poolUrls, { poolDriver: config.poolDriver, maxSessions: config.maxSessions });
       wss.broadcast(JSON.stringify({ event: 'pool:status', data: aggregated }));
     } catch { /* */ }
   }, 5000);
@@ -765,21 +959,25 @@ export async function startDashboard(config) {
       runConfig.triggeredBy = 'dashboard';
       if (params.concurrency) runConfig.concurrency = params.concurrency;
       if (params.baseUrl) runConfig.baseUrl = params.baseUrl;
+      if (params.screencast !== undefined) runConfig.screencast = params.screencast;
 
       // Wire up onProgress to broadcast WS events
       runConfig.onProgress = (data) => {
-        bufferLiveEvent(data);
+        // Don't buffer screencast frames — they're ephemeral and high volume
+        if (data.event !== 'test:frame') {
+          bufferLiveEvent(data);
+        }
         wss.broadcast(JSON.stringify(data));
       };
 
       let tests, hooks;
       if (params.suite) {
-        ({ tests, hooks } = loadTestSuite(params.suite, runConfig.testsDir));
+        ({ tests, hooks } = loadTestSuite(params.suite, runConfig.testsDir, runConfig.modulesDir));
       } else {
         ({ tests, hooks } = loadAllSuites(runConfig.testsDir, runConfig.modulesDir, runConfig.exclude));
       }
 
-      await waitForAnyPool(getPoolUrls(runConfig));
+      await waitForAnyPool(getPoolUrls(runConfig), 30000, { poolDriver: runConfig.poolDriver, maxSessions: runConfig.maxSessions });
       const results = await runTestsParallel(tests, runConfig, hooks || {});
       const report = generateReport(results);
       const suiteName = params.suite || null;

package/src/db.js

@@ -199,6 +199,24 @@ function migrate(db) {
     CREATE INDEX IF NOT EXISTS idx_al_project  ON api_learnings(project_id);
     CREATE INDEX IF NOT EXISTS idx_al_endpoint ON api_learnings(endpoint);
 
+    CREATE TABLE IF NOT EXISTS action_health (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id      INTEGER NOT NULL REFERENCES projects(id),
+      run_id          INTEGER REFERENCES runs(id) ON DELETE CASCADE,
+      test_name       TEXT NOT NULL,
+      action_index    INTEGER NOT NULL,
+      action_type     TEXT NOT NULL,
+      selector        TEXT,
+      success         INTEGER NOT NULL,
+      duration_ms     INTEGER,
+      console_errors_after INTEGER DEFAULT 0,
+      network_errors_after INTEGER DEFAULT 0,
+      page_url        TEXT,
+      created_at      TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_ah_project  ON action_health(project_id);
+    CREATE INDEX IF NOT EXISTS idx_ah_selector ON action_health(selector);
+
     CREATE TABLE IF NOT EXISTS error_patterns (
       id              INTEGER PRIMARY KEY AUTOINCREMENT,
       project_id      INTEGER NOT NULL REFERENCES projects(id),
@@ -255,6 +273,28 @@ function migrate(db) {
     db.exec('ALTER TABLE test_results ADD COLUMN pool_url TEXT');
   }
 
+  // Add pool_driver column to runs for driver visibility
+  try {
+    db.prepare('SELECT pool_driver FROM runs LIMIT 0').run();
+  } catch {
+    db.exec('ALTER TABLE runs ADD COLUMN pool_driver TEXT');
+  }
+
+  // Add visual diff columns to test_results
+  const trCols = db.pragma('table_info(test_results)').map(c => c.name);
+  if (!trCols.includes('baseline_screenshot')) {
+    db.exec('ALTER TABLE test_results ADD COLUMN baseline_screenshot TEXT');
+  }
+  if (!trCols.includes('verification_screenshot')) {
+    db.exec('ALTER TABLE test_results ADD COLUMN verification_screenshot TEXT');
+  }
+  if (!trCols.includes('diff_screenshot')) {
+    db.exec('ALTER TABLE test_results ADD COLUMN diff_screenshot TEXT');
+  }
+  if (!trCols.includes('visual_diff_json')) {
+    db.exec('ALTER TABLE test_results ADD COLUMN visual_diff_json TEXT');
+  }
+
   // Migrations: add metadata columns to screenshot_hashes
   const ssColumns = db.pragma('table_info(screenshot_hashes)').map(c => c.name);
   if (!ssColumns.includes('test_name')) {
@@ -336,18 +376,18 @@ export function getScreenshotHashes(filePaths) {
 }
 
 /** Save a run + its test results in a single transaction. Returns the run's DB id. */
-export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
+export function saveRun(projectId, report, runId, suiteName, triggeredBy, poolDriver) {
   const d = getDb();
   const { summary, results, generatedAt } = report;
 
   const insertRun = d.prepare(`
-    INSERT INTO runs (project_id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO runs (project_id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by, pool_driver)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
   const insertTest = d.prepare(`
-    INSERT INTO test_results (run_id, name, success, error, start_time, end_time, duration_ms, attempt, max_attempts, error_screenshot, console_logs, network_errors, screenshots, network_logs, actions_json, pool_url)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO test_results (run_id, name, success, error, start_time, end_time, duration_ms, attempt, max_attempts, error_screenshot, console_logs, network_errors, screenshots, network_logs, actions_json, pool_url, baseline_screenshot, verification_screenshot, diff_screenshot, visual_diff_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
   const insertHash = d.prepare('INSERT OR IGNORE INTO screenshot_hashes (hash, file_path, project_id, run_id, test_name, step_index, page_url, screenshot_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?)');
@@ -364,6 +404,7 @@ export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
       generatedAt,
       suiteName || null,
       triggeredBy || null,
+      poolDriver || null,
     );
     const runDbId = runInfo.lastInsertRowid;
 
@@ -388,6 +429,8 @@ export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
         narrative: a.narrative || undefined,
         error: a.error || undefined,
         actionRetries: a.actionRetries || undefined,
+        autoScreenshot: a.autoScreenshot || undefined,
+        screenshot: a.result?.screenshot || undefined,
       }));
 
       insertTest.run(
@@ -407,6 +450,10 @@ export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
         r.networkLogs?.length ? JSON.stringify(r.networkLogs) : null,
         actionsCondensed.length ? JSON.stringify(actionsCondensed) : null,
         r.poolUrl || null,
+        r.baselineScreenshot || null,
+        r.verificationScreenshot || null,
+        r.diffScreenshot || null,
+        r.visualDiff ? JSON.stringify(r.visualDiff) : null,
       );
 
       // Register screenshot hashes with metadata
@@ -416,6 +463,15 @@ export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
         const actionIdx = r.actions.indexOf(a);
         insertHash.run(computeScreenshotHash(a.result.screenshot), a.result.screenshot, projectId, runDbId, r.name, actionIdx, null, 'action');
       }
+
+      // Auto-captured per-step thumbnails for the storyline view
+      (r.actions || []).forEach((a, idx) => {
+        if (a.autoScreenshot) {
+          try {
+            insertHash.run(computeScreenshotHash(a.autoScreenshot), a.autoScreenshot, projectId, runDbId, r.name, idx, null, 'step');
+          } catch { /* best effort */ }
+        }
+      });
       if (r.errorScreenshot) {
         insertHash.run(computeScreenshotHash(r.errorScreenshot), r.errorScreenshot, projectId, runDbId, r.name, null, null, 'error');
       }
@@ -425,6 +481,9 @@ export function saveRun(projectId, report, runId, suiteName, triggeredBy) {
       if (r.baselineScreenshot) {
         insertHash.run(computeScreenshotHash(r.baselineScreenshot), r.baselineScreenshot, projectId, runDbId, r.name, null, null, 'baseline');
       }
+      if (r.diffScreenshot) {
+        insertHash.run(computeScreenshotHash(r.diffScreenshot), r.diffScreenshot, projectId, runDbId, r.name, null, null, 'diff');
+      }
     }
 
     return runDbId;
@@ -480,7 +539,7 @@ export function listProjects() {
 export function getProjectRuns(projectId, limit = 50, offset = 0) {
   const d = getDb();
   return d.prepare(`
-    SELECT id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by
+    SELECT id, run_id, total, passed, failed, pass_rate, duration, generated_at, suite_name, triggered_by, pool_driver
     FROM runs
     WHERE project_id = ?
     ORDER BY generated_at DESC
@@ -503,6 +562,9 @@ export function getRunDetail(runDbId) {
     const ss = t.screenshots ? JSON.parse(t.screenshots) : [];
     allPaths.push(...ss);
     if (t.error_screenshot) allPaths.push(t.error_screenshot);
+    if (t.baseline_screenshot) allPaths.push(t.baseline_screenshot);
+    if (t.verification_screenshot) allPaths.push(t.verification_screenshot);
+    if (t.diff_screenshot) allPaths.push(t.diff_screenshot);
   }
   const hashMap = getScreenshotHashes(allPaths);
 
@@ -518,6 +580,7 @@ export function getRunDetail(runDbId) {
     generatedAt: run.generated_at,
     suiteName: run.suite_name,
     triggeredBy: run.triggered_by || null,
+    poolDriver: run.pool_driver || null,
     results: tests.map(t => {
       const screenshots = t.screenshots ? JSON.parse(t.screenshots) : [];
       const testPaths = [...screenshots];
@@ -543,6 +606,10 @@ export function getRunDetail(runDbId) {
         actions: t.actions_json ? JSON.parse(t.actions_json) : [],
         screenshotHashes,
         poolUrl: t.pool_url || null,
+        baselineScreenshot: t.baseline_screenshot || null,
+        verificationScreenshot: t.verification_screenshot || null,
+        diffScreenshot: t.diff_screenshot || null,
+        visualDiff: t.visual_diff_json ? JSON.parse(t.visual_diff_json) : null,
       };
     }),
   };
@@ -553,7 +620,7 @@ export function getAllRuns(limit = 50, offset = 0) {
   const d = getDb();
   return d.prepare(`
     SELECT r.id, r.run_id, r.total, r.passed, r.failed, r.pass_rate, r.duration,
-           r.generated_at, r.suite_name, r.triggered_by, p.name AS project_name, p.id AS project_id
+           r.generated_at, r.suite_name, r.triggered_by, r.pool_driver, p.name AS project_name, p.id AS project_id
     FROM runs r
     JOIN projects p ON p.id = r.project_id
     ORDER BY r.generated_at DESC

package/src/index.js

@@ -8,21 +8,23 @@
  */
 
 export { loadConfig } from './config.js';
-export { waitForPool, connectToPool, startPool, stopPool, restartPool, getPoolStatus } from './pool.js';
+export { waitForPool, connectToPool, disconnectFromPool, startPool, stopPool, restartPool, getPoolStatus, clearDriverCache, getCachedDriver, trackCdpSession, releaseCdpSession, releaseSteelSession } from './pool.js';
 export { getPoolUrls, getAllPoolStatuses, getAggregatedPoolStatus, waitForAnyPool, selectPool, selectAndConnect } from './pool-manager.js';
 export { executeAction } from './actions.js';
-export { runTest, runTestsParallel, loadTestFile, loadTestSuite, loadAllSuites, listSuites } from './runner.js';
+export { runTest, runTestsParallel, loadTestFile, loadTestSuite, loadAllSuites, listSuites, fetchAuthToken } from './runner.js';
 export { generateReport, generateJUnitXML, saveReport, printReport, saveHistory, loadHistory, loadHistoryRun } from './reporter.js';
 export { startDashboard, stopDashboard } from './dashboard.js';
 export { fetchIssue, parseIssueUrl, detectProvider, checkCliAuth } from './issues.js';
 export { buildPrompt, generateTests, hasApiKey } from './ai-generate.js';
 export { verifyIssue } from './verify.js';
 export { resolveTestData, loadModuleRegistry, listModules } from './module-resolver.js';
-export { learnFromRun, categorizeError } from './learner.js';
-export { getLearningsSummary, getFlakySummary, getSelectorStability, getPageHealth, getApiHealth, getErrorPatterns, getTestTrends, getRunInsights, getTestCreationContext, generateImprovements } from './learner-sqlite.js';
+export { learnFromRun, categorizeError, isInfraError, INFRA_CATEGORIES } from './learner.js';
+export { getLearningsSummary, getFlakySummary, getSelectorStability, getPageHealth, getApiHealth, getErrorPatterns, getTestTrends, getRunInsights, getTestCreationContext, generateImprovements, getActionHealthScores } from './learner-sqlite.js';
 export { generateLearningsMarkdown } from './learner-markdown.js';
 export { writeToGraph, queryGraph, closeNeo4j } from './learner-neo4j.js';
 export { startNeo4j, stopNeo4j, getNeo4jStatus } from './neo4j-pool.js';
+export { forkAppInstance, destroyFork, destroyAllForks, getAppPoolStatus, isAppPoolEnabled } from './app-pool.js';
+export { compareImages, assertVisualMatch } from './visual-diff.js';
 
 import { loadConfig } from './config.js';
 import { waitForAnyPool, getPoolUrls } from './pool-manager.js';