librats 0.3.1

package/scripts/build-librats.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Determine platform
+const isWindows = process.platform === 'win32';
+const isMac = process.platform === 'darwin';
+const isLinux = process.platform === 'linux';
+
+// Paths
+const nodejsRoot = path.resolve(__dirname, '..');
+const projectRoot = path.resolve(__dirname, '..', '..');
+const buildDir = path.resolve(nodejsRoot, 'build-native');  // Build dir inside nodejs/
+const srcDir = path.resolve(projectRoot, 'src');
+const cmakeLists = path.resolve(projectRoot, 'CMakeLists.txt');
+
+console.log('Building librats native library...');
+console.log(`Platform: ${process.platform}`);
+console.log(`Project root: ${projectRoot}`);
+console.log(`Build directory: ${buildDir}`);
+
+// Check if CMake is installed
+try {
+    execSync('cmake --version', { stdio: 'pipe' });
+    console.log('✓ CMake found');
+} catch (error) {
+    console.error('\n❌ ERROR: CMake is not installed or not in PATH');
+    console.error('\nCMake is required to build librats.');
+    console.error('Please install CMake:');
+    if (isWindows) {
+        console.error('  - Download from: https://cmake.org/download/');
+        console.error('  - Or use: winget install Kitware.CMake');
+        console.error('  - Or use: choco install cmake');
+    } else if (isMac) {
+        console.error('  - Use Homebrew: brew install cmake');
+        console.error('  - Or download from: https://cmake.org/download/');
+    } else if (isLinux) {
+        console.error('  - Use: sudo apt install cmake');
+        console.error('  - Or: sudo yum install cmake');
+        console.error('  - Or download from: https://cmake.org/download/');
+    }
+    console.error('\nAfter installing CMake, run: npm install\n');
+    process.exit(1);
+}
+
+// Check if CMakeLists.txt exists
+if (!fs.existsSync(cmakeLists)) {
+    console.error('ERROR: CMakeLists.txt not found in project root.');
+    console.error('Make sure all source files are included in the npm package.');
+    process.exit(1);
+}
+
+// Check if src directory exists
+if (!fs.existsSync(srcDir)) {
+    console.error('ERROR: src directory not found.');
+    console.error('Make sure all source files are included in the npm package.');
+    process.exit(1);
+}
+
+// Create build directory if it doesn't exist
+if (!fs.existsSync(buildDir)) {
+    console.log(`Creating build directory: ${buildDir}`);
+    fs.mkdirSync(buildDir, { recursive: true });
+}
+
+// Helper function to execute commands
+function exec(command, options = {}) {
+    console.log(`> ${command}`);
+    try {
+        execSync(command, {
+            cwd: buildDir,
+            stdio: 'inherit',
+            ...options
+        });
+    } catch (error) {
+        console.error(`Command failed: ${command}`);
+        throw error;
+    }
+}
+
+try {
+    // Configure CMake with appropriate options
+    console.log('\nConfiguring CMake...');
+    
+    let cmakeArgs = [
+        '-DRATS_BUILD_TESTS=OFF',
+        '-DRATS_BUILD_EXAMPLES=OFF',
+        '-DRATS_STATIC_LIBRARY=ON',
+        '-DRATS_BINDINGS=ON',
+        '-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDLL'
+    ];
+
+    // Add platform-specific CMake arguments
+    if (isWindows) {
+        // Try to detect Visual Studio version
+        const vsVersions = ['2022', '2019', '2017'];
+        let generator = null;
+        
+        for (const version of vsVersions) {
+            try {
+                execSync(`where "C:\\Program Files\\Microsoft Visual Studio\\${version}"`, { stdio: 'ignore' });
+                generator = `Visual Studio ${version === '2022' ? '17' : version === '2019' ? '16' : '15'} ${version}`;
+                break;
+            } catch (e) {
+                // Try next version
+            }
+        }
+        
+        if (generator) {
+            cmakeArgs.push(`-G "${generator}"`);
+            cmakeArgs.push('-A x64');
+        }
+    } else if (isMac) {
+        // Use Unix Makefiles on macOS
+        cmakeArgs.push('-G "Unix Makefiles"');
+    } else if (isLinux) {
+        // Use Unix Makefiles on Linux
+        cmakeArgs.push('-G "Unix Makefiles"');
+    }
+
+    const cmakeConfigCmd = `cmake ${cmakeArgs.join(' ')} ../..`;
+    exec(cmakeConfigCmd);
+
+    // Build the library
+    console.log('\nBuilding librats library...');
+    
+    if (isWindows) {
+        // Build both Debug and Release configurations on Windows
+        exec('cmake --build . --config Debug --parallel');
+        exec('cmake --build . --config Release --parallel');
+        console.log('\nLibrats built successfully (Debug and Release)');
+    } else {
+        exec('cmake --build . -- -j4');
+        console.log('\nLibrats built successfully');
+    }
+
+    // Verify the library was built
+    const expectedLibPaths = isWindows 
+        ? [
+            path.join(buildDir, 'lib', 'Debug', 'rats.lib'),
+            path.join(buildDir, 'lib', 'Release', 'rats.lib')
+        ]
+        : [
+            path.join(buildDir, 'lib', 'librats.a')
+        ];
+    
+    console.log('\nBuild directory:', buildDir);
+
+    let foundLib = false;
+    for (const libPath of expectedLibPaths) {
+        if (fs.existsSync(libPath)) {
+            console.log(`✓ Found library: ${libPath}`);
+            foundLib = true;
+        }
+    }
+
+    if (!foundLib) {
+        console.warn('WARNING: Could not find built library files.');
+        console.warn('Expected paths:');
+        expectedLibPaths.forEach(p => console.warn(`  - ${p}`));
+        console.warn('The build may have failed. Check the output above.');
+        // Don't exit with error - let node-gyp try anyway
+    }
+
+    console.log('\n✓ Librats build completed successfully!\n');
+
+} catch (error) {
+    console.error('\n✗ Failed to build librats library');
+    console.error('Error:', error.message);
+    
+    // Provide helpful error messages
+    console.error('\nTroubleshooting:');
+    
+    if (isWindows) {
+        console.error('- Ensure Visual Studio Build Tools or Visual Studio is installed');
+        console.error('- Download from: https://visualstudio.microsoft.com/downloads/');
+        console.error('- Or run: npm install --global windows-build-tools');
+    } else if (isMac) {
+        console.error('- Ensure Xcode Command Line Tools are installed');
+        console.error('- Run: xcode-select --install');
+    } else if (isLinux) {
+        console.error('- Ensure build-essential is installed');
+        console.error('- Run: sudo apt install build-essential cmake');
+    }
+    
+    console.error('- Ensure CMake is installed and available in PATH');
+    console.error('- CMake download: https://cmake.org/download/');
+    
+    process.exit(1);
+}
+

