@playwright-test-runner/core 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playwright-test-runner/core",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Libreria agnostica per eseguire test Playwright con server Express e UI report",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -42,6 +42,7 @@
   "files": [
     "dist",
     "public",
+    "scripts",
     "playwright.config.ts"
   ],
   "directories": {

package/scripts/postinstall.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script
+ * Avvia automaticamente il report daemon dopo l'installazione del package
+ *
+ * Controllo tramite variabili d'ambiente:
+ * - PLAYWRIGHT_SKIP_DAEMON=true        - Salta completamente l'avvio del daemon
+ * - PLAYWRIGHT_DAEMON_AUTO=false       - Non avvia il daemon automaticamente
+ * - NODE_ENV=production                - Non avvia il daemon in produzione
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Evita di eseguire durante l'installazione della libreria stessa
+const isLibraryInstall = process.cwd().includes('playwright-library') ||
+                          process.cwd().includes('@playwright-test-runner');
+
+if (isLibraryInstall) {
+  console.log('📦 Installazione della libreria in corso, skip post-install...');
+  process.exit(0);
+}
+
+// Controlli per evitare l'avvio automatico
+const skipDaemon = process.env.PLAYWRIGHT_SKIP_DAEMON === 'true';
+const daemonAuto = process.env.PLAYWRIGHT_DAEMON_AUTO !== 'false'; // Default: true
+const isProduction = process.env.NODE_ENV === 'production';
+const isCIEnvironment = process.env.CI === 'true';
+
+if (skipDaemon) {
+  console.log('⏭️  PLAYWRIGHT_SKIP_DAEMON=true - Skip avvio daemon');
+  process.exit(0);
+}
+
+if (!daemonAuto) {
+  console.log('⏭️  PLAYWRIGHT_DAEMON_AUTO=false - Avvio manuale richiesto');
+  console.log('   Usa: npx playwright-daemon\n');
+  process.exit(0);
+}
+
+if (isProduction) {
+  console.log('🚫 NODE_ENV=production - Daemon non avviato in produzione');
+  console.log('   Per avviarlo comunque: PLAYWRIGHT_DAEMON_AUTO=true npm install');
+  console.log('   Oppure manualmente: npx playwright-daemon\n');
+  process.exit(0);
+}
+
+if (isCIEnvironment) {
+  console.log('🚫 CI=true - Daemon non avviato in ambiente CI/CD');
+  console.log('   Per avviarlo comunque: PLAYWRIGHT_DAEMON_AUTO=true npm install\n');
+  process.exit(0);
+}
+
+console.log(`
+╔════════════════════════════════════════════════════════════╗
+║                                                            ║
+║   🎭 Playwright Test Runner - Post Install                ║
+║                                                            ║
+╚════════════════════════════════════════════════════════════╝
+
+📦 Package installato con successo!
+
+🚀 Avvio del Report Server in background...
+`);
+
+// Determina il percorso del daemon
+const projectRoot = process.env.INIT_CWD || process.cwd();
+const daemonBin = path.join(__dirname, '../dist/daemon-cli.js');
+
+// Verifica che il daemon esista
+if (!fs.existsSync(daemonBin)) {
+  console.log('⚠️  Daemon non trovato, skip auto-start.');
+  console.log('   Usa: npx playwright-daemon per avviarlo manualmente\n');
+  process.exit(0);
+}
+
+// Crea la cartella tests se non esiste
+const testsDir = path.join(projectRoot, 'tests');
+if (!fs.existsSync(testsDir)) {
+  console.log('📁 Creazione cartella tests...');
+  fs.mkdirSync(testsDir, { recursive: true });
+
+  // Crea un test di esempio
+  const exampleTest = `import { test, expect } from '@playwright/test';
+
+test('example test', async ({ page }) => {
+  await page.goto('https://example.com');
+  await expect(page).toHaveTitle(/Example Domain/);
+});
+`;
+
+  fs.writeFileSync(path.join(testsDir, 'example.spec.ts'), exampleTest);
+  console.log('✅ Creato file di test di esempio: tests/example.spec.ts\n');
+}
+
+// Avvia il daemon in background
+try {
+  const daemon = spawn('node', [daemonBin, '--port', '9324'], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: projectRoot,
+    env: {
+      ...process.env,
+      INIT_CWD: projectRoot,
+    }
+  });
+
+  daemon.unref(); // Permette al processo parent di uscire
+
+  console.log(`
+✅ Report Server avviato in background!
+
+📊 Report disponibile su:
+   → http://localhost:9324
+
+📋 Dashboard:
+   → http://localhost:9324/dashboard
+
+💡 Comandi disponibili:
+   • npx playwright-test        - Esegui test e mostra report
+   • npx playwright-ui          - Interfaccia web interattiva
+   • npx playwright-daemon      - Gestisci il daemon server
+
+📁 Test Directory: ${testsDir}
+
+🎯 Prossimi Passi:
+   1. Aggiungi i tuoi test nella cartella 'tests/'
+   2. Esegui: npx playwright-test
+   3. Visualizza i report su http://localhost:9324
+
+════════════════════════════════════════════════════════════
+
+`);
+
+  // Salva il PID per future gestioni
+  const pidFile = path.join(projectRoot, '.playwright-daemon.pid');
+  fs.writeFileSync(pidFile, daemon.pid.toString());
+
+} catch (error) {
+  console.error('❌ Errore durante l\'avvio del daemon:', error.message);
+  console.log('\n💡 Puoi avviarlo manualmente con: npx playwright-daemon\n');
+}

