librats 0.7.2 → 0.9.0

package/native-src/src/librats_file_transfer.cpp

@@ -1,15 +1,11 @@
 #include "librats.h"
-// Logging macros for RatsClient
-#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", message)
-#define LOG_CLIENT_INFO(message)  LOG_INFO("client", message)
-#define LOG_CLIENT_WARN(message)  LOG_WARN("client", message)
-#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", message)
+#include "librats_log_macros.h"
 
 namespace librats {
 
-//=============================================================================
-// File Transfer API Implementation
-//=============================================================================
+// =============================================================================
+// File transfer API - thin forwarding layer over FileTransferManager
+// =============================================================================
 
 FileTransferManager& RatsClient::get_file_transfer_manager() {
     if (!file_transfer_manager_) {
@@ -22,24 +18,22 @@ bool RatsClient::is_file_transfer_available() const {
     return file_transfer_manager_ != nullptr;
 }
 
-std::string RatsClient::send_file(const std::string& peer_id, const std::string& file_path, 
-                                 const std::string& remote_filename) {
+std::string RatsClient::send_file(const std::string& peer_id, const std::string& file_path,
+                                  const std::string& remote_filename) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return "";
     }
-    
     return file_transfer_manager_->send_file(peer_id, file_path, remote_filename);
 }
 
 std::string RatsClient::send_directory(const std::string& peer_id, const std::string& directory_path,
-                                      const std::string& remote_directory_name, bool recursive) {
+                                       const std::string& remote_name) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return "";
     }
-    
-    return file_transfer_manager_->send_directory(peer_id, directory_path, remote_directory_name, recursive);
+    return file_transfer_manager_->send_directory(peer_id, directory_path, remote_name);
 }
 
 bool RatsClient::accept_file_transfer(const std::string& transfer_id, const std::string& local_path) {
@@ -47,8 +41,7 @@ bool RatsClient::accept_file_transfer(const std::string& transfer_id, const std:
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->accept_file_transfer(transfer_id, local_path);
+    return file_transfer_manager_->accept(transfer_id, local_path);
 }
 
 bool RatsClient::reject_file_transfer(const std::string& transfer_id, const std::string& reason) {
@@ -56,26 +49,7 @@ bool RatsClient::reject_file_transfer(const std::string& transfer_id, const std:
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->reject_file_transfer(transfer_id, reason);
-}
-
-bool RatsClient::accept_directory_transfer(const std::string& transfer_id, const std::string& local_path) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return false;
-    }
-    
-    return file_transfer_manager_->accept_directory_transfer(transfer_id, local_path);
-}
-
-bool RatsClient::reject_directory_transfer(const std::string& transfer_id, const std::string& reason) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return false;
-    }
-    
-    return file_transfer_manager_->reject_directory_transfer(transfer_id, reason);
+    return file_transfer_manager_->reject(transfer_id, reason);
 }
 
 bool RatsClient::pause_file_transfer(const std::string& transfer_id) {
@@ -83,8 +57,7 @@ bool RatsClient::pause_file_transfer(const std::string& transfer_id) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->pause_transfer(transfer_id);
+    return file_transfer_manager_->pause(transfer_id);
 }
 
 bool RatsClient::resume_file_transfer(const std::string& transfer_id) {
@@ -92,8 +65,7 @@ bool RatsClient::resume_file_transfer(const std::string& transfer_id) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->resume_transfer(transfer_id);
+    return file_transfer_manager_->resume(transfer_id);
 }
 
 bool RatsClient::cancel_file_transfer(const std::string& transfer_id) {
@@ -101,25 +73,24 @@ bool RatsClient::cancel_file_transfer(const std::string& transfer_id) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return false;
     }
-    
-    return file_transfer_manager_->cancel_transfer(transfer_id);
+    return file_transfer_manager_->cancel(transfer_id);
 }
 
-std::shared_ptr<FileTransferProgress> RatsClient::get_file_transfer_progress(const std::string& transfer_id) const {
+std::shared_ptr<FileTransferProgress>
+RatsClient::get_file_transfer_progress(const std::string& transfer_id) const {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return nullptr;
     }
-    
-    return file_transfer_manager_->get_transfer_progress(transfer_id);
+    return file_transfer_manager_->get_progress(transfer_id);
 }
 
