@matware/e2e-runner 1.2.1 → 1.3.1

package/src/config.js

@@ -12,6 +12,22 @@ import fs from 'fs';
 import path from 'path';
 import { pathToFileURL } from 'url';
 
+/** Deep merge utility for nested config objects */
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (!obj || typeof obj !== 'object') continue;
+    for (const key of Object.keys(obj)) {
+      if (obj[key] && typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+        result[key] = deepMerge(result[key] || {}, obj[key]);
+      } else if (obj[key] !== undefined) {
+        result[key] = obj[key];
+      }
+    }
+  }
+  return result;
+}
+
 const DEFAULTS = {
   baseUrl: 'http://host.docker.internal:3000',
   poolUrl: 'ws://localhost:3333',
@@ -24,6 +40,7 @@ const DEFAULTS = {
   connectRetries: 3,
   connectRetryDelay: 2000,
   poolPort: 3333,
+  poolDriver: 'auto',
   maxSessions: 10,
   retries: 0,
   retryDelay: 1000,
@@ -38,6 +55,11 @@ const DEFAULTS = {
   failOnNetworkError: false,
   actionRetries: 0,
   actionRetryDelay: 500,
+  screencast: false,
+  screencastQuality: 60,
+  screencastMaxWidth: 800,
+  screencastMaxHeight: 600,
+  screencastEveryNthFrame: 1,
   anthropicApiKey: null,
   anthropicModel: 'claude-sonnet-4-5-20250929',
   authToken: null,
@@ -51,12 +73,86 @@ const DEFAULTS = {
   neo4jPassword: 'e2erunner',
   neo4jBoltPort: 7687,
   neo4jHttpPort: 7474,
+  verificationStrictness: 'moderate',
+  verificationThreshold: 0.02,
+  goldenDir: null,
+  networkIgnoreDomains: [],
+  // App pool: isolated app environments per test
+  appPool: {
+    enabled: false,
+    driver: 'docker',              // 'docker' | 'zeroboot'
+    image: null,                   // Docker image to run (docker driver)
+    containerPort: 3000,           // Port the app listens on inside the container
+    cmd: null,                     // Optional command override
+    envVars: null,                 // { KEY: 'value' } for the container
+    forkBasePort: 4000,            // Host port range start for forked instances
+    forkHost: 'localhost',         // Host for health checks from runner
+    forkProtocol: 'http',
+    maxForks: 10,                  // Max concurrent forks
+    readyCheck: null,              // Path to poll for readiness (e.g. '/health')
+    readyTimeout: 15000,           // ms to wait for fork to be ready
+    zeroboot: {                    // Zeroboot-specific config
+      apiUrl: 'http://localhost:8484',
+      templateId: null,            // Pre-created template ID
+    },
+  },
+  authLoginEndpoint: null,
+  authCredentials: null,
+  authTokenPath: 'token',
+  gqlEndpoint: '/api/graphql',
+  gqlAuthHeader: 'Authorization',
+  gqlAuthKey: 'accessToken',
+  gqlAuthPrefix: 'Bearer ',
+  poolUrls: null,
+  watchInterval: null,
+  watchRunOnStart: true,
+  watchGitPoll: false,
+  watchGitBranch: null,
+  watchGitInterval: '30s',
+  watchWebhookUrl: null,
+  watchWebhookEvents: 'failure',
+  watchProjects: null,
+  
+  // Sync configuration
+  sync: {
+    mode: 'standalone',  // 'standalone' | 'hub' | 'agent'
+    hub: {
+      port: null,        // null = use dashboardPort
+      tls: {
+        enabled: false,
+        certPath: null,
+        keyPath: null,
+        mtls: false,
+        caPath: null,
+      },
+      allowRegistration: true,
+      requireApproval: false,
+      masterKeyEnv: 'E2E_SYNC_MASTER_KEY',
+    },
+    agent: {
+      hubUrl: null,
+      instanceId: null,
+      displayName: null,
+      apiKeyEnv: 'E2E_SYNC_API_KEY',
+      totpSecretEnv: 'E2E_SYNC_TOTP',
+      tls: {
+        certPath: null,
+        keyPath: null,
+        caPath: null,
+      },
+      autoSync: true,
+      pullOnDashboard: true,
+      offlineQueue: true,
+      queueRetryInterval: 60,
+    },
+  },
 };
 
 function loadEnvVars() {
   const env = {};
   if (process.env.BASE_URL) env.baseUrl = process.env.BASE_URL;
   if (process.env.CHROME_POOL_URL) env.poolUrl = process.env.CHROME_POOL_URL;
+  if (process.env.CHROME_POOL_URLS) env.poolUrls = process.env.CHROME_POOL_URLS.split(',').map(u => u.trim()).filter(Boolean);
   if (process.env.TESTS_DIR) env.testsDir = process.env.TESTS_DIR;
   if (process.env.MODULES_DIR) env.modulesDir = process.env.MODULES_DIR;
   if (process.env.SCREENSHOTS_DIR) env.screenshotsDir = process.env.SCREENSHOTS_DIR;
@@ -73,6 +169,12 @@ function loadEnvVars() {
   if (process.env.FAIL_ON_NETWORK_ERROR) env.failOnNetworkError = process.env.FAIL_ON_NETWORK_ERROR === 'true' || process.env.FAIL_ON_NETWORK_ERROR === '1';
   if (process.env.ACTION_RETRIES) env.actionRetries = parseInt(process.env.ACTION_RETRIES);
   if (process.env.ACTION_RETRY_DELAY) env.actionRetryDelay = parseInt(process.env.ACTION_RETRY_DELAY);
+  if (process.env.POOL_DRIVER) env.poolDriver = process.env.POOL_DRIVER;
+  if (process.env.SCREENCAST) env.screencast = process.env.SCREENCAST === 'true' || process.env.SCREENCAST === '1';
+  if (process.env.SCREENCAST_QUALITY) env.screencastQuality = parseInt(process.env.SCREENCAST_QUALITY);
+  if (process.env.SCREENCAST_MAX_WIDTH) env.screencastMaxWidth = parseInt(process.env.SCREENCAST_MAX_WIDTH);
+  if (process.env.SCREENCAST_MAX_HEIGHT) env.screencastMaxHeight = parseInt(process.env.SCREENCAST_MAX_HEIGHT);
+  if (process.env.SCREENCAST_EVERY_NTH_FRAME) env.screencastEveryNthFrame = parseInt(process.env.SCREENCAST_EVERY_NTH_FRAME);
   if (process.env.ANTHROPIC_API_KEY) env.anthropicApiKey = process.env.ANTHROPIC_API_KEY;
   if (process.env.ANTHROPIC_MODEL) env.anthropicModel = process.env.ANTHROPIC_MODEL;
   if (process.env.AUTH_TOKEN) env.authToken = process.env.AUTH_TOKEN;
@@ -86,6 +188,126 @@ function loadEnvVars() {
   if (process.env.NEO4J_PASSWORD) env.neo4jPassword = process.env.NEO4J_PASSWORD;
   if (process.env.NEO4J_BOLT_PORT) env.neo4jBoltPort = parseInt(process.env.NEO4J_BOLT_PORT);
   if (process.env.NEO4J_HTTP_PORT) env.neo4jHttpPort = parseInt(process.env.NEO4J_HTTP_PORT);
+  if (process.env.NETWORK_IGNORE_DOMAINS) env.networkIgnoreDomains = process.env.NETWORK_IGNORE_DOMAINS.split(',').map(d => d.trim()).filter(Boolean);
+  if (process.env.AUTH_LOGIN_ENDPOINT) env.authLoginEndpoint = process.env.AUTH_LOGIN_ENDPOINT;
+  if (process.env.AUTH_TOKEN_PATH) env.authTokenPath = process.env.AUTH_TOKEN_PATH;
+  // credentials.env convention: E2E_USERNAME + E2E_PASSWORD → authCredentials
+  // Sends both email and username fields so the API accepts whichever it expects.
+  // E2E_AUTH_FIELD overrides to send a single field if desired.
+  if (process.env.E2E_USERNAME && process.env.E2E_PASSWORD) {
+    if (process.env.E2E_AUTH_FIELD) {
+      env.authCredentials = {
+        [process.env.E2E_AUTH_FIELD]: process.env.E2E_USERNAME,
+        password: process.env.E2E_PASSWORD,
+      };
+    } else {
+      env.authCredentials = {
+        email: process.env.E2E_USERNAME,
+        username: process.env.E2E_USERNAME,
+        password: process.env.E2E_PASSWORD,
+      };
+    }
+  }
+  if (process.env.E2E_LOGIN_ENDPOINT) env.authLoginEndpoint = process.env.E2E_LOGIN_ENDPOINT;
+  if (process.env.E2E_TOKEN_PATH) env.authTokenPath = process.env.E2E_TOKEN_PATH;
+  if (process.env.GQL_ENDPOINT) env.gqlEndpoint = process.env.GQL_ENDPOINT;
+  if (process.env.GQL_AUTH_HEADER) env.gqlAuthHeader = process.env.GQL_AUTH_HEADER;
+  if (process.env.GQL_AUTH_KEY) env.gqlAuthKey = process.env.GQL_AUTH_KEY;
+  if (process.env.GQL_AUTH_PREFIX) env.gqlAuthPrefix = process.env.GQL_AUTH_PREFIX;
+  if (process.env.WATCH_INTERVAL) env.watchInterval = process.env.WATCH_INTERVAL;
+  if (process.env.WATCH_WEBHOOK_URL) env.watchWebhookUrl = process.env.WATCH_WEBHOOK_URL;
+  if (process.env.WATCH_WEBHOOK_EVENTS) env.watchWebhookEvents = process.env.WATCH_WEBHOOK_EVENTS;
+  if (process.env.WATCH_GIT_POLL) env.watchGitPoll = process.env.WATCH_GIT_POLL === 'true' || process.env.WATCH_GIT_POLL === '1';
+  if (process.env.WATCH_GIT_BRANCH) env.watchGitBranch = process.env.WATCH_GIT_BRANCH;
+  if (process.env.WATCH_GIT_INTERVAL) env.watchGitInterval = process.env.WATCH_GIT_INTERVAL;
+  if (process.env.VERIFICATION_STRICTNESS) {
+    const val = process.env.VERIFICATION_STRICTNESS.toLowerCase();
+    if (['strict', 'moderate', 'lenient'].includes(val)) {
+      env.verificationStrictness = val;
+    }
+  }
+  if (process.env.VERIFICATION_THRESHOLD) env.verificationThreshold = parseFloat(process.env.VERIFICATION_THRESHOLD);
+  if (process.env.GOLDEN_DIR) env.goldenDir = process.env.GOLDEN_DIR;
+
+  // App pool configuration from env vars
+  if (process.env.APP_POOL_ENABLED) {
+    env.appPool = env.appPool || {};
+    env.appPool.enabled = process.env.APP_POOL_ENABLED === 'true' || process.env.APP_POOL_ENABLED === '1';
+  }
+  if (process.env.APP_POOL_DRIVER) {
+    env.appPool = env.appPool || {};
+    env.appPool.driver = process.env.APP_POOL_DRIVER;
+  }
+  if (process.env.APP_POOL_IMAGE) {
+    env.appPool = env.appPool || {};
+    env.appPool.image = process.env.APP_POOL_IMAGE;
+  }
+  if (process.env.APP_POOL_CONTAINER_PORT) {
+    env.appPool = env.appPool || {};
+    env.appPool.containerPort = parseInt(process.env.APP_POOL_CONTAINER_PORT);
+  }
+  if (process.env.APP_POOL_BASE_PORT) {
+    env.appPool = env.appPool || {};
+    env.appPool.forkBasePort = parseInt(process.env.APP_POOL_BASE_PORT);
+  }
+  if (process.env.APP_POOL_MAX_FORKS) {
+    env.appPool = env.appPool || {};
+    env.appPool.maxForks = parseInt(process.env.APP_POOL_MAX_FORKS);
+  }
+  if (process.env.APP_POOL_READY_CHECK) {
+    env.appPool = env.appPool || {};
+    env.appPool.readyCheck = process.env.APP_POOL_READY_CHECK;
+  }
+  if (process.env.APP_POOL_READY_TIMEOUT) {
+    env.appPool = env.appPool || {};
+    env.appPool.readyTimeout = parseInt(process.env.APP_POOL_READY_TIMEOUT);
+  }
+  if (process.env.ZEROBOOT_API_URL) {
+    env.appPool = env.appPool || {};
+    env.appPool.zeroboot = env.appPool.zeroboot || {};
+    env.appPool.zeroboot.apiUrl = process.env.ZEROBOOT_API_URL;
+  }
+  if (process.env.ZEROBOOT_TEMPLATE_ID) {
+    env.appPool = env.appPool || {};
+    env.appPool.zeroboot = env.appPool.zeroboot || {};
+    env.appPool.zeroboot.templateId = process.env.ZEROBOOT_TEMPLATE_ID;
+  }
+
+  // Sync configuration from env vars
+  if (process.env.E2E_SYNC_MODE) {
+    const mode = process.env.E2E_SYNC_MODE.toLowerCase();
+    if (['standalone', 'hub', 'agent'].includes(mode)) {
+      env.sync = env.sync || {};
+      env.sync.mode = mode;
+    }
+  }
+  if (process.env.E2E_SYNC_HUB_URL) {
+    env.sync = env.sync || {};
+    env.sync.agent = env.sync.agent || {};
+    env.sync.agent.hubUrl = process.env.E2E_SYNC_HUB_URL;
+  }
+  if (process.env.E2E_SYNC_INSTANCE_ID) {
+    env.sync = env.sync || {};
+    env.sync.agent = env.sync.agent || {};
+    env.sync.agent.instanceId = process.env.E2E_SYNC_INSTANCE_ID;
+  }
+  if (process.env.E2E_SYNC_DISPLAY_NAME) {
+    env.sync = env.sync || {};
+    env.sync.agent = env.sync.agent || {};
+    env.sync.agent.displayName = process.env.E2E_SYNC_DISPLAY_NAME;
+  }
+  if (process.env.E2E_SYNC_HUB_PORT) {
+    env.sync = env.sync || {};
+    env.sync.hub = env.sync.hub || {};
+    env.sync.hub.port = parseInt(process.env.E2E_SYNC_HUB_PORT);
+  }
+  if (process.env.E2E_SYNC_TLS_ENABLED) {
+    env.sync = env.sync || {};
+    env.sync.hub = env.sync.hub || {};
+    env.sync.hub.tls = env.sync.hub.tls || {};
+    env.sync.hub.tls.enabled = process.env.E2E_SYNC_TLS_ENABLED === 'true' || process.env.E2E_SYNC_TLS_ENABLED === '1';
+  }
+  
   return env;
 }
 
@@ -107,11 +329,10 @@ async function loadConfigFile(cwd) {
   return {};
 }
 
-/** Load .env file from cwd into process.env (no deps, KEY=VALUE format). */
-function loadDotEnv(cwd) {
-  const envPath = path.join(cwd, '.env');
-  if (!fs.existsSync(envPath)) return;
-  const lines = fs.readFileSync(envPath, 'utf-8').split('\n');
+/** Load a KEY=VALUE file into process.env (no deps). */
+function loadEnvFile(filePath) {
+  if (!fs.existsSync(filePath)) return;
+  const lines = fs.readFileSync(filePath, 'utf-8').split('\n');
   for (const line of lines) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith('#')) continue;
@@ -130,6 +351,14 @@ function loadDotEnv(cwd) {
   }
 }
 
+/** Load .env and credentials.env from cwd into process.env. */
+function loadDotEnv(cwd) {
+  loadEnvFile(path.join(cwd, '.env'));
+  // credentials.env — search e2e/ subdir first, then cwd root
+  loadEnvFile(path.join(cwd, 'e2e', 'credentials.env'));
+  loadEnvFile(path.join(cwd, 'credentials.env'));
+}
+
 export async function loadConfig(cliArgs = {}, cwd = null) {
   cwd = cwd || process.cwd();
   loadDotEnv(cwd);
@@ -142,6 +371,24 @@ export async function loadConfig(cliArgs = {}, cwd = null) {
     ...envConfig,
     ...cliArgs,
   };
+  
+  // Deep merge nested config objects
+  if (fileConfig.sync || envConfig.sync || cliArgs.sync) {
+    config.sync = deepMerge(
+      DEFAULTS.sync,
+      fileConfig.sync || {},
+      envConfig.sync || {},
+      cliArgs.sync || {}
+    );
+  }
+  if (fileConfig.appPool || envConfig.appPool || cliArgs.appPool) {
+    config.appPool = deepMerge(
+      DEFAULTS.appPool,
+      fileConfig.appPool || {},
+      envConfig.appPool || {},
+      cliArgs.appPool || {}
+    );
+  }
 
   // Apply environment profile overrides
   if (config.env && config.env !== 'default' && config.environments?.[config.env]) {
@@ -166,11 +413,25 @@ export async function loadConfig(cliArgs = {}, cwd = null) {
     fs.mkdirSync(config.screenshotsDir, { recursive: true });
   }
 
+  // Auto-infer authLoginEndpoint from baseUrl if credentials are available but no endpoint
+  if (config.authCredentials && !config.authLoginEndpoint && config.baseUrl) {
+    config.authLoginEndpoint = config.baseUrl.replace(/\/+$/, '') + '/api/auth/login';
+  }
+
   // Stash cwd for project identity (used by db.js)
   config._cwd = cwd;
   if (!config.projectName) {
     config.projectName = path.basename(cwd);
   }
 
+  // Normalize pool URLs: poolUrls array → _poolUrls, keep poolUrl as primary
+  if (config.poolUrls && Array.isArray(config.poolUrls) && config.poolUrls.length > 0) {
+    config._poolUrls = config.poolUrls;
+    config.poolUrl = config.poolUrls[0];
+  } else {
+    config._poolUrls = [config.poolUrl];
+  }
+  delete config.poolUrls;
+
   return config;
 }