package/scripts/postinstall.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Check if we're in a development install (node_modules doesn't contain librats)
+const isDev = !__dirname.includes('node_modules');
+
+if (isDev) {
+  console.log('\n✨ Development installation detected');
+  console.log('   Librats native addon has been built for local development\n');
+} else {
+  console.log('\n✅ Librats installed successfully!');
+  console.log('   Native addon is ready to use\n');
+}
+
+// Check if the addon was built successfully
+const possiblePaths = [
+  path.join(__dirname, '..', 'build', 'Release', 'librats.node'),
+  path.join(__dirname, '..', 'build', 'Debug', 'librats.node'),
+];
+
+let addonFound = false;
+for (const addonPath of possiblePaths) {
+  if (fs.existsSync(addonPath)) {
+    addonFound = true;
+    if (process.env.LIBRATS_DEBUG) {
+      console.log(`   Native addon: ${addonPath}`);
+    }
+    break;
+  }
+}
+
+if (!addonFound) {
+  console.warn('⚠️  Warning: Native addon not found');
+  console.warn('   The build may have failed. Try running:');
+  console.warn('   npm rebuild librats\n');
+}
+
+// Show quick start example
+if (!process.env.CI && !process.env.npm_config_global) {
+  console.log('Verify installation:');
+  console.log('  npm run verify\n');
+  console.log('Quick start:');
+  console.log('```javascript');
+  console.log("const { RatsClient } = require('librats');");
+  console.log('const client = new RatsClient(8080);');
+  console.log('client.start();');
+  console.log('```\n');
+  console.log('Documentation: https://github.com/librats/librats/tree/main/nodejs\n');
+}
+

