@imwz/wp-pattern-sentinel 0.2.4 → 0.2.6

package/README.md

@@ -134,7 +134,28 @@ src/
   format.js          log, formatResult, printSummary
 ```
 
-Each worker gets its own authenticated `BrowserContext` so session failures are isolated. Login happens once per context before the queue starts.
+Each worker gets its own authenticated `BrowserContext` so session failures are isolated. Login happens once, then cookies are shared across all contexts — concurrent logins are never attempted.
+
+### Login resilience
+
+If the WordPress login page times out (common on slow local VMs), sentinel retries automatically with exponential backoff:
+
+| Attempt | Wait before retry |
+|---------|-------------------|
+| 1st | — |
+| 2nd | 5 s |
+| 3rd | 15 s |
+| 4th (final) | 30 s |
+
+Credential rejections (wrong password) are not retried — only timeout errors trigger the backoff.
+
+### Real-time output
+
+Each pattern result is printed to the terminal as soon as that worker finishes, rather than buffering everything until the full batch completes. During a long concurrent run you see progress immediately.
+
+### Failure log
+
+When any pattern fails, sentinel automatically writes a `sentinel-<timestamp>.log.json` file in the current working directory and prints the path after the summary. This preserves error details for later inspection without needing to re-run.
 
 ## npm publish
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imwz/wp-pattern-sentinel",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Browser-based WordPress block pattern validator using Playwright",
   "type": "module",
   "engines": {

package/src/editor.js

@@ -1,7 +1,36 @@
 import { log } from './format.js';
 
+/**
+ * Replace inline PHP expressions with static equivalents so the block editor
+ * receives valid markup and the round-trip comparison stays accurate.
+ *
+ * Handles the PHP patterns that appear in Elayne theme patterns:
+ *   <?php esc_html_e( 'Text', 'elayne' ); ?>           → Text
+ *   <?php echo esc_html__( 'Text', 'elayne' ); ?>      → Text
+ *   <?php esc_attr_e( 'Alt text', 'elayne' ); ?>       → Alt text
+ *   <?php echo esc_attr__( 'Alt text', 'elayne' ); ?>  → Alt text
+ *   <?php echo esc_url( get_template_directory_uri() ); ?>  → http://example.com
+ *   All other <?php ... ?> blocks                       → removed
+ */
+function stripPhpForValidation(content) {
+  if (!content.includes('<?php')) return content;
+
+  return content
+    .replace(/<\?php\s+(?:esc_html_e|esc_html__)\s*\(\s*'([^']+)'\s*,\s*'[^']+'\s*\)\s*;?\s*\?>/g, '$1')
+    .replace(/<\?php\s+(?:esc_html_e|esc_html__)\s*\(\s*"([^"]+)"\s*,\s*"[^"]+"\s*\)\s*;?\s*\?>/g, '$1')
+    .replace(/<\?php\s+echo\s+esc_html__\s*\(\s*'([^']+)'\s*,\s*'[^']+'\s*\)\s*;?\s*\?>/g, '$1')
+    .replace(/<\?php\s+(?:esc_attr_e|esc_attr__)\s*\(\s*'([^']+)'\s*,\s*'[^']+'\s*\)\s*;?\s*\?>/g, '$1')
+    .replace(/<\?php\s+(?:esc_attr_e|esc_attr__)\s*\(\s*"([^"]+)"\s*,\s*"[^"]+"\s*\)\s*;?\s*\?>/g, '$1')
+    .replace(/<\?php\s+echo\s+esc_attr__\s*\(\s*'([^']+)'\s*,\s*'[^']+'\s*\)\s*;?\s*\?>/g, '$1')
+    .replace(/<\?php\s+echo\s+esc_url\s*\([\s\S]*?\)\s*;?\s*\?>/g, 'http://example.com')
+    .replace(/<\?php[\s\S]*?\?>/g, '')
+    .trim();
+}
+
 /**
  * Strip the PHP file header (opening tag + docblock) and return the raw block markup.
+ * Inline PHP expressions within the block markup are replaced with static values
+ * so the editor receives valid content for round-trip validation.
  * Returns null if no block comment is found.
  *
  * WordPress pattern files look like:
@@ -21,7 +50,7 @@ export function extractBlockContent(fileContent) {
     .trim();
 
   if (!stripped.startsWith('<!--')) return null;
-  return stripped;
+  return stripPhpForValidation(stripped);
 }
 
 /**

package/src/login.js

@@ -1,40 +1,63 @@
 import { log } from './format.js';
 
+const RETRY_DELAYS = [5_000, 15_000, 30_000]; // ms between attempts 1→2, 2→3, 3→4
+
 export async function loginToWordPress(page, adminUrl, user, pass) {
-  try {
-    // Navigate to the editor — WordPress redirects to wp-login.php if unauthenticated,
-    // with redirect_to preserving the editor URL (important for multisite subsite context).
-    await page.goto(`${adminUrl}/wp-admin/post-new.php?post_type=page`, {
-      waitUntil: 'domcontentloaded',
-      timeout: 60000,
-    });
-
-    // Already logged in — editor loaded directly
-    if (await page.locator('.edit-post-layout, .editor-styles-wrapper').count() > 0) {
-      return true;
+  for (let attempt = 0; attempt <= RETRY_DELAYS.length; attempt++) {
+    if (attempt > 0) {
+      const delay = RETRY_DELAYS[attempt - 1];
+      log(`  Login timeout — waiting ${delay / 1000}s before retry ${attempt}/${RETRY_DELAYS.length}...`, 'yellow');
+      await new Promise(resolve => setTimeout(resolve, delay));
     }
 
-    // Wait for the login form to be ready before filling
-    await page.waitForSelector('#user_login', { state: 'visible', timeout: 30000 });
-    await page.fill('#user_login', user);
-    await page.fill('#user_pass', pass);
-
-    // Start listening for navigation BEFORE clicking — avoids missing the redirect
-    await Promise.all([
-      page.waitForNavigation({ waitUntil: 'domcontentloaded', timeout: 60000 }),
-      page.click('#wp-submit'),
-    ]);
-
-    const loggedIn = page.url().includes('/wp-admin/') && !page.url().includes('wp-login.php');
-    if (!loggedIn) {
-      const error = await page.textContent('#login_error').catch(() => null);
-      log(`Login failed: ${error?.trim() ?? 'unexpected URL after submit: ' + page.url()}`, 'red');
-      return false;
+    try {
+      const result = await attemptLogin(page, adminUrl, user, pass);
+      return result; // true = success, false = credential error (don't retry)
+    } catch (err) {
+      const shortMsg = err.message.split('\n')[0];
+      if (attempt < RETRY_DELAYS.length) {
+        log(`  Login attempt ${attempt + 1} timed out: ${shortMsg}`, 'yellow');
+      } else {
+        log(`Login failed after ${RETRY_DELAYS.length + 1} attempts: ${shortMsg}`, 'red');
+        return false;
+      }
     }
+  }
+
+  return false;
+}
+
+async function attemptLogin(page, adminUrl, user, pass) {
+  // Navigate to the editor — WordPress redirects to wp-login.php if unauthenticated,
+  // with redirect_to preserving the editor URL (important for multisite subsite context).
+  await page.goto(`${adminUrl}/wp-admin/post-new.php?post_type=page`, {
+    waitUntil: 'domcontentloaded',
+    timeout: 60000,
+  });
 
+  // Already logged in — editor loaded directly
+  if (await page.locator('.edit-post-layout, .editor-styles-wrapper').count() > 0) {
     return true;
-  } catch (error) {
-    log(`Login failed: ${error.message}`, 'red');
+  }
+
+  // Wait for the login form to be ready before filling
+  await page.waitForSelector('#user_login', { state: 'visible', timeout: 30000 });
+  await page.fill('#user_login', user);
+  await page.fill('#user_pass', pass);
+
+  // Start listening for navigation BEFORE clicking — avoids missing the redirect
+  await Promise.all([
+    page.waitForNavigation({ waitUntil: 'domcontentloaded', timeout: 60000 }),
+    page.click('#wp-submit'),
+  ]);
+
+  const loggedIn = page.url().includes('/wp-admin/') && !page.url().includes('wp-login.php');
+  if (!loggedIn) {
+    const error = await page.textContent('#login_error').catch(() => null);
+    // Credential error — no point retrying
+    log(`Login rejected: ${error?.trim() ?? 'unexpected URL after submit: ' + page.url()}`, 'red');
     return false;
   }
+
+  return true;
 }

package/src/main.js

@@ -35,12 +35,14 @@ export async function main() {
   // reauth=1 redirect loop — serialising login avoids this entirely.
   let contexts;
   try {
+    log('Logging in to WordPress...', 'cyan');
     const firstContext = await browser.newContext({ viewport: options.viewport });
     const loginPage    = await firstContext.newPage();
     loginPage.setDefaultTimeout(60000);
     const ok = await loginToWordPress(loginPage, options.adminUrl, options.user, options.pass);
     await loginPage.close();
     if (!ok) throw new Error('Failed to authenticate with WordPress');
+    log(`Authenticated — sharing session across ${options.concurrency} worker(s)`, 'green');
 
     const cookies = await firstContext.cookies();
     contexts = [firstContext];
@@ -58,10 +60,17 @@ export async function main() {
   const queue = new PQueue({ concurrency: options.concurrency });
   let idx = 0;
 
-  // Push ALL tasks without awaiting — this is what makes workers run in parallel
+  // Push ALL tasks without awaiting — workers run in parallel.
+  // Print each result immediately as it finishes (real-time feedback).
   const promises = files.map(file => {
     const context = contexts[idx++ % options.concurrency];
-    return queue.add(() => validatePatternFile(file, options, context));
+    return queue.add(async () => {
+      const result = await validatePatternFile(file, options, context);
+      if (!options.json) {
+        console.log(formatResult(result));
+      }
+      return result;
+    });
   });
 
   const results = await Promise.all(promises);
@@ -71,18 +80,26 @@ export async function main() {
 
   if (options.json) {
     for (const r of results) console.log(JSON.stringify(r));
-  } else {
-    for (const r of results) console.log(formatResult(r));
-    printSummary(results);
   }
 
-  process.exit(results.some(r => !r.passed) ? 1 : 0);
+  printSummary(results);
+
+  // Write a log file when any pattern failed so details are preserved for inspection.
+  const hasFailed = results.some(r => !r.passed);
+  if (hasFailed) {
+    const logPath = await writeLogFile(results);
+    if (logPath) log(`  Log saved → ${logPath}`, 'gray');
+  }
+
+  process.exit(hasFailed ? 1 : 0);
 }
 
 async function validatePatternFile(patternPath, options, context) {
   const patternName = path.basename(patternPath);
   const startTime   = Date.now();
 
+  log(`  Validating: ${patternName}`, 'cyan');
+
   let fileContent;
   try {
     fileContent = await fs.promises.readFile(patternPath, 'utf8');
@@ -153,3 +170,25 @@ function fail(pattern, startTime, type, message) {
     duration: Date.now() - startTime,
   };
 }
+
+async function writeLogFile(results) {
+  try {
+    const now = new Date();
+    const ts  = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const logPath = path.join(process.cwd(), `sentinel-${ts}.log.json`);
+    const payload = {
+      timestamp: now.toISOString(),
+      results: results.map(r => ({
+        pattern:  r.pattern,
+        passed:   r.passed,
+        duration: r.duration,
+        errors:   r.errors,
+        warnings: r.warnings,
+      })),
+    };
+    await fs.promises.writeFile(logPath, JSON.stringify(payload, null, 2));
+    return logPath;
+  } catch {
+    return null;
+  }
+}