testaro 60.4.0 → 60.4.1

package/UPGRADES.md

@@ -2802,3 +2802,113 @@ This gives you:
 ✅ No git conflicts
 
 Claude Sonnet 4.5 • 1x
+
+## Cleanup synchronization
+
+Claude Sonnet 4.5 recommendation to handle already-closed error messages on server (but not the local host) after end of a job:
+
+The issue is that forceKillBrowsers() is killing the browser processes immediately, but the async browserClose() calls in the signal handlers are still trying to close already-dead browsers, causing repeated errors.
+
+Solution: Coordinate Async and Sync Cleanup
+Replace the cleanup handlers in run.js:
+
+```
+// CLEANUP HANDLERS
+
+// Track cleanup state.
+let cleanupInProgress = false;
+let forceKillScheduled = false;
+
+// Force kills all Playwright browser processes synchronously.
+const forceKillBrowsers = () => {
+  if (cleanupInProgress) {
+    return;
+  }
+  cleanupInProgress = true;
+
+  const {execSync} = require('child_process');
+  try {
+    // Kill Chromium headless shell processes.
+    execSync('pkill -9 -f "chromium_headless_shell.*headless_shell"', {stdio: 'ignore'});
+  }
+  catch(error) {
+    // Ignore errors - processes may not exist.
+  }
+};
+
+// Graceful cleanup with timeout fallback.
+const gracefulCleanup = async (timeoutMs = 2000) => {
+  if (forceKillScheduled) {
+    return;
+  }
+  forceKillScheduled = true;
+
+  // Try graceful close with timeout.
+  const closePromise = browserClose();
+  const timeoutPromise = new Promise(resolve => setTimeout(resolve, timeoutMs));
+
+  await Promise.race([closePromise, timeoutPromise]);
+
+  // Force kill any remaining processes.
+  forceKillBrowsers();
+};
+
+// Synchronous cleanup on process exit (last resort).
+process.on('exit', () => {
+  if (!cleanupInProgress) {
+    forceKillBrowsers();
+  }
+});
+
+// Graceful cleanup on SIGINT (Ctrl+C).
+process.on('SIGINT', async () => {
+  console.log('\nReceived SIGINT, cleaning up...');
+  await gracefulCleanup();
+  process.exit(130);
+});
+
+// Graceful cleanup on SIGTERM.
+process.on('SIGTERM', async () => {
+  console.log('Received SIGTERM, cleaning up...');
+  await gracefulCleanup();
+  process.exit(143);
+});
+
+// Cleanup on uncaught exceptions.
+process.on('uncaughtException', async error => {
+  console.error('Uncaught exception:', error);
+  await gracefulCleanup(1000);
+  process.exit(1);
+});
+```
+
+And in `doActs`, replace the cleanup:
+
+```
+  console.log('Acts completed');
+  // If standardization is required:
+  if (['also', 'only'].includes(standard)) {
+    // ... existing standardization code ...
+  }
+  // Close the browser gracefully.
+  await gracefulCleanup();
+  // Delete the temporary report file.
+  await fs.rm(reportPath, {force: true});
+  return report;
+  ```
+
+Key changes:
+
+gracefulCleanup(): Attempts async browserClose() but races it against a timeout, then force-kills
+Guard flags: Prevent multiple simultaneous cleanup attempts that cause the error messages
+Timeout: Gives browserClose 2 seconds to complete before forcing kill
+No redundant calls: Only gracefulCleanup() calls both browserClose() and forceKillBrowsers()
+process.on('exit') as fallback: Only runs if other cleanup didn't complete
+This approach:
+
+Tries graceful closure first (avoiding the errors)
+Falls back to force-kill after timeout
+Prevents the async cleanup from running after force-kill
+Works consistently on both macOS and Ubuntu
+
+The above recommendation seems complex. Meanwhile the error message has been suppressed on the basis that context closure is not necessarily an error.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "60.4.0",
+  "version": "60.4.1",
   "description": "Run 1000 web accessibility tests from 11 tools and get a standardized report",
   "main": "index.js",
   "scripts": {

package/procs/tellServer.js

@@ -35,7 +35,7 @@ const agent = process.env.AGENT;
 
 // FUNCTIONS
 
-// Sends a notification to an observer.
+// Sends a notice to an observer.
 exports.tellServer = (report, messageParams, logMessage) => {
   const {serverID} = report.sources;
   const observerURL = typeof serverID === 'number' ? process.env[`NETWATCH_URL_${serverID}_OBSERVE`] : '';

package/run.js

@@ -114,6 +114,8 @@ let actCount = 0;
 // Facts about the current act.
 let actIndex = 0;
 let browser;
+let cleanupInProgress = false;
+let browserCloseIntentional = false;
 let browserContext;
 let page;
 let report;
@@ -269,20 +271,19 @@ const addError = (alsoLog, alsoAbort, report, actIndex, message) => {
     abortActs(report, actIndex);
   }
 };
-// Closes the current browser.
+// Closes any current browser.
 const browserClose = async () => {
+  // If a browser exists:
   if (browser) {
     browserCloseIntentional = true;
+    // Try to close all its contexts and ignore any messages that they are already closed.
     for (const context of browser.contexts()) {
       try {
         await context.close();
       }
-      catch(error) {
-        console.log(
-          `ERROR trying to close context: ${error.message.slice(0, 200).replace(/\n.+/s, '')}`
-        );
-      }
+      catch(error) {}
     }
+    // Close the browser.
     await browser.close();
     browserCloseIntentional = false;
     browser = null;
@@ -303,7 +304,7 @@ const launch = exports.launch = async (
     report.target.url = url;
     // Create a browser of the specified or default type.
     const browserType = playwrightBrowsers[browserID];
-    // Close the current browser, if any.
+    // Close any current browser.
     await browserClose();
     // Define browser options.
     const browserOptions = {
@@ -678,6 +679,7 @@ const launchSpecs = (act, report) => [
 // Performs the acts in a report and adds the results to the report.
 const doActs = async (report, opts = {}) => {
   const {acts} = report;
+  // Get the granular observation options, if any.
   const {onProgress = null, signal = null} = opts;
   // Get the standardization specification.
   const standard = report.standard || 'only';
@@ -696,7 +698,7 @@ const doActs = async (report, opts = {}) => {
       if (report.observe) {
         const whichParam = which ? `&which=${which}` : '';
         const messageParams = `act=${type}${whichParam}`;
-        // If a progress callback has been provided:
+        // If a progress callback has been provided by a caller on this host:
         if (onProgress) {
           // Notify the observer of the act.
           try {
@@ -712,7 +714,7 @@ const doActs = async (report, opts = {}) => {
         }
         // Otherwise, i.e. if no progress callback has been provided:
         else {
-          // Notify the observer of the act and log it.
+          // Notify the remote observer of the act and log it.
           tellServer(report, messageParams, message);
         }
       }
@@ -1598,7 +1600,7 @@ exports.doJob = async (job, opts = {}) => {
         process.exit();
       }
     });
-    // Perform the acts and get a report.
+    // Perform the acts with any specified same-host observation options and get a report.
     report = await doActs(report, opts);
     // Add the end time and duration to the report.
     const endTime = new Date();
@@ -1623,10 +1625,6 @@ exports.doJob = async (job, opts = {}) => {
 
 // CLEANUP HANDLERS
 
-// Track whether cleanup is in progress.
-let cleanupInProgress = false;
-let browserCloseIntentional = false;
-
 // Force-kills any Playwright browser processes synchronously.
 const forceKillBrowsers = () => {
   if (cleanupInProgress) {