package/scripts/prepare-package.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Prepare package script
+ * 
+ * This script runs before packing and publishing to ensure the package
+ * is ready for distribution. It checks that all necessary files are present.
+ */
+
+console.log('Preparing package for distribution...');
+
+const projectRoot = path.resolve(__dirname, '..', '..');
+const nodejsRoot = path.resolve(__dirname, '..');
+
+// Critical files that must be included in the package
+const criticalFiles = [
+    // Node.js binding files
+    { path: path.join(nodejsRoot, 'binding.gyp'), desc: 'Node.js binding configuration' },
+    { path: path.join(nodejsRoot, 'lib', 'index.js'), desc: 'JavaScript wrapper' },
+    { path: path.join(nodejsRoot, 'lib', 'index.d.ts'), desc: 'TypeScript definitions' },
+    { path: path.join(nodejsRoot, 'src', 'librats_node.cpp'), desc: 'Node.js binding source' },
+    { path: path.join(nodejsRoot, 'scripts', 'build-librats.js'), desc: 'Build script' },
+    { path: path.join(nodejsRoot, 'scripts', 'postinstall.js'), desc: 'Post-install script' },
+    
+    // Librats C++ library files
+    { path: path.join(projectRoot, 'CMakeLists.txt'), desc: 'CMake configuration' },
+    { path: path.join(projectRoot, 'src', 'librats.cpp'), desc: 'Librats main source' },
+    { path: path.join(projectRoot, 'src', 'librats.h'), desc: 'Librats main header' },
+    { path: path.join(projectRoot, 'src', 'librats_c.cpp'), desc: 'Librats C API' },
+    { path: path.join(projectRoot, 'src', 'librats_c.h'), desc: 'Librats C API header' },
+];
+
+let allFilesPresent = true;
+let missingFiles = [];
+
+console.log('\nChecking required files:');
+for (const file of criticalFiles) {
+    if (fs.existsSync(file.path)) {
+        console.log(`  ✓ ${file.desc}`);
+    } else {
+        console.log(`  ✗ ${file.desc} - MISSING`);
+        allFilesPresent = false;
+        missingFiles.push(file);
+    }
+}
+
+if (!allFilesPresent) {
+    console.error('\n❌ ERROR: Some required files are missing!');
+    console.error('\nMissing files:');
+    missingFiles.forEach(file => {
+        console.error(`  - ${file.path}`);
+        console.error(`    (${file.desc})`);
+    });
+    console.error('\nThe package cannot be published without these files.');
+    process.exit(1);
+}
+
+// Check that lib directory exists and has content
+const libDir = path.join(nodejsRoot, 'lib');
+if (!fs.existsSync(libDir)) {
+    console.error('\n❌ ERROR: lib directory does not exist!');
+    console.error('Create it with the JavaScript wrapper and TypeScript definitions.');
+    process.exit(1);
+}
+
+// Check that scripts directory exists
+const scriptsDir = path.join(nodejsRoot, 'scripts');
+if (!fs.existsSync(scriptsDir)) {
+    console.error('\n❌ ERROR: scripts directory does not exist!');
+    console.error('This directory is required for the build process.');
+    process.exit(1);
+}
+
+// Count source files
+const srcDir = path.join(projectRoot, 'src');
+if (fs.existsSync(srcDir)) {
+    const sourceFiles = fs.readdirSync(srcDir)
+        .filter(f => f.endsWith('.cpp') || f.endsWith('.h'));
+    console.log(`\n✓ Found ${sourceFiles.length} source files in src/`);
+}
+
+console.log('\n✅ Package is ready for distribution!\n');
+console.log('When users install this package via npm:');
+console.log('  1. The preinstall script will build the librats C++ library');
+console.log('  2. The install script will build the Node.js native addon');
+console.log('  3. The postinstall script will verify the installation');
+console.log('\nNo manual build steps are required by users!\n');
+

