@arcadialdev/arcality 2.6.1 → 2.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcadialdev/arcality",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "El primer ingeniero QA Autónomo integrado al CI/CD. Creado por Arcadial.",
   "main": "index.js",
   "scripts": {

package/scripts/gen-and-run.mjs

@@ -740,19 +740,51 @@ async function main() {
 
             const finalProjectId = process.env.ARCALITY_PROJECT_ID || selectedProjectId;
 
-            // ── SIGINT Handler: Cancelación manual (Ctrl+C / ESC) ──
-            // Se registra AQUÍ, justo antes del spawn, para que solo aplique durante la ejecución.
-            // Al cancelar: mata el proceso hijo, guarda estado "canceled", llama endMission y genera reporte.
-            let activeChildProcess = null;  // Referencia al proceso hijo de Playwright
+            // ── Cancelación Manual (Ctrl+C) — Estrategia bulletproof ──
+            // El problema: @clack/prompts registra su propio SIGINT handler cada tick del spinner,
+            // que llama a process.exit(0) directamente. removeAllListeners() no es suficiente porque
+            // Clack lo re-registra en cada frame de animación.
+            //
+            // La solución: interceptar process.exit() antes de que Clack lo llame,
+            // y usar prependListener para que NUESTRO handler siempre se ejecute primero.
+
+            let activeChildProcess = null;
             let userCanceledMission = false;
-            const cancelHandler = async () => {
-                if (userCanceledMission) return; // Evitar doble disparo
+            let sigintCount = 0;
+            let _missionActive = true;  // Mientras true, bloqueamos el process.exit de Clack
+
+            // Guardar el process.exit original y reemplazarlo temporalmente
+            const _origProcessExit = process.exit.bind(process);
+            process.exit = (code) => {
+                if (_missionActive) {
+                    // Clack (u otra lib) está intentando matar el proceso — lo bloqueamos.
+                    // Nuestro cancelHandler ya habrá sido invocado vía prependListener.
+                    // El proceso se cerrará naturalmente cuando el child process termine.
+                    return;
+                }
+                _origProcessExit(code);
+            };
+
+            const cancelHandler = () => {
+                sigintCount++;
+                if (sigintCount > 3) {
+                    console.log(chalk.red('\n🛑 Forzando salida inmediata...'));
+                    _missionActive = false;
+                    _origProcessExit(1);
+                    return;
+                }
+
+                if (userCanceledMission) {
+                    console.log(chalk.yellow('\n⏳ Cancelación en progreso, esperando reporte... (Ctrl+C x4 para forzar cierre)'));
+                    return;
+                }
                 userCanceledMission = true;
 
                 console.log(chalk.yellow('\n\n⚠️  [ARCALITY] Misión cancelada por el usuario.'));
-                if (!process.argv.includes('--debug')) s.stop(chalk.yellow('⚠️  Misión cancelada por el usuario.'));
+                if (!process.argv.includes('--debug')) {
+                    try { s.stop(chalk.yellow('⚠️  Misión cancelada.')); } catch { /* ignore */ }
+                }
 
-                // 1. Escribir un agent-log de cancelación para que el reporte lo refleje
                 try {
                     const ctxDir = process.env.CONTEXT_DIR;
                     if (ctxDir && fs.existsSync(ctxDir)) {
@@ -770,28 +802,15 @@ async function main() {
                     }
                 } catch { /* silencioso */ }
 
-                // 2. Registraremos la misión como 'canceled' en el bloque finally
-                console.log(chalk.gray('   >> Registrando misión como "cancelada"...'));
-
-                // 3. Matar el proceso hijo de Playwright — hacerlo AL FINAL para dar tiempo
-                //    a que el agente-log y endMission terminen antes del kill.
-                //    NO llamar process.exit() aquí: el finally del try/catch principal
-                //    se encarga de generar el reporte visual y abrirlo en el browser.
-                if (activeChildProcess) {
-                    try {
-                        if (process.platform === 'win32') {
-                            spawn('taskkill', ['/pid', activeChildProcess.pid, '/f', '/t'], { stdio: 'ignore', windowsHide: true });
-                        } else {
-                            activeChildProcess.kill('SIGTERM');
-                        }
-                    } catch { /* silencioso */ }
-                }
-                // El bloque finally del try/catch de run() tomará el control
-                // a partir de aquí (el proceso hijo ya terminó → run() rechaza → catch → finally).
+                console.log(chalk.gray('   >> Esperando que Playwright cierre y genere el reporte...'));
+                // Playwright también recibe el SIGINT nativamente desde la terminal Windows
+                // y cerrará su proceso limpiamente, lo que resolverá la Promise del run() → finally
             };
 
-            process.once('SIGINT', cancelHandler);
-            process.once('SIGTERM', cancelHandler);
+            // prependListener asegura que nuestro handler se ejecuta ANTES que el de Clack
+            process.prependListener('SIGINT', cancelHandler);
+            process.prependListener('SIGTERM', cancelHandler);
+
 
             // Build env for the runner — merge arcality.config values.
             // ARCALITY_API_URL must be explicit — it comes from the library's internal config,
@@ -831,23 +850,55 @@ async function main() {
             const testFile = path.join(PROJECT_ROOT, 'tests', '_helpers', 'agentic-runner.spec.ts');
             const configFile = path.join(PROJECT_ROOT, 'playwright.config.js');
 
-            // Resolve playwright CLI relative to PROJECT_ROOT exactly as Node handles module resolution.
-            // This prevents the "did not expect test() to be called here" singleton duplication error.
+            // Resolve playwright CLI — CRITICAL: must use the same @playwright/test instance
+            // that the agentic-runner.bundle.spec.js was compiled against. If the user's project
+            // has its own @playwright/test, we must use THAT one to avoid the singleton conflict
+            // ("Playwright Test did not expect test() to be called here").
+            //
+            // Resolution order:
+            //   1. ORIGINAL_CWD (user's project) — preferred, avoids singleton mismatch
+            //   2. PROJECT_ROOT (arcality package) — fallback for clean installs
             let playwrightCli;
             try {
-                // Find the core @playwright/test that the local project uses
-                const testRunnerPath = require.resolve('@playwright/test', { paths: [PROJECT_ROOT] });
-                // Target the cli.js file strictly inside its parallel playwright dependency
+                const searchPaths = [ORIGINAL_CWD, PROJECT_ROOT];
+                let testRunnerPath = null;
+                let resolveError = null;
+
+                for (const searchPath of searchPaths) {
+                    try {
+                        testRunnerPath = require.resolve('@playwright/test', { paths: [searchPath] });
+                        break;
+                    } catch (e) {
+                        resolveError = e;
+                    }
+                }
+
+                if (!testRunnerPath) throw resolveError;
+
+                // Navigate from @playwright/test/index.js → playwright/cli.js (sibling package)
                 playwrightCli = path.join(testRunnerPath, '..', '..', '..', 'playwright', 'cli.js');
+
+                // Some versions nest it differently — try alternate location
                 if (!fs.existsSync(playwrightCli)) {
-                    throw new Error(`CLI not found exactly at: ${playwrightCli}`);
+                    const alt = path.join(testRunnerPath, '..', '..', 'playwright', 'cli.js');
+                    if (fs.existsSync(alt)) playwrightCli = alt;
+                    else throw new Error(`Playwright CLI not found. Tried:\n  ${playwrightCli}\n  ${alt}`);
+                }
+
+                if (process.argv.includes('--debug')) {
+                    console.log(chalk.gray(`[DEBUG] Using playwright CLI: ${playwrightCli}`));
                 }
             } catch (e) {
-                console.error(chalk.red('\n[FATAL] Playwright core not found! Make sure playwright is properly installed.'));
+                console.error(chalk.red('\n[FATAL] Playwright core not found. Make sure @playwright/test is installed.'));
                 console.error(chalk.red(e.message));
+                console.error(chalk.yellow('\nTip: Run `npm install @playwright/test` in your project directory.'));
+                _missionActive = false;
+                process.exit = _origProcessExit;
                 process.exit(1);
             }
 
+
+            const postProcessSigint = () => console.log(chalk.yellow('\n⏳ Finalizando tareas de reporte, por favor espera...'));
             let missionResult = null;
             let finalFailReason = null;
             let finalUsageData = undefined;
@@ -869,9 +920,10 @@ async function main() {
                     onSpawn: (child) => { activeChildProcess = child; }  // ← Capturar referencia para cancelHandler
                 });
 
-                // Eliminar handlers SIGINT ahora que el proceso terminó normalmente
-                process.off('SIGINT', cancelHandler);
-                process.off('SIGTERM', cancelHandler);
+                process.removeAllListeners('SIGINT');
+                process.removeAllListeners('SIGTERM');
+                process.on('SIGINT', postProcessSigint);
+                process.on('SIGTERM', postProcessSigint);
 
                 if (userCanceledMission) {
                     missionResult = 'canceled';
@@ -932,15 +984,10 @@ async function main() {
                     }
                 }
             } catch (e) {
-                // Eliminar handlers SIGINT en el path de error también
-                process.off('SIGINT', cancelHandler);
-                process.off('SIGTERM', cancelHandler);
-
+                // SIGINT ya fue manejado por cancelHandler — solo clasificamos el resultado
                 if (userCanceledMission) {
                     missionResult = 'canceled';
                     finalFailReason = 'user_canceled';
-                    // El cancelHandler ya registró la cancelación en el servidor.
-                    // Solo mostramos un mensaje y dejamos que el finally genere el reporte.
                     console.log(chalk.yellow('\n⚠️  Misión cancelada — generando reporte de evidencia...'));
                 } else {
                     missionResult = 'failed';
@@ -952,14 +999,28 @@ async function main() {
                     }
                 }
             } finally {
+                // Desactivar el bloqueo de process.exit y restaurar el original
+                _missionActive = false;
+                process.exit = _origProcessExit;
+                process.removeListener('SIGINT', cancelHandler);
+                process.removeListener('SIGTERM', cancelHandler);
+
                 if (userCanceledMission) {
                     missionResult = 'canceled';
                     finalFailReason = 'user_canceled';
                     await new Promise(r => setTimeout(r, 800));
                 }
 
+                process.on('SIGINT', postProcessSigint);
+                process.on('SIGTERM', postProcessSigint);
+
                 const sRep = spinner();
-                sRep.start('📊 Generating report...');
+                if (!process.argv.includes('--debug')) {
+                    sRep.start('📊 Generating report...');
+                } else {
+                    console.log('📊 Generating report...');
+                }
+
                 await run("node", [path.join(PROJECT_ROOT, "scripts/rebrand-report.mjs")]).catch(() => { });
 
                 const reportDir = process.env.REPORTS_DIR || 'tests-report';
@@ -997,7 +1058,13 @@ async function main() {
                     const actualBasePath = sasData?.basePath || sasData?.base_path;
 
                     if (sasData && actualSasUrl && actualBasePath) {
-                        if (!process.argv.includes('--debug')) sRep.start('☁️  Uploading evidence to Azure...');
+                        if (!process.argv.includes('--debug')) {
+                            sRep.start('☁️  Uploading evidence to Azure...');
+                        }
+                        process.removeAllListeners('SIGINT');
+                        process.removeAllListeners('SIGTERM');
+                        process.on('SIGINT', postProcessSigint);
+                        process.on('SIGTERM', postProcessSigint);
                         
                         await uploadEvidence(reportDir, actualSasUrl, actualBasePath);
                         
@@ -1060,6 +1127,10 @@ async function main() {
                 agentMode = false;
                 prompt = "";
                 firstRun = false;
+
+                // Limpiar handlers del post-proceso
+                process.removeListener('SIGINT', postProcessSigint);
+                process.removeListener('SIGTERM', postProcessSigint);
             }
         }
         firstRun = false;