librats 0.5.0 → 0.5.2

package/scripts/prepare-package.js

@@ -7,36 +7,156 @@ 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.
+ * is ready for distribution. It copies the native C++ source files into
+ * the nodejs package directory so they can be included in the npm package.
  */
 
 console.log('Preparing package for distribution...');
 
 const projectRoot = path.resolve(__dirname, '..', '..');
 const nodejsRoot = path.resolve(__dirname, '..');
+const nativeSrcDir = path.join(nodejsRoot, 'native-src');
 
-// Critical files that must be included in the package
+// Helper function to copy a file
+function copyFile(src, dest) {
+    const destDir = path.dirname(dest);
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    fs.copyFileSync(src, dest);
+}
+
+// Helper function to copy a directory recursively
+function copyDir(src, dest, filter = () => true) {
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath, filter);
+        } else if (filter(entry.name)) {
+            copyFile(srcPath, destPath);
+        }
+    }
+}
+
+// Check that we're in the project root with the source files
+if (!fs.existsSync(path.join(projectRoot, 'CMakeLists.txt'))) {
+    console.error('\n❌ ERROR: Cannot find CMakeLists.txt in project root.');
+    console.error('This script must be run from within the librats repository.');
+    console.error(`Expected project root: ${projectRoot}`);
+    process.exit(1);
+}
+
+if (!fs.existsSync(path.join(projectRoot, 'src'))) {
+    console.error('\n❌ ERROR: Cannot find src/ directory in project root.');
+    console.error('This script must be run from within the librats repository.');
+    process.exit(1);
+}
+
+// Clean up existing native-src directory
+if (fs.existsSync(nativeSrcDir)) {
+    console.log('Cleaning existing native-src directory...');
+    fs.rmSync(nativeSrcDir, { recursive: true, force: true });
+}
+
+console.log('\nCopying native source files to native-src/...');
+
+// Create native-src directory
+fs.mkdirSync(nativeSrcDir, { recursive: true });
+
+// Copy CMakeLists.txt
+console.log('  Copying CMakeLists.txt...');
+copyFile(
+    path.join(projectRoot, 'CMakeLists.txt'),
+    path.join(nativeSrcDir, 'CMakeLists.txt')
+);
+
+// Copy LICENSE
+if (fs.existsSync(path.join(projectRoot, 'LICENSE'))) {
+    console.log('  Copying LICENSE...');
+    copyFile(
+        path.join(projectRoot, 'LICENSE'),
+        path.join(nativeSrcDir, 'LICENSE')
+    );
+}
+
+// Copy version.rc.in
+if (fs.existsSync(path.join(projectRoot, 'version.rc.in'))) {
+    console.log('  Copying version.rc.in...');
+    copyFile(
+        path.join(projectRoot, 'version.rc.in'),
+        path.join(nativeSrcDir, 'version.rc.in')
+    );
+}
+
+// Copy src/ directory (only .cpp, .h, .hpp, .in files, excluding main.cpp)
+console.log('  Copying src/ directory...');
+const srcFilter = (name) => {
+    if (name === 'main.cpp') return false;
+    return name.endsWith('.cpp') || name.endsWith('.h') || 
+           name.endsWith('.hpp') || name.endsWith('.in');
+};
+copyDir(
+    path.join(projectRoot, 'src'),
+    path.join(nativeSrcDir, 'src'),
+    srcFilter
+);
+
+// Copy 3rdparty/ directory
+if (fs.existsSync(path.join(projectRoot, '3rdparty'))) {
+    console.log('  Copying 3rdparty/ directory...');
+    copyDir(
+        path.join(projectRoot, '3rdparty'),
+        path.join(nativeSrcDir, '3rdparty')
+    );
+}
+
+// Count copied files
+let cppCount = 0;
+let hCount = 0;
+const countFiles = (dir) => {
+    if (!fs.existsSync(dir)) return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            countFiles(fullPath);
+        } else if (entry.name.endsWith('.cpp')) {
+            cppCount++;
+        } else if (entry.name.endsWith('.h') || entry.name.endsWith('.hpp')) {
+            hCount++;
+        }
+    }
+};
+countFiles(nativeSrcDir);
+
+console.log(`\n✓ Copied ${cppCount} source files and ${hCount} header files`);
+
+// Verify critical files in nodejs 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' },
+    { path: path.join(nativeSrcDir, 'CMakeLists.txt'), desc: 'CMake configuration (copied)' },
+    { path: path.join(nativeSrcDir, 'src', 'librats.cpp'), desc: 'Librats main source (copied)' },
+    { path: path.join(nativeSrcDir, 'src', 'librats.h'), desc: 'Librats main header (copied)' },
+    { path: path.join(nativeSrcDir, 'src', 'librats_c.cpp'), desc: 'Librats C API (copied)' },
+    { path: path.join(nativeSrcDir, 'src', 'librats_c.h'), desc: 'Librats C API header (copied)' },
 ];
 
 let allFilesPresent = true;
 let missingFiles = [];
 
-console.log('\nChecking required files:');
+console.log('\nVerifying required files:');
 for (const file of criticalFiles) {
     if (fs.existsSync(file.path)) {
         console.log(`  ✓ ${file.desc}`);
@@ -58,34 +178,10 @@ if (!allFilesPresent) {
     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('The native-src/ directory now contains all C++ source files needed to build.');
+console.log('\nWhen 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/src/librats_node.cpp

@@ -473,7 +473,52 @@ private:
         std::string content_hash = info[0].As<Napi::String>().Utf8Value();
         int port = info[1].As<Napi::Number>().Int32Value();
         
-        rats_error_t result = rats_announce_for_hash(client_, content_hash.c_str(), port);
+        // Check if optional callback is provided
+        rats_peers_found_cb c_callback = nullptr;
+        void* callback_user_data = nullptr;
+        Napi::ThreadSafeFunction* tsfn_ptr = nullptr;
+        
+        if (info.Length() >= 3 && info[2].IsFunction()) {
+            // Create thread-safe function for callback
+            auto tsfn = new Napi::ThreadSafeFunction();
+            *tsfn = Napi::ThreadSafeFunction::New(
+                env,
+                info[2].As<Napi::Function>(),
+                "AnnounceForHashCallback",
+                0,
+                1,
+                [](Napi::Env) {} // Release callback
+            );
+            tsfn_ptr = tsfn;
+            
+            c_callback = [](void* user_data, const char** peer_addresses, int count) {
+                auto* tsfn = static_cast<Napi::ThreadSafeFunction*>(user_data);
+                if (!tsfn) return;
+                
+                // Copy peer addresses for async callback
+                std::vector<std::string>* peers = new std::vector<std::string>();
+                for (int i = 0; i < count; i++) {
+                    if (peer_addresses[i]) {
+                        peers->push_back(peer_addresses[i]);
+                    }
+                }
+                
+                tsfn->BlockingCall(peers, [](Napi::Env env, Napi::Function jsCallback, std::vector<std::string>* data) {
+                    Napi::Array arr = Napi::Array::New(env, data->size());
+                    for (size_t i = 0; i < data->size(); i++) {
+                        arr.Set(static_cast<uint32_t>(i), Napi::String::New(env, (*data)[i]));
+                    }
+                    jsCallback.Call({arr});
+                    delete data;
+                });
+                
+                tsfn->Release();
+                delete tsfn;
+            };
+            callback_user_data = tsfn_ptr;
+        }
+        
+        rats_error_t result = rats_announce_for_hash(client_, content_hash.c_str(), port, c_callback, callback_user_data);
         return Napi::Boolean::New(env, result == RATS_SUCCESS);
     }