librats 0.7.0 → 0.7.1

package/lib/index.d.ts

@@ -696,3 +696,18 @@ export function getGitDescribe(): string;
  */
 export function getAbi(): number;
 
+// ============ Logging Control Functions ============
+
+/**
+ * Enable or disable console logging.
+ * When disabled, log messages will not be printed to stdout/stderr.
+ * File logging (if enabled) will still work.
+ * @param enabled - Whether to enable console logging (default: true)
+ */
+export function setConsoleLoggingEnabled(enabled: boolean): void;
+
+/**
+ * Check if console logging is currently enabled.
+ * @returns true if console logging is enabled
+ */
+export function isConsoleLoggingEnabled(): boolean;

package/native-src/src/librats.cpp

@@ -455,7 +455,8 @@ void RatsClient::handle_client(socket_t client_socket, const std::string& peer_h
         }
         
         // ----- 2. DECRYPT IF NEEDED -----
-        std::string data;
+        // Use vector directly to avoid unnecessary string conversions
+        std::vector<uint8_t> data;
         
         if (noise_handshake_done) {
             std::string current_peer_id;
@@ -492,16 +493,18 @@ void RatsClient::handle_client(socket_t client_socket, const std::string& peer_h
                 }
                 
                 plaintext.resize(pt_len);
-                data = std::string(plaintext.begin(), plaintext.end());
+                data = std::move(plaintext);
                 LOG_CLIENT_DEBUG("Decrypted message from " << current_peer_id << " (" << pt_len << " bytes)");
             } else {
-                data = std::string(received_bytes.begin(), received_bytes.end());
+                data = std::move(received_bytes);
             }
         } else {
-            data = std::string(received_bytes.begin(), received_bytes.end());
+            data = std::move(received_bytes);
         }
         