package/scripts/release.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Release Script
+ * Gestisce il versioning e la pubblicazione su npm in modo interattivo
+ */
+
+const { execSync, spawn } = require('child_process');
+const readline = require('readline');
+
+console.log(`
+╔════════════════════════════════════════════════════════════╗
+║                                                            ║
+║   🚀 Playwright Test Runner - Release Script               ║
+║                                                            ║
+╚════════════════════════════════════════════════════════════╝
+`);
+
+// Controlla lo stato git
+function checkGitStatus() {
+  try {
+    const status = execSync('git status --porcelain', { encoding: 'utf-8' });
+    return status.trim() !== '';
+  } catch (error) {
+    return false;
+  }
+}
+
+// Leggi la versione corrente
+const packageJson = require('../package.json');
+console.log(`📦 Versione corrente: ${packageJson.version}\n`);
+
+// Controlla se ci sono modifiche non committate
+const hasChanges = checkGitStatus();
+
+if (hasChanges) {
+  console.log('⚠️  Modifiche non committate rilevate!\n');
+
+  const rlGit = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  rlGit.question('Vuoi committare tutte le modifiche ora? (s/n): ', (answer) => {
+    if (answer.toLowerCase() === 's' || answer.toLowerCase() === 'y') {
+      rlGit.question('Inserisci il messaggio di commit: ', (message) => {
+        try {
+          execSync('git add .', { stdio: 'inherit' });
+          execSync(`git commit -m "${message}"`, { stdio: 'inherit' });
+          console.log('\n✅ Modifiche committate!\n');
+          rlGit.close();
+          // Piccolo delay per lasciare stdio stabilizzarsi
+          setTimeout(() => startRelease(), 100);
+        } catch (error) {
+          console.error('\n❌ Errore durante il commit:', error.message);
+          rlGit.close();
+          process.exit(1);
+        }
+      });
+    } else {
+      console.log('\n⚠️  Procedo senza creare tag git (solo aggiornamento version in package.json)\n');
+      rlGit.close();
+      setTimeout(() => startRelease(true), 100); // Skip git tag
+    }
+  });
+} else {
+  startRelease();
+}
+
+function startRelease(skipGitTag = false) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log('Seleziona il tipo di versione da rilasciare:\n');
+  console.log('  1. PATCH  - Bug fix (es: 1.0.2 → 1.0.3)');
+  console.log('  2. MINOR  - Nuova feature (es: 1.0.2 → 1.1.0)');
+  console.log('  3. MAJOR  - Breaking change (es: 1.0.2 → 2.0.0)');
+  console.log('  4. CUSTOM - Specifica versione manualmente');
+  console.log('  0. ANNULLA\n');
+
+  rl.question('La tua scelta (1-4): ', (answer) => {
+    let versionType;
+
+    switch (answer.trim()) {
+      case '1':
+        versionType = 'patch';
+        break;
+      case '2':
+        versionType = 'minor';
+        break;
+      case '3':
+        versionType = 'major';
+        break;
+      case '4':
+        rl.question('Inserisci la versione (es: 2.5.0): ', (customVersion) => {
+          rl.close();
+          setTimeout(() => executeRelease(customVersion, skipGitTag), 100);
+        });
+        return;
+      case '0':
+        console.log('\n❌ Operazione annullata\n');
+        rl.close();
+        process.exit(0);
+        return;
+      default:
+        console.log('\n❌ Scelta non valida\n');
+        rl.close();
+        process.exit(1);
+        return;
+    }
+
+    rl.close();
+    setTimeout(() => executeRelease(versionType, skipGitTag), 100);
+  });
+}
+
+function executeRelease(versionType, skipGitTag = false) {
+  try {
+    console.log('\n━'.repeat(30));
+    console.log(`\n🔄 Aggiornamento versione (${versionType})...`);
+
+    // Esegui npm version
+    const versionCommand = skipGitTag
+      ? `npm version ${versionType} --no-git-tag-version`
+      : `npm version ${versionType}`;
+
+    execSync(versionCommand, {
+      encoding: 'utf-8',
+      stdio: 'inherit',
+    });
+
+    console.log('\n✅ Versione aggiornata con successo!');
+
+    if (skipGitTag) {
+      console.log('⚠️  Tag git NON creato (modifiche non committate)');
+      console.log('💡 Ricordati di committare package.json con la nuova versione\n');
+    }
+
+    // Aspetta che stdio si stabilizzi dopo execSync
+    setTimeout(() => {
+      askForPublish(skipGitTag);
+    }, 200);
+
+  } catch (error) {
+    console.error('\n❌ Errore durante il versioning:', error.message);
+    process.exit(1);
+  }
+}
+
+function askForPublish(skipGitTag) {
+  // Chiedi conferma per la pubblicazione
+  const rlConfirm = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  rlConfirm.question('\n📤 Vuoi pubblicare su npm? (s/n): ', (publish) => {
+    const shouldPublish = publish.toLowerCase() === 's' || publish.toLowerCase() === 'y';
+
+    rlConfirm.close();
+
+    if (shouldPublish) {
+      // Usa setTimeout per lasciare che readline si chiuda completamente
+      setTimeout(() => {
+        console.log('\n━'.repeat(30));
+        console.log('\n🔐 Eseguo npm login...');
+        console.log('💡 Il browser si aprirà per l\'autenticazione');
+        console.log('   Premi ENTER quando richiesto, poi completa il login nel browser\n');
+
+        // Usa spawn invece di execSync per gestire meglio l'interattività
+        const loginProcess = spawn('npm', ['login'], {
+          stdio: 'inherit', // Passa stdin, stdout, stderr al processo padre
+        });
+
+        loginProcess.on('close', (code) => {
+          if (code !== 0) {
+            console.error('\n❌ Errore durante il login');
+            process.exit(1);
+          }
+
+          console.log('\n✅ Login completato con successo!');
+          console.log('\n🚀 Pubblicazione su npm...\n');
+
+          // Esegui npm publish
+          const publishProcess = spawn('npm', ['publish', '--access', 'public'], {
+            stdio: 'inherit',
+          });
+
+          publishProcess.on('close', (publishCode) => {
+            if (publishCode !== 0) {
+              console.error('\n❌ Errore durante la pubblicazione');
+              process.exit(1);
+            }
+
+            console.log('\n━'.repeat(30));
+            console.log('\n✅ Package pubblicato con successo su npm!');
+
+            if (!skipGitTag) {
+              console.log('\n💡 Ricordati di pushare il tag su git:');
+              console.log('   git push && git push --tags\n');
+            } else {
+              console.log('\n💡 Ricordati di committare e pushare:');
+              console.log('   git add package.json');
+              console.log('   git commit -m "Release vX.X.X"');
+              console.log('   git push\n');
+            }
+            console.log('━'.repeat(30) + '\n');
+
+            process.exit(0);
+          });
+        });
+      }, 300);
+    } else {
+      console.log('\n⏭️  Pubblicazione saltata');
+      console.log('\n💡 Per pubblicare manualmente:');
+      console.log('   npm login && npm publish --access public\n');
+      process.exit(0);
+    }
+  });
+}