package/scripts/verify-installation.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Installation Verification Script
+ * 
+ * Checks if librats was installed correctly and all components are working.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('🔍 Verifying librats installation...\n');
+
+let allChecksPassed = true;
+
+// Check 1: Can we load the module?
+console.log('1. Loading librats module...');
+try {
+    const librats = require('../lib/index.js');
+    console.log('   ✅ Module loaded successfully\n');
+    
+    // Check 2: Version info
+    console.log('2. Checking version info...');
+    try {
+        const versionString = librats.getVersionString();
+        const version = librats.getVersion();
+        console.log(`   ✅ Version: ${versionString}`);
+        console.log(`   ✅ Components: ${version.major}.${version.minor}.${version.patch}.${version.build}\n`);
+    } catch (err) {
+        console.log('   ❌ Failed to get version info:', err.message);
+        allChecksPassed = false;
+    }
+    
+    // Check 3: Constants
+    console.log('3. Checking constants...');
+    try {
+        if (typeof librats.ConnectionStrategy.DIRECT_ONLY === 'number') {
+            console.log('   ✅ ConnectionStrategy constants defined');
+        }
+        if (typeof librats.ErrorCodes.SUCCESS === 'number') {
+            console.log('   ✅ ErrorCodes constants defined\n');
+        }
+    } catch (err) {
+        console.log('   ❌ Constants check failed:', err.message);
+        allChecksPassed = false;
+    }
+    
+    // Check 4: Can we create a client?
+    console.log('4. Testing client creation...');
+    try {
+        const RatsClient = librats.RatsClient;
+        const testPort = 19999;
+        const client = new RatsClient(testPort);
+        console.log('   ✅ Client created successfully\n');
+        
+        // Check 5: Can we start and stop?
+        console.log('5. Testing start/stop...');
+        try {
+            const started = client.start();
+            if (started) {
+                console.log('   ✅ Client started successfully');
+                
+                const peerId = client.getOurPeerId();
+                if (peerId && typeof peerId === 'string') {
+                    console.log(`   ✅ Got peer ID: ${peerId}`);
+                }
+                
+                const peerCount = client.getPeerCount();
+                console.log(`   ✅ Peer count: ${peerCount}`);
+                
+                client.stop();
+                console.log('   ✅ Client stopped successfully\n');
+            } else {
+                console.log('   ⚠️  Warning: Client failed to start (port may be in use)\n');
+            }
+        } catch (err) {
+            console.log('   ❌ Start/stop test failed:', err.message);
+            allChecksPassed = false;
+        }
+    } catch (err) {
+        console.log('   ❌ Client creation failed:', err.message);
+        allChecksPassed = false;
+    }
+    
+    // Check 6: TypeScript definitions
+    console.log('6. Checking TypeScript definitions...');
+    const tsDefsPath = path.join(__dirname, '..', 'lib', 'index.d.ts');
+    if (fs.existsSync(tsDefsPath)) {
+        console.log('   ✅ TypeScript definitions found\n');
+    } else {
+        console.log('   ⚠️  Warning: TypeScript definitions not found\n');
+    }
+    
+} catch (err) {
+    console.log('   ❌ Failed to load module:', err.message);
+    console.log('\nError details:');
+    console.log(err.stack);
+    allChecksPassed = false;
+}
+
+// Summary
+console.log('━'.repeat(60));
+if (allChecksPassed) {
+    console.log('✅ All checks passed! Librats is installed correctly.\n');
+    console.log('You can now use librats in your project:');
+    console.log("  const { RatsClient } = require('librats');");
+    console.log('  const client = new RatsClient(8080);');
+    console.log('  client.start();\n');
+    process.exit(0);
+} else {
+    console.log('❌ Some checks failed. Installation may be incomplete.\n');
+    console.log('Troubleshooting:');
+    console.log('  1. Try rebuilding: npm rebuild librats');
+    console.log('  2. Check build tools are installed (CMake, C++ compiler)');
+    console.log('  3. Check the logs above for specific errors');
+    console.log('  4. See: https://github.com/librats/librats/tree/main/nodejs\n');
+    process.exit(1);
+}
+