-        LOG_CLIENT_DEBUG("Received data from " << peer_hash_id << ": " << data.substr(0, 50) << (data.length() > 50 ? "..." : ""));
+        // Log first 50 bytes for debugging
+        size_t log_len = (std::min)(data.size(), static_cast<size_t>(50));
+        LOG_CLIENT_DEBUG("Received data from " << peer_hash_id << ": " << std::string(data.begin(), data.begin() + log_len) << (data.size() > 50 ? "..." : ""));
         
         // ----- 3. CONNECTION STATE CHECK (during handshake phase only) -----
         if (!handshake_completed) {
@@ -531,51 +534,75 @@ void RatsClient::handle_client(socket_t client_socket, const std::string& peer_h
         }
         
         // ----- 4. HANDSHAKE PHASE -----
-        if (is_handshake_message(data)) {
+        // Only check for handshake messages BEFORE handshake is completed
+        // This avoids expensive JSON parsing on every message after handshake
+        if (!handshake_completed && is_handshake_message(data)) {
             if (!handle_handshake_message(client_socket, peer_hash_id, data)) {
                 LOG_CLIENT_ERROR("Failed to handle handshake message from " << peer_hash_id);
                 break;
             }
             
-            // Check if handshake just completed
+            // Check if rats handshake just completed (COMPLETED or NOISE_PENDING state)
             if (!handshake_completed) {
                 RatsPeer peer_copy;
-                bool just_completed = false;
+                bool rats_handshake_done = false;
+                bool needs_noise_handshake = false;
                 
                 {
                     std::lock_guard<std::mutex> lock(peers_mutex_);
                     auto sock_it = socket_to_peer_id_.find(client_socket);
                     if (sock_it != socket_to_peer_id_.end()) {
                         auto peer_it = peers_.find(sock_it->second);
-                        if (peer_it != peers_.end() && peer_it->second.is_handshake_completed()) {
-                            just_completed = true;
-                            peer_copy = peer_it->second;
+                        if (peer_it != peers_.end()) {
+                            // Check if rats handshake completed (either COMPLETED or NOISE_PENDING)
+                            if (peer_it->second.is_handshake_completed()) {
+                                rats_handshake_done = true;
+                                peer_copy = peer_it->second;
+                            } else if (peer_it->second.handshake_state == RatsPeer::HandshakeState::NOISE_PENDING) {
+                                rats_handshake_done = true;
+                                needs_noise_handshake = true;
+                                peer_copy = peer_it->second;
+                            }
                         }
                     }
                 }
                 
                 // ----- POST-HANDSHAKE ACTIONS -----
-                if (just_completed) {
-                    handshake_completed = true;
-                    LOG_CLIENT_INFO("Handshake completed for peer " << peer_hash_id << " (peer_id: " << peer_copy.peer_id << ")");
+                if (rats_handshake_done) {
+                    LOG_CLIENT_INFO("Rats handshake completed for peer " << peer_hash_id << " (peer_id: " << peer_copy.peer_id << ")");
                     
                     // Remove from reconnection queue if present (successful connection)
                     remove_from_reconnect_queue(peer_copy.peer_id);
                     
                     // Noise encryption handshake - only if BOTH sides support encryption
                     // peer_copy.encryption_enabled is already negotiated in handle_handshake_message()
-                    if (peer_copy.encryption_enabled) {
+                    if (needs_noise_handshake) {
                         LOG_CLIENT_INFO("Starting Noise handshake for peer " << peer_copy.peer_id);
                         if (perform_noise_handshake(client_socket, peer_copy.peer_id, peer_copy.is_outgoing)) {
                             noise_handshake_done = true;
                             LOG_CLIENT_INFO("Noise handshake successful for peer " << peer_copy.peer_id);
+                            
+                            // Update state to COMPLETED after successful Noise handshake
+                            {
+                                std::lock_guard<std::mutex> lock(peers_mutex_);
+                                auto sock_it = socket_to_peer_id_.find(client_socket);
+                                if (sock_it != socket_to_peer_id_.end()) {
+                                    auto peer_it = peers_.find(sock_it->second);
+                                    if (peer_it != peers_.end()) {
+                                        peer_it->second.handshake_state = RatsPeer::HandshakeState::COMPLETED;
+                                        log_handshake_completion_unlocked(peer_it->second);
+                                    }
+                                }
+                            }
                         } else {
                             LOG_CLIENT_ERROR("Noise handshake failed for peer " << peer_copy.peer_id);
+                            // Connection will be closed due to failed Noise handshake
+                            break;
                         }
-                    } else {
-                        LOG_CLIENT_DEBUG("Skipping Noise handshake for peer " << peer_copy.peer_id << " - encryption not negotiated");
                     }
                     
+                    handshake_completed = true;
+                    
                     // Connection callback
                     if (connection_callback_) {
                         connection_callback_(client_socket, peer_copy.peer_id);
@@ -621,11 +648,11 @@ void RatsClient::handle_client(socket_t client_socket, const std::string& peer_h
             continue;
         }
         
-        std::vector<uint8_t> received_data(data.begin(), data.end());
+        // Use data directly - no need for extra copy
         MessageHeader header;
         std::vector<uint8_t> payload;
         
-        if (!parse_message_with_header(received_data, header, payload)) {
+        if (!parse_message_with_header(data, header, payload)) {
             LOG_CLIENT_WARN("No header found in message from " << peer_hash_id);
             continue;
         }
@@ -741,14 +768,15 @@ std::string RatsClient::create_handshake_message(const std::string& message_type
     handshake_msg["message_type"] = message_type;
     handshake_msg["timestamp"] = timestamp;
     handshake_msg["encryption_enabled"] = is_encryption_enabled();
+    handshake_msg["listen_port"] = listen_port_;
     
     return handshake_msg.dump();
 }
 
-bool RatsClient::parse_handshake_message(const std::string& message, HandshakeMessage& out_msg) const {
+bool RatsClient::parse_handshake_message(const std::vector<uint8_t>& data, HandshakeMessage& out_msg) const {
     try {
-        // Use nlohmann::json for proper JSON parsing
-        nlohmann::json json_msg = nlohmann::json::parse(message);
+        // Use nlohmann::json with iterators to avoid string conversion
+        nlohmann::json json_msg = nlohmann::json::parse(data.begin(), data.end());
         
         // Clear the output structure
         out_msg = HandshakeMessage{};
@@ -762,6 +790,8 @@ bool RatsClient::parse_handshake_message(const std::string& message, HandshakeMe
         out_msg.timestamp = json_msg.value("timestamp", static_cast<int64_t>(0));
         // Parse encryption_enabled (default to false for backward compatibility)
         out_msg.encryption_enabled = json_msg.value("encryption_enabled", false);
+        // Parse listen_port (default to 0 for backward compatibility with older clients)
+        out_msg.listen_port = json_msg.value("listen_port", static_cast<uint16_t>(0));
         
         return true;
         
@@ -823,37 +853,30 @@ bool RatsClient::validate_handshake_message(const HandshakeMessage& msg) const {
     return true;
 }
 
-bool RatsClient::is_handshake_message(const std::string& message) const {
+bool RatsClient::is_handshake_message(const std::vector<uint8_t>& data) const {
     try {
-        std::string json_to_parse = message;
-        
         // Check if message has our message header (starts with "RATS" magic)
-        std::vector<uint8_t> message_data(message.begin(), message.end());
         MessageHeader header;
         std::vector<uint8_t> payload;
         
-        if (parse_message_with_header(message_data, header, payload)) {
+        if (parse_message_with_header(data, header, payload)) {
             // Message has valid header - extract the JSON payload
             if (header.type == MessageDataType::STRING || header.type == MessageDataType::JSON) {
-                json_to_parse = std::string(payload.begin(), payload.end());
-            } else {
-                // Handshake messages should be string/JSON type
-                return false;
+                // Parse the JSON message directly from payload
+                nlohmann::json json_msg = nlohmann::json::parse(payload.begin(), payload.end());
+                std::string expected_protocol;
+                {
+                    std::lock_guard<std::mutex> lock(protocol_config_mutex_);
+                    expected_protocol = custom_protocol_name_;
+                }
+                return json_msg.value("protocol", "") == expected_protocol && 
+                       json_msg.value("message_type", "") == "handshake";
             }
-        } else {
-            // Message has no header
+            // Handshake messages should be string/JSON type
             return false;
         }
-        
-        // Parse the JSON message
-        nlohmann::json json_msg = nlohmann::json::parse(json_to_parse);
-        std::string expected_protocol;
-        {
-            std::lock_guard<std::mutex> lock(protocol_config_mutex_);
-            expected_protocol = custom_protocol_name_;
-        }
-        return json_msg.value("protocol", "") == expected_protocol && 
-               json_msg.value("message_type", "") == "handshake";
+        // Message has no header
+        return false;
     } catch (const std::exception&) {
         return false;
     }
@@ -898,28 +921,25 @@ bool RatsClient::send_handshake(socket_t socket, const std::string& our_peer_id)
     return send_handshake_unlocked(socket, our_peer_id);
 }
 
-bool RatsClient::handle_handshake_message(socket_t socket, const std::string& peer_hash_id, const std::string& message) {
-    // Extract JSON payload from message header if present
-    std::string json_to_parse = message;
-    std::vector<uint8_t> message_data(message.begin(), message.end());
+bool RatsClient::handle_handshake_message(socket_t socket, const std::string& peer_hash_id, const std::vector<uint8_t>& data) {
+    // Extract JSON payload from message header
     MessageHeader header;
     std::vector<uint8_t> payload;
     
-    if (parse_message_with_header(message_data, header, payload)) {
-        // Message has valid header - extract the JSON payload
-        if (header.type == MessageDataType::STRING || header.type == MessageDataType::JSON) {
-            json_to_parse = std::string(payload.begin(), payload.end());
-        } else {
-            LOG_CLIENT_ERROR("Invalid message type for handshake: " << static_cast<int>(header.type));
-            return false;
-        }
-    } else {
+    if (!parse_message_with_header(data, header, payload)) {
         LOG_CLIENT_ERROR("Failed to parse handshake message header from " << peer_hash_id);
         return false;
     }
     
+    // Message has valid header - check the type
+    if (header.type != MessageDataType::STRING && header.type != MessageDataType::JSON) {
+        LOG_CLIENT_ERROR("Invalid message type for handshake: " << static_cast<int>(header.type));
+        return false;
+    }
+    
+    // Parse handshake message directly from payload (no string conversion)
     HandshakeMessage handshake_msg;
-    if (!parse_handshake_message(json_to_parse, handshake_msg)) {
+    if (!parse_handshake_message(payload, handshake_msg)) {
         LOG_CLIENT_ERROR("Failed to parse handshake message from " << peer_hash_id);
         return false;
     }
@@ -995,12 +1015,35 @@ bool RatsClient::handle_handshake_message(socket_t socket, const std::string& pe
                     << ", remote=" << remote_encryption 
                     << ", result=" << peer.encryption_enabled);
     
+    // For incoming connections, update port to the peer's actual listen port
+    // This is critical for peer exchange to work correctly
+    if (!peer.is_outgoing && handshake_msg.listen_port > 0) {
+        // Remove old address mapping
+        address_to_peer_id_.erase(peer.normalized_address);
+        
+        // Update port and normalized address
+        peer.port = handshake_msg.listen_port;
+        peer.normalized_address = normalize_peer_address(peer.ip, peer.port);
+        
+        // Add new address mapping
+        address_to_peer_id_[peer.normalized_address] = peer.peer_id;
+        
+        LOG_CLIENT_INFO("Updated incoming peer port to listen_port: " << peer.ip << ":" << peer.port);
+    }
+    
     // Simplified handshake logic - just one message type
     if (peer.handshake_state == RatsPeer::HandshakeState::PENDING) {
         // This is an incoming handshake - send our handshake back
         if (send_handshake_unlocked(socket, get_our_peer_id())) {
-            peer.handshake_state = RatsPeer::HandshakeState::COMPLETED;
-            log_handshake_completion_unlocked(peer);
+            // If encryption is enabled, we need to do Noise handshake first
+            // Set NOISE_PENDING to prevent other threads from sending messages
+            if (peer.encryption_enabled) {
+                peer.handshake_state = RatsPeer::HandshakeState::NOISE_PENDING;
+                LOG_CLIENT_DEBUG("Rats handshake done, entering NOISE_PENDING state for " << peer_hash_id);
+            } else {
+                peer.handshake_state = RatsPeer::HandshakeState::COMPLETED;
+                log_handshake_completion_unlocked(peer);
+            }
             
             // Append to historical peers file after successful connection
             append_peer_to_historical_file(peer);
@@ -1013,8 +1056,15 @@ bool RatsClient::handle_handshake_message(socket_t socket, const std::string& pe
         }
     } else if (peer.handshake_state == RatsPeer::HandshakeState::SENT) {
         // This is a response to our handshake
-        peer.handshake_state = RatsPeer::HandshakeState::COMPLETED;
-        log_handshake_completion_unlocked(peer);
+        // If encryption is enabled, we need to do Noise handshake first
+        // Set NOISE_PENDING to prevent other threads from sending messages
+        if (peer.encryption_enabled) {
+            peer.handshake_state = RatsPeer::HandshakeState::NOISE_PENDING;
+            LOG_CLIENT_DEBUG("Rats handshake done, entering NOISE_PENDING state for " << peer_hash_id);
+        } else {
+            peer.handshake_state = RatsPeer::HandshakeState::COMPLETED;
+            log_handshake_completion_unlocked(peer);
+        }
         
         // Append to historical peers file after successful connection
         append_peer_to_historical_file(peer);
@@ -2377,8 +2427,8 @@ nlohmann::json RatsClient::create_peer_exchange_message(const RatsPeer& peer) {
     payload["peer_id"] = peer.peer_id;
     payload["connection_type"] = peer.is_outgoing ? "outgoing" : "incoming";
     
-    // Create rats message
-    return create_rats_message("peer", payload, peer.peer_id);
+    // Create rats message - use OUR peer_id as sender, not the advertised peer's id
+    return create_rats_message("peer", payload, get_our_peer_id());
 }
 
 void RatsClient::broadcast_peer_exchange_message(const RatsPeer& new_peer) {

package/native-src/src/librats.h

@@ -48,9 +48,10 @@ struct RatsPeer {
     // Handshake-related fields
     enum class HandshakeState {
         PENDING,        // Handshake not started
-        SENT,          // Handshake sent, waiting for response
-        COMPLETED,     // Handshake completed successfully
-        FAILED         // Handshake failed
+        SENT,           // Handshake sent, waiting for response
+        NOISE_PENDING,  // Rats handshake done, Noise handshake in progress
+        COMPLETED,      // Handshake completed successfully (including Noise if enabled)
+        FAILED          // Handshake failed
     };
     
     HandshakeState handshake_state;         // Current handshake state
@@ -990,6 +991,20 @@ public:
     // Logging Control API
     // =========================================================================
     
+    /**
+     * Enable or disable console logging
+     * When disabled, log messages will not be printed to stdout/stderr
+     * File logging (if enabled) will still work
+     * @param enabled Whether to enable console logging (default: true)
+     */
+    void set_console_logging_enabled(bool enabled);
+    
+    /**
+     * Check if console logging is currently enabled
+     * @return true if console logging is enabled
+     */
+    bool is_console_logging_enabled() const;
+    
     /**
      * Enable or disable file logging
      * When enabled, logs will be written to "rats.log" by default
@@ -2046,15 +2061,16 @@ private:
         std::string message_type;
         int64_t timestamp;
         bool encryption_enabled;  // Whether peer supports/wants encryption
+        uint16_t listen_port;     // Peer's listening port for peer exchange
     };
 
     std::string create_handshake_message(const std::string& message_type, const std::string& our_peer_id) const;
-    bool parse_handshake_message(const std::string& message, HandshakeMessage& out_msg) const;
+    bool parse_handshake_message(const std::vector<uint8_t>& data, HandshakeMessage& out_msg) const;
     bool validate_handshake_message(const HandshakeMessage& msg) const;
-    bool is_handshake_message(const std::string& message) const;
+    bool is_handshake_message(const std::vector<uint8_t>& data) const;
     bool send_handshake(socket_t socket, const std::string& our_peer_id);
     bool send_handshake_unlocked(socket_t socket, const std::string& our_peer_id);
-    bool handle_handshake_message(socket_t socket, const std::string& peer_hash_id, const std::string& message);
+    bool handle_handshake_message(socket_t socket, const std::string& peer_hash_id, const std::vector<uint8_t>& data);
     void check_handshake_timeouts();
     void log_handshake_completion_unlocked(const RatsPeer& peer);
 

package/native-src/src/librats_c.cpp

@@ -161,6 +161,14 @@ char* rats_get_connection_statistics_json(rats_client_t handle) {
     return rats_strdup_owned(json.dump());
 }
 
+void rats_set_console_logging_enabled(int enabled) {
+    Logger::getInstance().set_console_logging_enabled(enabled != 0);
+}
+
+int rats_is_console_logging_enabled(void) {
+    return Logger::getInstance().is_console_logging_enabled() ? 1 : 0;
+}
+
 void rats_set_logging_enabled(int enabled) {
     // Global logger control through any client instance is awkward; use singleton
     Logger::getInstance().set_file_logging_enabled(enabled != 0);

package/native-src/src/librats_c.h

@@ -41,6 +41,8 @@ RATS_API char** rats_get_peer_ids(rats_client_t client, int* count); // caller m
 RATS_API char* rats_get_peer_info_json(rats_client_t client, const char* peer_id); // caller must free
 
 // Logging controls (optional helpers)
+RATS_API void rats_set_console_logging_enabled(int enabled);
+RATS_API int rats_is_console_logging_enabled(void);
 RATS_API void rats_set_logging_enabled(int enabled);
 RATS_API void rats_set_log_level(const char* level_str); // "DEBUG", "INFO", "WARN", "ERROR"
 RATS_API void rats_set_log_file_path(rats_client_t client, const char* file_path);

package/native-src/src/librats_encryption.cpp

@@ -103,6 +103,11 @@ std::vector<uint8_t> RatsClient::get_peer_handshake_hash(const std::string& peer
 }
 
 bool RatsClient::send_noise_message(socket_t socket, const uint8_t* data, size_t len) {
+    // Get socket-specific mutex for thread-safe sending
+    // This prevents race conditions with other threads sending rats protocol messages
+    auto socket_mutex = get_socket_send_mutex(socket);
+    std::lock_guard<std::mutex> send_lock(*socket_mutex);
+    
     // Send length-prefixed message for Noise handshake
     uint32_t network_len = htonl(static_cast<uint32_t>(len));
     

package/native-src/src/librats_logging.cpp

@@ -14,6 +14,18 @@ namespace librats {
 // Logging Control API Implementation
 //=============================================================================
 
+void RatsClient::set_console_logging_enabled(bool enabled) {
+    Logger::getInstance().set_console_logging_enabled(enabled);
+    // Only log if console is enabled, otherwise we're silently disabling
+    if (enabled) {
+        LOG_CLIENT_INFO("Console logging enabled");
+    }
+}
+
+bool RatsClient::is_console_logging_enabled() const {
+    return Logger::getInstance().is_console_logging_enabled();
+}
+
 void RatsClient::set_logging_enabled(bool enabled) {
     LOG_CLIENT_INFO("Setting file logging " << (enabled ? "enabled" : "disabled"));
     

package/native-src/src/logger.h

@@ -59,6 +59,17 @@ public:
         timestamps_enabled_ = enabled;
     }
     
+    // Console logging configuration
+    void set_console_logging_enabled(bool enabled) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        console_logging_enabled_ = enabled;
+    }
+    
+    bool is_console_logging_enabled() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return console_logging_enabled_;
+    }
+    
     // File logging configuration
     void set_file_logging_enabled(bool enabled) {
         std::lock_guard<std::mutex> lock(mutex_);
@@ -147,13 +158,15 @@ public:
         // Add message
         console_oss << " " << message << std::endl;
         
-        // Output to appropriate console stream
-        if (level >= LogLevel::ERROR) {
-            std::cerr << console_oss.str();
-            std::cerr.flush();
-        } else {
-            std::cout << console_oss.str();
-            std::cout.flush();
+        // Output to appropriate console stream (if console logging is enabled)
+        if (console_logging_enabled_) {
+            if (level >= LogLevel::ERROR) {
+                std::cerr << console_oss.str();
+                std::cerr.flush();
+            } else {
+                std::cout << console_oss.str();
+                std::cout.flush();
+            }
         }
         
         // Also write to file if file logging is enabled
@@ -164,8 +177,8 @@ public:
 
 private:
     Logger() : min_level_(LogLevel::INFO), colors_enabled_(true), timestamps_enabled_(true),
-               file_logging_enabled_(false), max_log_file_size_(10 * 1024 * 1024), 
-               max_log_files_(5), current_file_size_(0) {
+               console_logging_enabled_(true), file_logging_enabled_(false), 
+               max_log_file_size_(10 * 1024 * 1024), max_log_files_(5), current_file_size_(0) {
         // Check if we're outputting to a terminal
         is_terminal_ = isatty(fileno(stdout));
         
@@ -366,6 +379,9 @@ private:
     bool timestamps_enabled_;
     bool is_terminal_;
     
+    // Console logging control
+    bool console_logging_enabled_;
+    
     // File logging members
     bool file_logging_enabled_;
     std::string log_file_path_;

package/package.json

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

package/src/librats_node.cpp

@@ -1330,6 +1330,25 @@ Napi::Value GetVersion(const Napi::CallbackInfo& info) {
     return version;
 }
 
+// Console logging control functions
+Napi::Value SetConsoleLoggingEnabled(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1 || !info[0].IsBoolean()) {
+        Napi::TypeError::New(env, "Boolean expected").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    bool enabled = info[0].As<Napi::Boolean>().Value();
+    rats_set_console_logging_enabled(enabled ? 1 : 0);
+    return env.Undefined();
+}
+
+Napi::Value IsConsoleLoggingEnabled(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return Napi::Boolean::New(env, rats_is_console_logging_enabled() != 0);
+}
+
 Napi::Value GetGitDescribe(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     const char* git_describe = rats_get_git_describe();
@@ -1399,6 +1418,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set("getGitDescribe", Napi::Function::New(env, GetGitDescribe));
     exports.Set("getAbi", Napi::Function::New(env, GetAbi));
     
+    // Export logging control functions
+    exports.Set("setConsoleLoggingEnabled", Napi::Function::New(env, SetConsoleLoggingEnabled));
+    exports.Set("isConsoleLoggingEnabled", Napi::Function::New(env, IsConsoleLoggingEnabled));
+    
     // Export constants
     exports.Set("constants", InitConstants(env));