package/scripts/status-daemon.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+/**
+ * Status Daemon Script
+ * Controlla lo stato del daemon server
+ */
+
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+
+const projectRoot = process.env.INIT_CWD || process.cwd();
+const pidFile = path.join(projectRoot, '.playwright-daemon.pid');
+const daemonPort = 9324;
+
+console.log('🔍 Controllo stato daemon...\n');
+
+// Controlla il file PID
+if (!fs.existsSync(pidFile)) {
+  console.log('❌ Daemon non attivo');
+  console.log('   File PID non trovato:', pidFile);
+  console.log('\n💡 Avvia il daemon con: npx playwright-daemon\n');
+  process.exit(0);
+}
+
+const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim());
+
+// Controlla se il processo è attivo
+let processRunning = false;
+try {
+  process.kill(pid, 0); // Signal 0 = controlla esistenza
+  processRunning = true;
+} catch (e) {
+  processRunning = false;
+}
+
+if (!processRunning) {
+  console.log('⚠️  Processo non più attivo (PID stale)');
+  console.log('   Rimuovo file PID obsoleto...');
+  fs.unlinkSync(pidFile);
+  console.log('\n💡 Riavvia il daemon con: npx playwright-daemon\n');
+  process.exit(0);
+}
+
+// Controlla se il server risponde
+const req = http.request(
+  {
+    hostname: 'localhost',
+    port: daemonPort,
+    path: '/health',
+    method: 'GET',
+    timeout: 2000,
+  },
+  (res) => {
+    let data = '';
+
+    res.on('data', (chunk) => {
+      data += chunk;
+    });
+
+    res.on('end', () => {
+      try {
+        const health = JSON.parse(data);
+
+        console.log('✅ Daemon ATTIVO\n');
+        console.log('📊 Informazioni:');
+        console.log(`   • PID: ${pid}`);
+        console.log(`   • Porta: ${daemonPort}`);
+        console.log(`   • Status: ${health.status}`);
+        console.log(`   • Progetto: ${health.projectRoot}`);
+        console.log(`   • Test Dir: ${health.testsDir}`);
+        console.log('\n🌐 URLs:');
+        console.log(`   • Report: http://localhost:${daemonPort}`);
+        console.log(`   • Dashboard: http://localhost:${daemonPort}/dashboard`);
+        console.log(`   • Health: http://localhost:${daemonPort}/health`);
+        console.log('\n💡 Comandi:');
+        console.log('   • npx playwright-daemon stop  - Ferma il daemon');
+        console.log('   • npx playwright-test         - Esegui test');
+        console.log('');
+
+      } catch (e) {
+        console.log('⚠️  Server risponde ma formato non valido');
+        console.log('   Response:', data);
+      }
+    });
+  }
+);
+
+req.on('error', (error) => {
+  console.log('❌ Daemon non risponde');
+  console.log(`   Processo ${pid} attivo ma server non raggiungibile sulla porta ${daemonPort}`);
+  console.log(`   Errore: ${error.message}`);
+  console.log('\n💡 Prova a:');
+  console.log('   1. Fermare il daemon: npx playwright-daemon stop');
+  console.log('   2. Riavviarlo: npx playwright-daemon\n');
+});
+
+req.on('timeout', () => {
+  req.destroy();
+  console.log('⏱️  Timeout - Il server non risponde entro 2 secondi');
+  console.log('\n💡 Il daemon potrebbe essere in fase di avvio o sovraccarico\n');
+});
+
+req.end();

