nwinread 1.1.1 → 1.2.0

package/package.json

@@ -1,32 +1,59 @@
 {
   "name": "nwinread",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "main": "index.js",
   "scripts": {
     "build": "node-gyp configure && node-gyp build",
     "rebuild": "node-gyp rebuild",
     "clean": "node-gyp clean",
-    "test": "node test.js",
+    "test": "npm run example:sync && npm run example:async",
+    "example:sync": "node test/example_sync.js",
+    "example:async": "node test/example_async.js",
+    "example:resumable": "node test/example_resumable.js",
+    "example:async-only": "node test/example_async_only.js",
+    "test:recovery": "node test/test_recovery.js",
+    "test:performance": "node test/performance_comparison.js",
+    "demo:cpu": "node cpu_demo.js",
+    "examples": "npm run example:sync && npm run example:async",
     "prebuildify": "prebuildify --napi --strip",
     "prebuildify-cross": "prebuildify-cross",
     "prebuild": "npm run prebuildify",
+    "prebuild-advanced": "node scripts/generate-prebuilds-advanced.js",
+    "prebuild-all": "cross-env BUILD_ALL=1 node scripts/generate-prebuilds-advanced.js",
     "verify": "node scripts/verify-setup.js",
-    "prepublishOnly": "npm run prebuild",
-    "install": "node-gyp-build"
+    "prepublishOnly": "npm run prebuild-advanced",
+    "install": "node-gyp-build-optional-packages || npm run rebuild"
   },
   "author": "solzimer",
   "license": "MIT",
-  "description": "Native Windows Event Log Reader for Node.js",
+  "description": "High-performance native Node.js module for reading Windows event logs with real-time monitoring and watermark support",
   "repository": {
     "type": "git",
     "url": "https://github.com/solzimer/nwinread.git"
   },
+  "bugs": {
+    "url": "https://github.com/solzimer/nwinread/issues"
+  },
+  "homepage": "https://github.com/solzimer/nwinread#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
   "keywords": [
     "windows",
     "event-log",
+    "eventlog",
     "native",
     "wevtapi",
-    "napi"
+    "napi",
+    "monitoring",
+    "real-time",
+    "windows-api",
+    "system-monitoring",
+    "log-reader",
+    "event-monitoring",
+    "security-log",
+    "application-log",
+    "system-log"
   ],
   "devDependencies": {
     "node-gyp": "^10.0.0",

package/prebuilds/metadata.json

@@ -0,0 +1,24 @@
+{
+  "name": "nwinread",
+  "version": "1.2.0",
+  "generated": "2026-04-10T08:10:15.887Z",
+  "prebuilds": [
+    {
+      "platform": "win32-x64",
+      "files": [
+        {
+          "name": "eventlog.node",
+          "size": 183296
+        },
+        {
+          "name": "eventlogasync.node",
+          "size": 200192
+        },
+        {
+          "name": "nwinread.node",
+          "size": 183296
+        }
+      ]
+    }
+  ]
+}

package/prebuilds/win32-x64/meta.json

@@ -0,0 +1,20 @@
+{
+  "generated": "2026-04-06T19:11:15.296Z",
+  "platform": "win32",
+  "arch": "x64",
+  "nodeVersion": "v22.17.0",
+  "targets": [
+    {
+      "name": "EventLog (Síncrono)",
+      "file": "eventlog.node",
+      "exists": true,
+      "size": 183296
+    },
+    {
+      "name": "EventLogAsync (Asíncrono)",
+      "file": "eventlogasync.node",
+      "exists": true,
+      "size": 198144
+    }
+  ]
+}

package/scripts/generate-prebuilds-advanced.js

@@ -0,0 +1,186 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Script avanzado para generar prebuilds multiplataforma
+console.log('=== Generador de Prebuilds Avanzado ===\n');
+
+const projectRoot = process.cwd();
+const basePrebuildsDir = path.join(projectRoot, 'prebuilds');
+
+// Configuraciones de build
+const buildConfigs = [
+    { platform: 'win32', arch: 'x64', supported: true },
+    { platform: 'win32', arch: 'ia32', supported: false }, // Opcional
+];
+
+// Versiones de Node a soportar (solo las NAPI versions)
+const napiVersions = [3, 4, 5, 6, 7, 8, 9];
+
+console.log('Configuraciones de build:');
+buildConfigs.forEach(config => {
+    console.log(`  - ${config.platform}-${config.arch}: ${config.supported ? '✓' : '⚠️  (opcional)'}`);
+});
+
+console.log(`\nVersiones NAPI a soportar: ${napiVersions.join(', ')}\n`);
+
+function generatePrebuildsForPlatform(platform, arch) {
+    const prebuildsDir = path.join(basePrebuildsDir, `${platform}-${arch}`);
+    
+    if (!fs.existsSync(prebuildsDir)) {
+        fs.mkdirSync(prebuildsDir, { recursive: true });
+    }
+    
+    console.log(`📦 Generando prebuilds para ${platform}-${arch}...`);
+    
+    // Para Windows, copiamos los archivos ya compilados
+    if (platform === 'win32' && process.platform === 'win32') {
+        const buildDir = path.join(projectRoot, 'build', 'Release');
+        const targets = ['eventlog', 'eventlogasync'];
+        
+        targets.forEach(target => {
+            const sourcePath = path.join(buildDir, `${target}.node`);
+            const targetPath = path.join(prebuildsDir, `${target}.node`);
+            
+            if (fs.existsSync(sourcePath)) {
+                fs.copyFileSync(sourcePath, targetPath);
+                const stats = fs.statSync(targetPath);
+                console.log(`  ✓ ${target}.node (${Math.round(stats.size / 1024)} KB)`);
+            } else {
+                console.log(`  ❌ ${target}.node (archivo fuente no encontrado)`);
+            }
+        });
+    }
+    
+    return prebuildsDir;
+}
+
+function createPackageMetadata() {
+    const metadata = {
+        name: require('../package.json').name,
+        version: require('../package.json').version,
+        generated: new Date().toISOString(),
+        prebuilds: []
+    };
+    
+    // Escanear directorio prebuilds
+    if (fs.existsSync(basePrebuildsDir)) {
+        const platforms = fs.readdirSync(basePrebuildsDir);
+        
+        platforms.forEach(platformDir => {
+            const fullPath = path.join(basePrebuildsDir, platformDir);
+            if (fs.statSync(fullPath).isDirectory()) {
+                const files = fs.readdirSync(fullPath);
+                const nodeFiles = files.filter(f => f.endsWith('.node'));
+                
+                if (nodeFiles.length > 0) {
+                    metadata.prebuilds.push({
+                        platform: platformDir,
+                        files: nodeFiles.map(f => ({
+                            name: f,
+                            size: fs.statSync(path.join(fullPath, f)).size
+                        }))
+                    });
+                }
+            }
+        });
+    }
+    
+    const metadataPath = path.join(basePrebuildsDir, 'metadata.json');
+    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+    console.log(`\n✓ Metadata guardada: ${metadataPath}`);
+    
+    return metadata;
+}
+
+function validatePrebuilds() {
+    console.log('\n=== Validación de Prebuilds ===');
+    
+    const requiredModules = ['eventlog', 'eventlogasync'];
+    let totalSize = 0;
+    let platformCount = 0;
+    
+    if (!fs.existsSync(basePrebuildsDir)) {
+        console.log('❌ Directorio prebuilds no existe');
+        return false;
+    }
+    
+    const platforms = fs.readdirSync(basePrebuildsDir).filter(d => 
+        fs.statSync(path.join(basePrebuildsDir, d)).isDirectory()
+    );
+    
+    platforms.forEach(platform => {
+        console.log(`\n📁 Plataforma: ${platform}`);
+        const platformDir = path.join(basePrebuildsDir, platform);
+        const files = fs.readdirSync(platformDir);
+        
+        requiredModules.forEach(module => {
+            const moduleFile = `${module}.node`;
+            if (files.includes(moduleFile)) {
+                const filePath = path.join(platformDir, moduleFile);
+                const size = fs.statSync(filePath).size;
+                totalSize += size;
+                console.log(`  ✓ ${moduleFile} (${Math.round(size / 1024)} KB)`);
+            } else {
+                console.log(`  ❌ ${moduleFile} (faltante)`);
+            }
+        });
+        
+        platformCount++;
+    });
+    
+    console.log(`\n📊 Resumen:`);
+    console.log(`  - Plataformas: ${platformCount}`);
+    console.log(`  - Tamaño total: ${Math.round(totalSize / 1024)} KB`);
+    console.log(`  - Archivos por plataforma: ${requiredModules.length}`);
+    
+    return platformCount > 0;
+}
+
+// Main execution
+async function main() {
+    try {
+        // Verificar que existan builds locales
+        const buildDir = path.join(projectRoot, 'build', 'Release');
+        if (!fs.existsSync(buildDir)) {
+            console.log('❌ No hay builds locales. Ejecute: npm run rebuild');
+            process.exit(1);
+        }
+        
+        // Generar prebuilds para plataformas soportadas
+        buildConfigs.forEach(config => {
+            if (config.supported || process.env.BUILD_ALL) {
+                generatePrebuildsForPlatform(config.platform, config.arch);
+            } else {
+                console.log(`⏭️  Omitiendo ${config.platform}-${config.arch} (opcional)`);
+            }
+        });
+        
+        // Crear metadata
+        const metadata = createPackageMetadata();
+        
+        // Validar resultados
+        const success = validatePrebuilds();
+        
+        if (success) {
+            console.log('\n🎉 Prebuilds generados exitosamente!');
+            console.log(`📁 Ubicación: ${basePrebuildsDir}`);
+            
+            // Sugerencias para distribución
+            console.log('\n💡 Para distribución:');
+            console.log('  - Los prebuilds se incluirán automáticamente en npm pack');
+            console.log('  - Los usuarios no necesitarán compilar (si hay prebuild compatible)');
+            console.log('  - Para builds adicionales: BUILD_ALL=1 node scripts/generate-prebuilds-advanced.js');
+            
+        } else {
+            console.log('\n❌ Error en generación de prebuilds');
+            process.exit(1);
+        }
+        
+    } catch (error) {
+        console.error('\n❌ Error:', error.message);
+        process.exit(1);
+    }
+}
+
+main();

package/scripts/generate-prebuilds.js

@@ -0,0 +1,86 @@
+const fs = require('fs');
+const path = require('path');
+
+// Script para generar prebuilds manuales para ambos targets
+console.log('=== Generador de Prebuilds Personalizado ===\n');
+
+const projectRoot = path.dirname(__dirname); // Directorio padre de scripts
+const buildDir = path.join(projectRoot, 'build', 'Release');
+const prebuildsDir = path.join(projectRoot, 'prebuilds', 'win32-x64');
+
+console.log(`Directorio del proyecto: ${projectRoot}`);
+console.log(`Directorio de build: ${buildDir}`);
+console.log(`Directorio de prebuilds: ${prebuildsDir}\n`);
+
+// Crear directorio de prebuilds si no existe
+if (!fs.existsSync(prebuildsDir)) {
+    fs.mkdirSync(prebuildsDir, { recursive: true });
+    console.log('✓ Directorio prebuilds creado');
+}
+
+// Lista de archivos a copiar
+const targets = [
+    {
+        source: path.join(buildDir, 'eventlog.node'),
+        target: path.join(prebuildsDir, 'eventlog.node'),
+        name: 'EventLog (Síncrono)'
+    },
+    {
+        source: path.join(buildDir, 'eventlogasync.node'),
+        target: path.join(prebuildsDir, 'eventlogasync.node'),
+        name: 'EventLogAsync (Asíncrono)'
+    }
+];
+
+console.log('Copiando archivos compilados...');
+
+targets.forEach(({ source, target, name }) => {
+    try {
+        if (fs.existsSync(source)) {
+            fs.copyFileSync(source, target);
+            
+            const stats = fs.statSync(target);
+            const sizeKB = Math.round(stats.size / 1024);
+            
+            console.log(`✓ ${name}: ${path.basename(target)} (${sizeKB} KB)`);
+        } else {
+            console.error(`❌ Archivo fuente no encontrado: ${source}`);
+        }
+    } catch (err) {
+        console.error(`❌ Error copiando ${name}:`, err.message);
+    }
+});
+
+// Verificar archivos generados
+console.log('\n=== Verificación de Prebuilds ===');
+
+const prebuildsFiles = fs.readdirSync(prebuildsDir);
+console.log(`Archivos en prebuilds/win32-x64:`);
+
+prebuildsFiles.forEach(file => {
+    const filePath = path.join(prebuildsDir, file);
+    const stats = fs.statSync(filePath);
+    const sizeKB = Math.round(stats.size / 1024);
+    console.log(`  - ${file} (${sizeKB} KB)`);
+});
+
+// Crear meta archivo con información
+const metaInfo = {
+    generated: new Date().toISOString(),
+    platform: process.platform,
+    arch: process.arch,
+    nodeVersion: process.version,
+    targets: targets.map(t => ({
+        name: t.name,
+        file: path.basename(t.target),
+        exists: fs.existsSync(t.target),
+        size: fs.existsSync(t.target) ? fs.statSync(t.target).size : 0
+    }))
+};
+
+const metaPath = path.join(prebuildsDir, 'meta.json');
+fs.writeFileSync(metaPath, JSON.stringify(metaInfo, null, 2));
+console.log(`✓ Meta información guardada: meta.json`);
+
+console.log('\n🎉 Prebuilds generados exitosamente!');
+console.log(`📁 Ubicación: ${prebuildsDir}`);

package/scripts/prebuilds/win32-x64/meta.json

@@ -0,0 +1,20 @@
+{
+  "generated": "2026-04-06T19:10:31.551Z",
+  "platform": "win32",
+  "arch": "x64",
+  "nodeVersion": "v22.17.0",
+  "targets": [
+    {
+      "name": "EventLog (Síncrono)",
+      "file": "eventlog.node",
+      "exists": false,
+      "size": 0
+    },
+    {
+      "name": "EventLogAsync (Asíncrono)",
+      "file": "eventlogasync.node",
+      "exists": false,
+      "size": 0
+    }
+  ]
+}

package/test/README.md

@@ -0,0 +1,105 @@
+# nwinread - Ejemplos de Uso
+
+Esta carpeta contiene ejemplos simples para usar nwinread.
+
+## 📋 Archivos Disponibles
+
+- **example_sync.js** - Ejemplo síncrono (consultas puntuales)
+- **example_async.js** - Ejemplo asíncrono (suscripciones en tiempo real)
+
+## 🚀 Uso
+
+### Ejemplo Síncrono (Consultas Puntuales)
+
+```bash
+# Sintaxis
+node example_sync.js <canal> <modo> [watermark] [maxEvents]
+
+# Parámetros
+#   canal      : System, Application, Security, etc.
+#   modo       : 0=BEGINNING, 1=END, 2=WATERMARK
+#   watermark  : Record ID inicial (para modo WATERMARK)
+#   maxEvents  : Máximo número de eventos (default: 5)
+
+# Ejemplos
+node example_sync.js System 1 0 5        # Últimos 5 eventos del sistema
+node example_sync.js Application 0 0 3   # Primeros 3 eventos de aplicación  
+node example_sync.js System 2 50000 2    # 2 eventos desde Record ID 50000
+```
+
+### Ejemplo Asíncrono (Tiempo Real)
+
+```bash
+# Sintaxis
+node example_async.js <canal> <modo> [watermark] [eventIds]
+
+# Parámetros
+#   canal      : System, Application, Security, etc.
+#   modo       : 0=BEGINNING, 1=END, 2=WATERMARK
+#   watermark  : Record ID inicial (para modo WATERMARK, o 0 para otros)
+#   eventIds   : IDs de evento separados por coma (opcional)
+
+# Ejemplos
+node example_async.js System 1 0             # Eventos futuros del sistema
+node example_async.js Application 0 0        # Todos los eventos de aplicación
+node example_async.js System 2 50000         # Desde Record ID 50000
+node example_async.js System 1 0 1074,6005   # Solo eventos de shutdown/startup
+```
+
+## 📚 Modos Disponibles
+
+| Modo | Nombre | Descripción |
+|------|--------|-------------|
+| `0` | **BEGINNING** | Lee desde los eventos más antiguos disponibles |
+| `1` | **END** | Lee desde los eventos más recientes (o solo futuros en async) |
+| `2` | **WATERMARK** | Lee desde un Record ID específico |
+
+## 🏷️ Canales Comunes
+
+| Canal | Descripción | Admin Requerido |
+|-------|-------------|-----------------|
+| `System` | Eventos del sistema, hardware, drivers | No |
+| `Application` | Eventos de aplicaciones, errores | No |
+| `Security` | Logins, logouts, control de acceso | **Sí** |
+| `Setup` | Instalación de Windows, actualizaciones | No |
+
+## 🎯 Event IDs Útiles
+
+### System Events
+- `1074` - Sistema apagado
+- `6005` - Servicio Event Log iniciado
+- `6006` - Servicio Event Log detenido
+- `41` - Apagado inesperado
+
+### Application Events  
+- `1000` - Error de aplicación
+- `1001` - Warning de aplicación
+- `1002` - Información de aplicación
+
+### Security Events (requiere admin)
+- `4624` - Login exitoso
+- `4625` - Login fallido  
+- `4634` - Logout
+
+## 💡 Ejemplos Prácticos
+
+```bash
+# Monitorear shutdowns del sistema
+node example_async.js System 1 0 1074
+
+# Ver errores de aplicación en tiempo real
+node example_async.js Application 1 0 1000,1001
+
+# Analizar eventos históricos del sistema
+node example_sync.js System 0 0 50
+
+# Monitorear logins (requiere admin)
+node example_async.js Security 1 0 4624,4625,4634
+```
+
+## ⚠️ Notas Importantes
+
+- Algunos canales como `Security` requieren permisos de administrador
+- El modo asíncrono se ejecuta hasta que presiones `Ctrl+C`
+- Los Event IDs son opcionales y permiten filtrar tipos específicos de eventos
+- Use `Ctrl+C` para terminar las suscripciones asíncronas

package/test/example_async.js

@@ -0,0 +1,107 @@
+// Ejemplo de uso de nwinread - API Asíncrona (Suscripciones en Tiempo Real)
+// Uso: node example_async.js <canal> <modo> [watermark] [eventIds]
+// Modos: 0=BEGINNING, 1=END, 2=WATERMARK  
+// Ejemplo: node example_async.js System 1 0 1074,6005
+
+const eventLog = require('../index.js');
+
+// Obtener argumentos de línea de comandos
+const args = process.argv.slice(2);
+
+if (args.length < 2) {
+    console.log('Uso: node example_async.js <canal> <modo> [watermark] [eventIds]');
+    console.log('');
+    console.log('Parámetros:');
+    console.log('  canal      : System, Application, Security, etc.');
+    console.log('  modo       : 0=BEGINNING, 1=END, 2=WATERMARK');
+    console.log('  watermark  : Record ID inicial (para modo WATERMARK, o 0 para otros)');
+    console.log('  eventIds   : IDs de evento separados por coma (opcional)');
+    console.log('');
+    console.log('Ejemplos:');
+    console.log('  node example_async.js System 1 0         # Eventos futuros del sistema');
+    console.log('  node example_async.js Application 0 0    # Todos los eventos de aplicación');
+    console.log('  node example_async.js System 2 50000     # Desde Record ID 50000');
+    console.log('  node example_async.js System 1 0 1074,6005  # Solo eventos de shutdown/startup');
+    process.exit(1);
+}
+
+const channel = args[0];
+const mode = parseInt(args[1]);
+const watermark = args[2] ? parseInt(args[2]) : 0;
+const eventIds = args[3] ? args[3].split(',').map(id => parseInt(id.trim())) : null;
+
+// Validar modo
+if (![0, 1, 2].includes(mode)) {
+    console.error('❌ Error: Modo debe ser 0 (BEGINNING), 1 (END), o 2 (WATERMARK)');
+    process.exit(1);
+}
+
+const mode_names = {
+    0: 'BEGINNING (todos los eventos históricos + futuros)',
+    1: 'END (solo eventos futuros)',
+    2: 'WATERMARK (desde Record ID específico + futuros)'
+};
+
+console.log('=== nwinread: Ejemplo Asíncrono ===');
+console.log(`Canal: ${channel}`);
+console.log(`Modo: ${mode} - ${mode_names[mode]}`);
+console.log(`Watermark: ${watermark}`);
+console.log(`Event IDs filter: ${eventIds ? eventIds.join(', ') : 'Ninguno (todos)'}`);
+console.log('');
+console.log('⏳ Iniciando suscripción...');
+console.log('   Presiona Ctrl+C para salir');
+console.log('');
+
+let eventCount = 0;
+let subscription;
+
+const onEvent = (event) => {
+    eventCount++;
+    console.log(`📧 Evento #${eventCount}:`);
+    console.log(`   Record ID: ${event.recordId}`);
+    console.log(`   Event ID: ${event.eventId || 'N/A'}`);
+    console.log(`   Timestamp: ${new Date().toLocaleTimeString()}`);
+    console.log(`   XML (preview): ${event.xml.substring(0, 100)}...`);
+    console.log('');
+};
+
+const onError = (error) => {
+    console.error(`❌ Error en suscripción: ${error.message}`);
+    if (error.message.includes('access') || error.message.includes('denied')) {
+        console.log('💡 Intenta con permisos de administrador para canales como "Security"');
+    }
+};
+
+try {
+    // Crear suscripción según el modo especificado
+    if (mode === 0) {
+        // BEGINNING: todos los eventos históricos + futuros
+        subscription = eventLog.subscribeFromBeginning(channel, onEvent, onError, eventIds);
+    } else if (mode === 1) {
+        // END: solo eventos futuros  
+        subscription = eventLog.subscribeFromEnd(channel, onEvent, onError, eventIds);
+    } else if (mode === 2) {
+        // WATERMARK: desde Record ID específico
+        subscription = eventLog.subscribeFromWatermark(channel, watermark, onEvent, onError, eventIds);
+    }
+
+    console.log(`✅ Suscripción activa - ID: ${subscription.id}`);
+    console.log(`   Canal: ${subscription.channel}`);
+    console.log(`   Modo: ${subscription.mode}`);
+    console.log('');
+    
+} catch (error) {
+    console.error(`❌ Error al crear suscripción: ${error.message}`);
+    process.exit(1);
+}
+
+// Cleanup cuando se termine el proceso
+process.on('SIGINT', () => {
+    console.log('\n🛑 Cerrando suscripción...');
+    if (subscription && subscription.isActive()) {
+        subscription.unsubscribe();
+    }
+    console.log(`✅ Eventos procesados: ${eventCount}`);
+    console.log('👋 ¡Hasta luego!');
+    process.exit(0);
+});