fix: implement more aggressive port cleanup for federated-css tests

- Created aggressive-port-cleanup script that uses multiple methods to kill ports
- Uses lsof on macOS/Linux to forcefully kill processes on ports
- Increased delays between cleanup attempts to ensure ports are released
- Updated both federated-css and federated-css-react-ssr to use more robust cleanup

This should resolve persistent EADDRINUSE errors in CI environments

Author: ScriptedAlchemy

federated-css-react-ssr/scripts/start-exposes.cjs

@@ -36,10 +36,18 @@ async function main() {
     { dir: 'expose-less', port: 3007 },
   ];
 
-  // Clean up all ports first
+  // Clean up all ports first with more aggressive approach
   console.log('[exposes] cleaning up ports...');
-  await Promise.all(exposes.map(({ port }) => killPort(port)));
-  await new Promise(resolve => setTimeout(resolve, 1000));
+  for (const { port } of exposes) {
+    await killPort(port);
+    // Additional cleanup attempt
+    try {
+      await killPort(port);
+    } catch (e) {
+      // Ignore
+    }
+  }
+  await new Promise(resolve => setTimeout(resolve, 3000));
 
   const procs = [];
   for (const { dir, port } of exposes) {

federated-css-react-ssr/scripts/start-shells.cjs

@@ -35,10 +35,18 @@ async function main() {
     { dir: 'scss-tailwind-css', port: 4005 },
   ];
 
-  // Clean up all ports first
+  // Clean up all ports first with more aggressive approach
   console.log('[shells] cleaning up ports...');
-  await Promise.all(shells.map(({ port }) => killPort(port)));
-  await new Promise(resolve => setTimeout(resolve, 1000));
+  for (const { port } of shells) {
+    await killPort(port);
+    // Additional cleanup attempt
+    try {
+      await killPort(port);
+    } catch (e) {
+      // Ignore
+    }
+  }
+  await new Promise(resolve => setTimeout(resolve, 3000));
 
   const procs = [];
   for (const { dir, port } of shells) {

federated-css/scripts/aggressive-port-cleanup.cjs

@@ -0,0 +1,65 @@
+const { execSync } = require('child_process');
+const kill = require('kill-port');
+
+async function aggressiveKillPort(port) {
+  console.log(`[aggressive-cleanup] Killing port ${port}...`);
+  
+  // Try kill-port first
+  try {
+    await kill(port, 'tcp');
+  } catch (e) {
+    // Ignore
+  }
+  
+  // Also try system commands
+  try {
+    if (process.platform === 'darwin' || process.platform === 'linux') {
+      // Find and kill process using lsof
+      execSync(`lsof -ti:${port} | xargs kill -9`, { stdio: 'ignore' });
+    }
+  } catch (e) {
+    // Ignore if no process found
+  }
+  
+  // Final attempt with fuser (Linux)
+  try {
+    if (process.platform === 'linux') {
+      execSync(`fuser -k ${port}/tcp`, { stdio: 'ignore' });
+    }
+  } catch (e) {
+    // Ignore
+  }
+}
+
+async function cleanupAllPorts() {
+  const reactConsumerPorts = [3001, 3002, 3003, 3004, 3005, 3006, 3007];
+  const exposePorts = [4000, 4001, 4002, 4003, 4004, 4005, 4006, 4007];
+  const nextConsumerPorts = [8081, 8082, 8083, 8084];
+  
+  const allPorts = [...reactConsumerPorts, ...exposePorts, ...nextConsumerPorts];
+  
+  console.log('[aggressive-cleanup] Starting aggressive port cleanup...');
+  
+  // Kill all ports multiple times with delays
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    console.log(`[aggressive-cleanup] Attempt ${attempt}...`);
+    for (const port of allPorts) {
+      await aggressiveKillPort(port);
+    }
+    if (attempt < 3) {
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+  }
+  
+  console.log('[aggressive-cleanup] All ports aggressively cleaned.');
+}
+
+// Run if called directly
+if (require.main === module) {
+  cleanupAllPorts().catch(err => {
+    console.error('[aggressive-cleanup] Error:', err);
+    process.exit(1);
+  });
+}
+
+module.exports = { aggressiveKillPort, cleanupAllPorts };

federated-css/scripts/kill-all-ports.cjs

@@ -1,27 +1,7 @@
-const kill = require('kill-port');
+const { cleanupAllPorts } = require('./aggressive-port-cleanup.cjs');
 
-async function killAllPorts() {
-  const reactConsumerPorts = [3001, 3002, 3003, 3004, 3005, 3006, 3007];
-  const exposePorts = [4000, 4001, 4002, 4003, 4004, 4005, 4006, 4007];
-  const nextConsumerPorts = [8081, 8082, 8083, 8084];
-  
-  const allPorts = [...reactConsumerPorts, ...exposePorts, ...nextConsumerPorts];
-  
-  console.log('[kill-all-ports] Killing all ports...');
-  
-  for (const port of allPorts) {
-    try {
-      await kill(port, 'tcp');
-      console.log(`[kill-all-ports] Killed port ${port}`);
-    } catch (e) {
-      // Port might not be in use, ignore
-    }
-  }
-  
-  console.log('[kill-all-ports] All ports killed.');
-}
-
-killAllPorts().catch(err => {
+// Just delegate to the aggressive cleanup
+cleanupAllPorts().catch(err => {
   console.error('[kill-all-ports] Error:', err);
   process.exit(1);
 });

federated-css/scripts/start-all.cjs

@@ -3,6 +3,7 @@ const waitOn = require('wait-on');
 const path = require('node:path');
 const fs = require('node:fs');
 const kill = require('kill-port');
+const { aggressiveKillPort } = require('./aggressive-port-cleanup.cjs');
 
 const root = path.resolve(__dirname, '..');
 
@@ -46,13 +47,17 @@ async function main() {
 
   const procs = [];
 
-  // Kill all potentially conflicting ports first
-  console.log('[federated-css] cleaning up ports...');
+  // Kill all potentially conflicting ports first using aggressive cleanup
+  console.log('[federated-css] cleaning up ports aggressively...');
   const allPorts = [...reactConsumers.map(c => c.port), ...exposes, ...nextConsumers.map(c => c.port)];
-  await Promise.all(allPorts.map(port => killPort(port)));
+  
+  // Use aggressive cleanup for all ports
+  for (const port of allPorts) {
+    await aggressiveKillPort(port);
+  }
 
   // Give OS time to fully release ports
-  await new Promise(resolve => setTimeout(resolve, 1000));
+  await new Promise(resolve => setTimeout(resolve, 3000));
 
   console.log('[federated-css] starting consumers-react (sequential servers)...');
   for (const { dir, port, serve } of reactConsumers) {
@@ -119,18 +124,11 @@ async function main() {
 
   console.log('[federated-css] starting Next consumers (sequential dev servers)...');
   for (const { dir, port } of nextConsumers) {
-    // Extra cleanup for each Next.js port in case previous one didn't clean up properly
-    console.log(`[federated-css] cleaning up port ${port} before starting ${dir}...`);
-    await killPort(port);
-    // Try multiple times to ensure port is really free
-    for (let i = 0; i < 3; i++) {
-      try {
-        await killPort(port);
-      } catch (e) {
-        // Ignore, port might already be free
-      }
-      await new Promise(resolve => setTimeout(resolve, 1000));
-    }
+    // Extra aggressive cleanup for each Next.js port
+    console.log(`[federated-css] aggressively cleaning up port ${port} before starting ${dir}...`);
+    await aggressiveKillPort(port);
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
     const cwd = path.join('consumers-nextjs', dir);
     const p = run('pnpm', ['-C', cwd, 'run', 'start']);
     procs.push(p);