package/scripts/stop-daemon.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+/**
+ * Stop Daemon Script
+ * Ferma il daemon server dei report
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const projectRoot = process.env.INIT_CWD || process.cwd();
+const pidFile = path.join(projectRoot, '.playwright-daemon.pid');
+
+if (!fs.existsSync(pidFile)) {
+  console.log('ℹ️  Nessun daemon attivo trovato');
+  console.log('   File PID non esistente:', pidFile);
+  process.exit(0);
+}
+
+try {
+  const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim());
+
+  try {
+    // Prova a killare il processo
+    process.kill(pid, 'SIGTERM');
+
+    console.log(`✅ Daemon fermato (PID: ${pid})`);
+
+    // Rimuovi il file PID
+    fs.unlinkSync(pidFile);
+
+  } catch (killError) {
+    if (killError.code === 'ESRCH') {
+      console.log(`ℹ️  Processo ${pid} non più in esecuzione`);
+      fs.unlinkSync(pidFile);
+    } else {
+      throw killError;
+    }
+  }
+
+} catch (error) {
+  console.error('❌ Errore durante la chiusura del daemon:', error.message);
+  console.log('\n💡 Prova a cercare il processo manualmente:');
+  console.log('   lsof -ti:9324 | xargs kill -9');
+  process.exit(1);
+}