-std::vector<std::shared_ptr<FileTransferProgress>> RatsClient::get_active_file_transfers() const {
+std::vector<std::shared_ptr<FileTransferProgress>>
+RatsClient::get_active_file_transfers() const {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return {};
     }
-    
     return file_transfer_manager_->get_active_transfers();
 }
 
@@ -128,8 +99,7 @@ nlohmann::json RatsClient::get_file_transfer_statistics() const {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return nlohmann::json::object();
     }
-    
-    return file_transfer_manager_->get_transfer_statistics();
+    return file_transfer_manager_->get_statistics();
 }
 
 void RatsClient::set_file_transfer_config(const FileTransferConfig& config) {
@@ -137,90 +107,38 @@ void RatsClient::set_file_transfer_config(const FileTransferConfig& config) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return;
     }
-    
     file_transfer_manager_->set_config(config);
 }
 
-const FileTransferConfig& RatsClient::get_file_transfer_config() const {
+FileTransferConfig RatsClient::get_file_transfer_config() const {
     if (!is_file_transfer_available()) {
         throw std::runtime_error("File transfer manager not available");
     }
-    
     return file_transfer_manager_->get_config();
 }
 
-void RatsClient::on_file_transfer_progress(FileTransferProgressCallback callback) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return;
-    }
-    
-    file_transfer_manager_->set_progress_callback(callback);
-}
-
-void RatsClient::on_file_transfer_completed(FileTransferCompletedCallback callback) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return;
-    }
-    
-    file_transfer_manager_->set_completion_callback(callback);
-}
-
-void RatsClient::on_file_transfer_request(FileTransferRequestCallback callback) {
+void RatsClient::on_file_transfer_progress(TransferProgressCallback callback) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return;
     }
-    
-    file_transfer_manager_->set_request_callback(callback);
-}
-
-void RatsClient::on_directory_transfer_progress(DirectoryTransferProgressCallback callback) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return;
-    }
-    
-    file_transfer_manager_->set_directory_progress_callback(callback);
-}
-
-std::string RatsClient::request_file(const std::string& peer_id, const std::string& remote_file_path,
-                                    const std::string& local_path) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return "";
-    }
-    
-    return file_transfer_manager_->request_file(peer_id, remote_file_path, local_path);
-}
-
-std::string RatsClient::request_directory(const std::string& peer_id, const std::string& remote_directory_path,
-                                         const std::string& local_directory_path, bool recursive) {
-    if (!is_file_transfer_available()) {
-        LOG_CLIENT_ERROR("File transfer manager not available");
-        return "";
-    }
-    
-    return file_transfer_manager_->request_directory(peer_id, remote_directory_path, local_directory_path, recursive);
+    file_transfer_manager_->set_progress_callback(std::move(callback));
 }
 
-void RatsClient::on_file_request(FileRequestCallback callback) {
+void RatsClient::on_file_transfer_completed(TransferCompletedCallback callback) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return;
     }
-    
-    file_transfer_manager_->set_file_request_callback(callback);
+    file_transfer_manager_->set_completed_callback(std::move(callback));
 }
 
-void RatsClient::on_directory_request(DirectoryRequestCallback callback) {
+void RatsClient::on_file_transfer_request(TransferOfferCallback callback) {
     if (!is_file_transfer_available()) {
         LOG_CLIENT_ERROR("File transfer manager not available");
         return;
     }
-    
-    file_transfer_manager_->set_directory_request_callback(callback);
+    file_transfer_manager_->set_offer_callback(std::move(callback));
 }
 
-}
+} // namespace librats

package/native-src/src/librats_gossipsub.cpp

@@ -1,9 +1,5 @@
 #include "librats.h"
