feat: add methods to set and get Hamlib debug level, defaulting to NONE

Author: boybook

index.d.ts

@@ -66,6 +66,12 @@ type VFO = 'VFO-A' | 'VFO-B';
  */
 type RadioMode = 'USB' | 'LSB' | 'FM' | 'PKTFM' | 'AM' | 'CW' | 'RTTY' | 'DIG' | string;
 
+/**
+ * Hamlib debug level type
+ * Controls the verbosity of Hamlib library debug output
+ */
+type RigDebugLevel = 0 | 1 | 2 | 3 | 4 | 5;
+
 /**
  * Memory channel data interface
  */
@@ -276,6 +282,41 @@ declare class HamLib {
    */
   static getHamlibVersion(): string;
 
+  /**
+   * Set Hamlib debug level (affects all instances globally)
+   * Controls the verbosity of Hamlib library debug output.
+   * By default, debug level is set to 0 (NONE) to prevent unwanted output.
+   *
+   * @param level Debug level:
+   *   - 0 = NONE (no debug output) - default
+   *   - 1 = BUG (serious bug messages only)
+   *   - 2 = ERR (error messages)
+   *   - 3 = WARN (warning messages)
+   *   - 4 = VERBOSE (verbose messages)
+   *   - 5 = TRACE (trace messages - very detailed)
+   * @static
+   * @example
+   * // Disable all debug output (default)
+   * HamLib.setDebugLevel(0);
+   *
+   * // Enable verbose debugging for troubleshooting
+   * HamLib.setDebugLevel(4);
+   *
+   * // Enable full trace debugging for development
+   * HamLib.setDebugLevel(5);
+   */
+  static setDebugLevel(level: RigDebugLevel): void;
+
+  /**
+   * Get current Hamlib debug level
+   * Note: This method is not supported by Hamlib API and will throw an error.
+   * Applications should track the debug level they set using setDebugLevel().
+   *
+   * @static
+   * @throws Always throws error as Hamlib doesn't provide API to query debug level
+   */
+  static getDebugLevel(): never;
+
   /**
    * Open connection to device
    * Must be called before other operations

lib/index.js

@@ -39,6 +39,41 @@ class HamLib {
     return nativeModule.HamLib.getHamlibVersion();
   }
 
+  /**
+   * Set Hamlib debug level (affects all instances globally)
+   * @param {number} level - Debug level:
+   *   - 0 = NONE (no debug output)
+   *   - 1 = BUG (serious bug messages)
+   *   - 2 = ERR (error messages)
+   *   - 3 = WARN (warning messages)
+   *   - 4 = VERBOSE (verbose messages)
+   *   - 5 = TRACE (trace messages - very detailed)
+   * @static
+   * @example
+   * // Disable all debug output (default)
+   * HamLib.setDebugLevel(0);
+   *
+   * // Enable verbose debugging
+   * HamLib.setDebugLevel(4);
+   *
+   * // Enable full trace debugging
+   * HamLib.setDebugLevel(5);
+   */
+  static setDebugLevel(level) {
+    return nativeModule.HamLib.setDebugLevel(level);
+  }
+
+  /**
+   * Get current Hamlib debug level
+   * Note: This method is not supported by Hamlib API and will throw an error.
+   * Applications should track the debug level they set using setDebugLevel().
+   * @static
+   * @throws {Error} Always throws error as Hamlib doesn't provide API to query debug level
+   */
+  static getDebugLevel() {
+    return nativeModule.HamLib.getDebugLevel();
+  }
+
   /**
    * Open connection to the radio device
    * Must be called before other operations
@@ -1093,6 +1128,10 @@ class HamLib {
   }
 }
 
+// Set debug level to NONE by default to prevent unwanted output
+// Users can change this using HamLib.setDebugLevel() if needed
+HamLib.setDebugLevel(0);
+
 // Export for CommonJS
 module.exports = { HamLib };
 module.exports.HamLib = HamLib;

src/addon.cpp

@@ -1,8 +1,12 @@
 #include <napi.h>
 #include "hamlib.h"
 #include "decoder.h"
+#include <hamlib/rig.h>
 
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  // Set Hamlib debug level to NONE by default to prevent unwanted output
+  // Users can change this using HamLib.setDebugLevel() if needed
+  rig_set_debug(RIG_DEBUG_NONE);
 
   Napi::String name = Napi::String::New(env, "HamLib");
   exports.Set(name, NodeHamLib::GetClass(env));

src/hamlib.cpp

@@ -2214,12 +2214,9 @@ NodeHamLib::NodeHamLib(const Napi::CallbackInfo & info): ObjectWrap(info) {
       std::string portStr = info[1].As<Napi::String>().Utf8Value();
       strncpy(port_path, portStr.c_str(), HAMLIB_FILPATHLEN - 1);
       port_path[HAMLIB_FILPATHLEN - 1] = '\0';
-    } else {
-      // If second argument exists but is not a string, treat it as debug level (backward compatibility)
-      rig_set_debug_level(RIG_DEBUG_NONE);
     }
-  } else {
-    rig_set_debug_level(RIG_DEBUG_NONE);
+    // Note: Debug level is now controlled globally via HamLib.setDebugLevel()
+    // and set to RIG_DEBUG_NONE by default in addon initialization
   }
   //rig_model_t myrig_model;
   //   hamlib_port_t myport;
@@ -2241,19 +2238,21 @@ NodeHamLib::NodeHamLib(const Napi::CallbackInfo & info): ObjectWrap(info) {
 
   // Check if port_path is a network address (contains colon)
   is_network_rig = isNetworkAddress(port_path);
-  
+
   if (is_network_rig) {
     // Use NETRIGCTL model for network connections
     myrig_model = 2; // RIG_MODEL_NETRIGCTL
-    printf("Using network connection to %s\n", port_path);
+    // Network connection will be established on open()
   }
 
   my_rig = rig_init(myrig_model);
   //int retcode = 0;
   if (!my_rig) {
-    fprintf(stderr, "Unknown rig num: %d\n", myrig_model);
-    fprintf(stderr, "Please check riglist.h\n");
-    Napi::TypeError::New(env, "Unable to Init Rig").ThrowAsJavaScriptException();
+    // Create detailed error message
+    std::string errorMsg = "Unable to initialize rig (model: " +
+                           std::to_string(myrig_model) +
+                           "). Please check if the model number is valid.";
+    Napi::TypeError::New(env, errorMsg).ThrowAsJavaScriptException();
   }
 
   // Set port path and type based on connection type
@@ -3724,6 +3723,8 @@ Napi::Function NodeHamLib::GetClass(Napi::Env env) {
       // Static methods
       NodeHamLib::StaticMethod("getSupportedRigs", & NodeHamLib::GetSupportedRigs),
       NodeHamLib::StaticMethod("getHamlibVersion", & NodeHamLib::GetHamlibVersion),
+      NodeHamLib::StaticMethod("setDebugLevel", & NodeHamLib::SetDebugLevel),
+      NodeHamLib::StaticMethod("getDebugLevel", & NodeHamLib::GetDebugLevel),
     });
       constructor = Napi::Persistent(ret);
       constructor.SuppressDestruct();
@@ -3843,6 +3844,47 @@ Napi::Value NodeHamLib::GetHamlibVersion(const Napi::CallbackInfo& info) {
   return Napi::String::New(env, hamlib_version2);
 }
 
+// Set Hamlib debug level
+// Debug levels: 0=NONE, 1=BUG, 2=ERR, 3=WARN, 4=VERBOSE, 5=TRACE
+Napi::Value NodeHamLib::SetDebugLevel(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsNumber()) {
+    Napi::TypeError::New(env, "Debug level (number) required").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  int level = info[0].As<Napi::Number>().Int32Value();
+
+  // Validate debug level (0-5)
+  if (level < 0 || level > 5) {
+    Napi::RangeError::New(env, "Debug level must be between 0 (NONE) and 5 (TRACE)").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  rig_set_debug((enum rig_debug_level_e)level);
+
+  return env.Undefined();
+}
+
+// Get current Hamlib debug level
+Napi::Value NodeHamLib::GetDebugLevel(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  // hamlib_get_debug() is not available in all versions, so we use a workaround
+  // by calling rig_debug_level which is a global variable in hamlib
+  // However, this is internal implementation, so we use rig_debug with RIG_DEBUG_NONE
+  // to get the current level. For now, we'll just return a note that this is not
+  // directly accessible. In practice, applications should track the level they set.
+
+  // Since there's no public API to query debug level in Hamlib,
+  // we'll document that users should track it themselves
+  Napi::Error::New(env,
+    "Getting debug level is not supported by Hamlib API. "
+    "Please track the debug level you set using setDebugLevel().").ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+
 // Serial Port Configuration Methods
 
 // Set serial configuration parameter (data_bits, stop_bits, parity, handshake, etc.)

src/hamlib.h

@@ -168,6 +168,10 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
   // Static method to get Hamlib version
   static Napi::Value GetHamlibVersion(const Napi::CallbackInfo&);
 
+  // Static methods to control debug level
+  static Napi::Value SetDebugLevel(const Napi::CallbackInfo&);
+  static Napi::Value GetDebugLevel(const Napi::CallbackInfo&);
+
   static Napi::Function GetClass(Napi::Env);
 
   static int freq_change_cb(RIG*, vfo_t, freq_t, void*);

test/test_loader.js

@@ -123,8 +123,8 @@ try {
   const totalMethods = instanceMethods.length + staticMethods.length;
 
   test(`实例方法数量正确 (80个)`, () => instanceMethods.length === 80);
-  test(`静态方法数量正确 (2个)`, () => staticMethods.length === 2);
-  test(`总方法数量正确 (82个)`, () => totalMethods === 82);
+  test(`静态方法数量正确 (4个)`, () => staticMethods.length === 4);
+  test(`总方法数量正确 (84个)`, () => totalMethods === 84);
 
   console.log(`   📊 实例方法: ${instanceMethods.length}个`);
   console.log(`   📊 静态方法: ${staticMethods.length}个`);