-// Logging macros for RatsClient
-#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", message)
-#define LOG_CLIENT_INFO(message)  LOG_INFO("client", message)
-#define LOG_CLIENT_WARN(message)  LOG_WARN("client", message)
-#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", message)
+#include "librats_log_macros.h"
 
 namespace librats {
 

package/native-src/src/librats_ice.cpp

@@ -91,6 +91,10 @@ std::optional<StunMappedAddress> RatsClient::discover_public_address(
     
     if (result.success && result.mapped_address) {
         LOG_INFO("ice", "Discovered public address: " << result.mapped_address->to_string());
+        
+        // Add public IP to our own addresses list to prevent self-connections
+        add_ignored_address(result.mapped_address->address);
+        
         return result.mapped_address;
     }
     
@@ -183,7 +187,7 @@ void RatsClient::set_ice_config(const IceConfig& config) {
     get_ice_manager().set_config(config);
 }
 
-const IceConfig& RatsClient::get_ice_config() const {
+IceConfig RatsClient::get_ice_config() const {
     // Need to cast away const to get mutable reference for lazy initialization
     return const_cast<RatsClient*>(this)->get_ice_manager().config();
 }

package/native-src/src/librats_log_macros.h

@@ -0,0 +1,36 @@
+/**
+ * @file librats_log_macros.h
+ * @brief Shared logging macros for all librats_*.cpp files.
+ *
+ * In TESTING builds the macros embed the `this` pointer so that
+ * log lines from different RatsClient instances can be distinguished.
+ */
+
+#ifndef LIBRATS_LOG_MACROS_H
+#define LIBRATS_LOG_MACROS_H
+
+#include "logger.h"
+
+#ifdef TESTING
+#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", "[pointer: " << this << "] " << message)
+#define LOG_CLIENT_INFO(message)  LOG_INFO("client", "[pointer: " << this << "] " << message)
+#define LOG_CLIENT_WARN(message)  LOG_WARN("client", "[pointer: " << this << "] " << message)
+#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", "[pointer: " << this << "] " << message)
+
+#define LOG_SERVER_DEBUG(message) LOG_DEBUG("server", "[pointer: " << this << "] " << message)
+#define LOG_SERVER_INFO(message)  LOG_INFO("server", "[pointer: " << this << "] " << message)
+#define LOG_SERVER_WARN(message)  LOG_WARN("server", "[pointer: " << this << "] " << message)
+#define LOG_SERVER_ERROR(message) LOG_ERROR("server", "[pointer: " << this << "] " << message)
+#else
+#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", message)
+#define LOG_CLIENT_INFO(message)  LOG_INFO("client", message)
+#define LOG_CLIENT_WARN(message)  LOG_WARN("client", message)
+#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", message)
+
+#define LOG_SERVER_DEBUG(message) LOG_DEBUG("server", message)
+#define LOG_SERVER_INFO(message)  LOG_INFO("server", message)
+#define LOG_SERVER_WARN(message)  LOG_WARN("server", message)
+#define LOG_SERVER_ERROR(message) LOG_ERROR("server", message)
+#endif
+
+#endif // LIBRATS_LOG_MACROS_H

package/native-src/src/librats_logging.cpp

@@ -1,13 +1,7 @@
 #include "librats.h"
-#include "logger.h"
+#include "librats_log_macros.h"
 #include <algorithm>
 
-// Logging macros for RatsClient
-#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", message)
-#define LOG_CLIENT_INFO(message)  LOG_INFO("client", message)
-#define LOG_CLIENT_WARN(message)  LOG_WARN("client", message)
-#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", message)
-
 namespace librats {
 
 //=============================================================================

package/native-src/src/librats_mdns.cpp

@@ -6,17 +6,7 @@
 #include <memory>
 #include <stdexcept>
 
-#ifdef TESTING
-#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", "[pointer: " << this << "] " << message)
-#define LOG_CLIENT_INFO(message)  LOG_INFO("client", "[pointer: " << this << "] " << message)
-#define LOG_CLIENT_WARN(message)  LOG_WARN("client", "[pointer: " << this << "] " << message)
-#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", "[pointer: " << this << "] " << message)
-#else
-#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", message)
-#define LOG_CLIENT_INFO(message)  LOG_INFO("client", message)
-#define LOG_CLIENT_WARN(message)  LOG_WARN("client", message)
-#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", message)
-#endif
+#include "librats_log_macros.h"
 
 namespace librats {
 

package/native-src/src/librats_persistence.cpp

@@ -12,17 +12,7 @@
 #include <iomanip>
 #include <stdexcept>
 
-#ifdef TESTING
-#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", "[pointer: " << this << "] " << message)
-#define LOG_CLIENT_INFO(message)  LOG_INFO("client", "[pointer: " << this << "] " << message)
-#define LOG_CLIENT_WARN(message)  LOG_WARN("client", "[pointer: " << this << "] " << message)
-#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", "[pointer: " << this << "] " << message)
-#else
-#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", message)
-#define LOG_CLIENT_INFO(message)  LOG_INFO("client", message)
-#define LOG_CLIENT_WARN(message)  LOG_WARN("client", message)
-#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", message)
-#endif
+#include "librats_log_macros.h"
 
 namespace librats {
 

package/native-src/src/librats_reconnection.cpp

@@ -1,16 +1,5 @@
 #include "librats.h"
-
-#ifdef TESTING
-#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", "[pointer: " << this << "] " << message)
-#define LOG_CLIENT_INFO(message)  LOG_INFO("client", "[pointer: " << this << "] " << message)
-#define LOG_CLIENT_WARN(message)  LOG_WARN("client", "[pointer: " << this << "] " << message)
-#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", "[pointer: " << this << "] " << message)
-#else
-#define LOG_CLIENT_DEBUG(message) LOG_DEBUG("client", message)
-#define LOG_CLIENT_INFO(message)  LOG_INFO("client", message)
-#define LOG_CLIENT_WARN(message)  LOG_WARN("client", message)
-#define LOG_CLIENT_ERROR(message) LOG_ERROR("client", message)
-#endif
+#include "librats_log_macros.h"
 
 namespace librats {
 
@@ -37,7 +26,7 @@ void RatsClient::set_reconnect_config(const ReconnectConfig& config) {
                     << ", stable_threshold=" << config.stable_connection_threshold_seconds << "s");
 }
 
-const ReconnectConfig& RatsClient::get_reconnect_config() const {
+ReconnectConfig RatsClient::get_reconnect_config() const {
     std::lock_guard<std::mutex> lock(reconnect_mutex_);
     return reconnect_config_;
 }

package/native-src/src/librats_statistic.cpp

@@ -0,0 +1,105 @@
+#include "librats.h"
+#include "librats_log_macros.h"
+#include "os.h"
+
+namespace librats {
+
+    
+// =========================================================================
+// Statistics and Information
+// =========================================================================
+
+nlohmann::json RatsClient::get_connection_statistics() const {
+    nlohmann::json stats;
+    
+    {
+        std::lock_guard<std::mutex> lock(peers_mutex_);
+        stats["total_peers"] = peers_.size();
+        stats["validated_peers"] = get_peer_count_unlocked();
+        stats["max_peers"] = max_peers_;
+    }
+    
+    stats["running"] = is_running();
+    stats["listen_port"] = listen_port_;
+    stats["our_peer_id"] = get_our_peer_id();
+    stats["encryption_enabled"] = is_encryption_enabled();
+    
+    // DHT statistics (IPv4 + IPv6 combined)
+    if (is_dht_running()) {
+        stats["dht_running"] = true;
+        stats["dht_routing_table_size"] = get_dht_routing_table_size();
+        stats["dht_ipv4_running"] = (dht_client_ && dht_client_->is_running());
+        stats["dht_ipv6_running"] = (dht_client_v6_ && dht_client_v6_->is_running());
+        if (dht_client_ && dht_client_->is_running()) {
+            stats["dht_ipv4_routing_table_size"] = dht_client_->get_routing_table_size();
+        }
+        if (dht_client_v6_ && dht_client_v6_->is_running()) {
+            stats["dht_ipv6_routing_table_size"] = dht_client_v6_->get_routing_table_size();
+        }
+    } else {
+        stats["dht_running"] = false;
+    }
+    
+    // mDNS statistics
+    stats["mdns_running"] = is_mdns_running();
+    
+    // Reconnection statistics
+    {
+        std::lock_guard<std::mutex> lock(reconnect_mutex_);
+        stats["reconnect_enabled"] = reconnect_config_.enabled;
+        stats["reconnect_queue_size"] = reconnect_queue_.size();
+        stats["reconnect_max_attempts"] = reconnect_config_.max_attempts;
+    }
+    
+    return stats;
+}
+
+// Cached formatting helpers - computed once on first use
+static const std::string& get_box_separator() {
+    static const std::string separator = supports_unicode() ? 
+        "════════════════════════════════════════════════════════════════════" :
+        "=====================================================================";
+    return separator;
+}
+
+static const std::string& get_box_vertical() {
+    static const std::string vertical = supports_unicode() ? "│" : "|";
+    return vertical;
+}
+
+static const std::string& get_checkmark() {
+    static const std::string checkmark = supports_unicode() ? "✓" : "[*]";
+    return checkmark;
+}
+
+void RatsClient::log_handshake_completion_unlocked(const RatsPeer& peer) {
+    // Calculate connection duration
+    auto now = std::chrono::steady_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - peer.connected_at);
+    
+    // Get current peer count (assumes peers_mutex_ is already locked)
+    int current_peer_count = get_peer_count_unlocked();
+    
+    // Create visually appealing log output
+    std::string connection_type = peer.is_outgoing ? "OUTGOING" : "INCOMING";
+    const std::string& separator = get_box_separator();
+    const std::string& vertical = get_box_vertical();
+    const std::string& checkmark = get_checkmark();
+    
+    LOG_CLIENT_INFO("");
+    LOG_CLIENT_INFO(separator);
+    LOG_CLIENT_INFO(checkmark << " HANDSHAKE COMPLETED - NEW PEER CONNECTED");
+    LOG_CLIENT_INFO(separator);
+    LOG_CLIENT_INFO(vertical << " Peer ID       : " << peer.peer_id);
+    LOG_CLIENT_INFO(vertical << " Address       : " << peer.ip << ":" << peer.port);
+    LOG_CLIENT_INFO(vertical << " Connection    : " << connection_type);
+    LOG_CLIENT_INFO(vertical << " Protocol Ver. : " << peer.version);
+    LOG_CLIENT_INFO(vertical << " Socket        : " << peer.socket);
+    LOG_CLIENT_INFO(vertical << " Duration      : " << duration.count() << "ms");
+    LOG_CLIENT_INFO(vertical << " Network Peers : " << current_peer_count << "/" << max_peers_);
+    
+    LOG_CLIENT_INFO(separator);
+    LOG_CLIENT_INFO("");
+}
+
+}

package/native-src/src/socket.cpp

@@ -760,13 +760,25 @@ static bool build_udp_dest_addr(const std::string& host, int port, AddressFamily
                                 sockaddr_storage& addr, socklen_t& addr_len) {
     memset(&addr, 0, sizeof(addr));
 
-    // Native IPv6 address
+    // Native IPv6 address, or hostname that must resolve to IPv6 (pure IPv6 socket).
+    // A pure IPv6 socket (V6ONLY) cannot send to IPv4-mapped addresses, so hostnames
+    // are resolved via AAAA records here.
+    std::string ipv6_host;
     if (network_utils::is_valid_ipv6(host)) {
+        ipv6_host = host;
+    } else if (af == AddressFamily::IPv6) {
+        ipv6_host = network_utils::resolve_hostname_v6(host);
+        if (ipv6_host.empty()) {
+            LOG_SOCKET_DEBUG("Failed to resolve hostname to IPv6: " << host);
+            return false;
+        }
+    }
+    if (!ipv6_host.empty()) {
         auto* a6 = reinterpret_cast<sockaddr_in6*>(&addr);
         a6->sin6_family = AF_INET6;
         a6->sin6_port = htons(port);
-        if (inet_pton(AF_INET6, host.c_str(), &a6->sin6_addr) <= 0) {
-            LOG_SOCKET_ERROR("Invalid IPv6 address: " << host);
+        if (inet_pton(AF_INET6, ipv6_host.c_str(), &a6->sin6_addr) <= 0) {
+            LOG_SOCKET_ERROR("Invalid IPv6 address: " << ipv6_host);
             return false;
         }
         addr_len = sizeof(sockaddr_in6);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librats",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Node.js bindings for librats - A high-performance peer-to-peer networking library",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/scripts/build-librats.js

@@ -136,6 +136,9 @@ try {
         '-DRATS_BUILD_EXAMPLES=OFF',
         '-DRATS_STATIC_LIBRARY=ON',
         '-DRATS_BINDINGS=ON',
+        // The bindings only need the static archive; install/package-config rules
+        // (find_package support) are unnecessary here and pull in cmake/ratsConfig.cmake.in.
+        '-DRATS_INSTALL=OFF',
         '-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDLL'
     ];
 

package/scripts/prepare-package.js

@@ -108,6 +108,16 @@ copyDir(
     srcFilter
 );
 
+// Copy cmake/ directory (package-config templates referenced by CMakeLists.txt
+// when RATS_INSTALL is enabled, e.g. cmake/ratsConfig.cmake.in)
+if (fs.existsSync(path.join(projectRoot, 'cmake'))) {
+    console.log('  Copying cmake/ directory...');
+    copyDir(
+        path.join(projectRoot, 'cmake'),
+        path.join(nativeSrcDir, 'cmake')
+    );
+}
+
 // Copy 3rdparty/ directory
 if (fs.existsSync(path.join(projectRoot, '3rdparty'))) {
     console.log('  Copying 3rdparty/ directory...');