hamlib 0.2.0 → 0.2.2

package/src/hamlib.cpp

@@ -2191,19 +2191,17 @@ NodeHamLib::NodeHamLib(const Napi::CallbackInfo & info): ObjectWrap(info) {
     return;
   }
 
-  // Set default port path if not provided
-  strncpy(port_path, "/dev/ttyUSB0", SHIM_HAMLIB_FILPATHLEN - 1);
-  port_path[SHIM_HAMLIB_FILPATHLEN - 1] = '\0';
-
   // Check if port path is provided as second argument
-  if (info.Length() >= 2) {
-    if (info[1].IsString()) {
-      std::string portStr = info[1].As<Napi::String>().Utf8Value();
+  bool has_port = false;
+  port_path[0] = '\0';
+
+  if (info.Length() >= 2 && info[1].IsString()) {
+    std::string portStr = info[1].As<Napi::String>().Utf8Value();
+    if (!portStr.empty()) {
       strncpy(port_path, portStr.c_str(), SHIM_HAMLIB_FILPATHLEN - 1);
       port_path[SHIM_HAMLIB_FILPATHLEN - 1] = '\0';
+      has_port = true;
     }
-    // Note: Debug level is now controlled globally via HamLib.setDebugLevel()
-    // and set to RIG_DEBUG_NONE by default in addon initialization
   }
   //unsigned int myrig_model;
   //   hamlib_port_t myport;
@@ -2242,13 +2240,16 @@ NodeHamLib::NodeHamLib(const Napi::CallbackInfo & info): ObjectWrap(info) {
     Napi::TypeError::New(env, errorMsg).ThrowAsJavaScriptException();
   }
   
-  // Set port path and type based on connection type
-  shim_rig_set_port_path(my_rig, port_path);
+  // Only set port path and type when user explicitly provided a port.
+  // Otherwise, let rig_init() defaults take effect (e.g., dummy rig uses RIG_PORT_NONE).
+  if (has_port) {
+    shim_rig_set_port_path(my_rig, port_path);
 
-  if (is_network_rig) {
-    shim_rig_set_port_type(my_rig, SHIM_RIG_PORT_NETWORK);
-  } else {
-    shim_rig_set_port_type(my_rig, SHIM_RIG_PORT_SERIAL);
+    if (is_network_rig) {
+      shim_rig_set_port_type(my_rig, SHIM_RIG_PORT_NETWORK);
+    } else {
+      shim_rig_set_port_type(my_rig, SHIM_RIG_PORT_SERIAL);
+    }
   }
 
   // this->freq_emit_cb = [info](double freq) {
@@ -3701,6 +3702,46 @@ Napi::Function NodeHamLib::GetClass(Napi::Env env) {
       // Reset Function
       NodeHamLib::InstanceMethod("reset", & NodeHamLib::Reset),
 
+      // Lock Mode (Hamlib >= 4.7.0)
+      NodeHamLib::InstanceMethod("setLockMode", & NodeHamLib::SetLockMode),
+      NodeHamLib::InstanceMethod("getLockMode", & NodeHamLib::GetLockMode),
+
+      // Clock (Hamlib >= 4.7.0)
+      NodeHamLib::InstanceMethod("setClock", & NodeHamLib::SetClock),
+      NodeHamLib::InstanceMethod("getClock", & NodeHamLib::GetClock),
+
+      // VFO Info (Hamlib >= 4.7.0)
+      NodeHamLib::InstanceMethod("getVfoInfo", & NodeHamLib::GetVfoInfo),
+
+      // Rig Info / Raw / Conf (async)
+      NodeHamLib::InstanceMethod("getInfo", & NodeHamLib::GetInfo),
+      NodeHamLib::InstanceMethod("sendRaw", & NodeHamLib::SendRaw),
+      NodeHamLib::InstanceMethod("setConf", & NodeHamLib::SetConf),
+      NodeHamLib::InstanceMethod("getConf", & NodeHamLib::GetConf),
+
+      // Passband / Resolution (sync)
+      NodeHamLib::InstanceMethod("getPassbandNormal", & NodeHamLib::GetPassbandNormal),
+      NodeHamLib::InstanceMethod("getPassbandNarrow", & NodeHamLib::GetPassbandNarrow),
+      NodeHamLib::InstanceMethod("getPassbandWide", & NodeHamLib::GetPassbandWide),
+      NodeHamLib::InstanceMethod("getResolution", & NodeHamLib::GetResolution),
+
+      // Capability queries (sync)
+      NodeHamLib::InstanceMethod("getSupportedParms", & NodeHamLib::GetSupportedParms),
+      NodeHamLib::InstanceMethod("getSupportedVfoOps", & NodeHamLib::GetSupportedVfoOps),
+      NodeHamLib::InstanceMethod("getSupportedScanTypes", & NodeHamLib::GetSupportedScanTypes),
+
+      // Capability queries - batch 2 (sync)
+      NodeHamLib::InstanceMethod("getPreampValues", & NodeHamLib::GetPreampValues),
+      NodeHamLib::InstanceMethod("getAttenuatorValues", & NodeHamLib::GetAttenuatorValues),
+      NodeHamLib::InstanceMethod("getMaxRit", & NodeHamLib::GetMaxRit),
+      NodeHamLib::InstanceMethod("getMaxXit", & NodeHamLib::GetMaxXit),
+      NodeHamLib::InstanceMethod("getMaxIfShift", & NodeHamLib::GetMaxIfShift),
+      NodeHamLib::InstanceMethod("getAvailableCtcssTones", & NodeHamLib::GetAvailableCtcssTones),
+      NodeHamLib::InstanceMethod("getAvailableDcsCodes", & NodeHamLib::GetAvailableDcsCodes),
+      NodeHamLib::InstanceMethod("getFrequencyRanges", & NodeHamLib::GetFrequencyRanges),
+      NodeHamLib::InstanceMethod("getTuningSteps", & NodeHamLib::GetTuningSteps),
+      NodeHamLib::InstanceMethod("getFilterList", & NodeHamLib::GetFilterList),
+
       NodeHamLib::InstanceMethod("close", & NodeHamLib::Close),
       NodeHamLib::InstanceMethod("destroy", & NodeHamLib::Destroy),
       NodeHamLib::InstanceMethod("getConnectionInfo", & NodeHamLib::GetConnectionInfo),
@@ -3710,6 +3751,8 @@ Napi::Function NodeHamLib::GetClass(Napi::Env env) {
       NodeHamLib::StaticMethod("getHamlibVersion", & NodeHamLib::GetHamlibVersion),
       NodeHamLib::StaticMethod("setDebugLevel", & NodeHamLib::SetDebugLevel),
       NodeHamLib::StaticMethod("getDebugLevel", & NodeHamLib::GetDebugLevel),
+      NodeHamLib::StaticMethod("getCopyright", & NodeHamLib::GetCopyright),
+      NodeHamLib::StaticMethod("getLicense", & NodeHamLib::GetLicense),
     });
       constructor = Napi::Persistent(ret);
       constructor.SuppressDestruct();
@@ -5358,3 +5401,774 @@ Napi::Value NodeHamLib::Reset(const Napi::CallbackInfo& info) {
   asyncWorker->Queue();
   return asyncWorker->GetPromise();
 }
+
+// ===== Lock Mode (Hamlib >= 4.7.0) =====
+
+class SetLockModeAsyncWorker : public HamLibAsyncWorker {
+public:
+    SetLockModeAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance, int lock)
+        : HamLibAsyncWorker(env, hamlib_instance), lock_(lock) {}
+
+    void Execute() override {
+        CHECK_RIG_VALID();
+        result_code_ = shim_rig_set_lock_mode(hamlib_instance_->my_rig, lock_);
+        if (result_code_ != SHIM_RIG_OK) {
+            error_message_ = shim_rigerror(result_code_);
+        }
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        if (result_code_ != SHIM_RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
+    }
+
+    void OnError(const Napi::Error& e) override {
+        deferred_.Reject(Napi::Error::New(Env(), error_message_).Value());
+    }
+
+private:
+    int lock_;
+};
+
+class GetLockModeAsyncWorker : public HamLibAsyncWorker {
+public:
+    GetLockModeAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance)
+        : HamLibAsyncWorker(env, hamlib_instance), lock_(0) {}
+
+    void Execute() override {
+        CHECK_RIG_VALID();
+        result_code_ = shim_rig_get_lock_mode(hamlib_instance_->my_rig, &lock_);
+        if (result_code_ != SHIM_RIG_OK) {
+            error_message_ = shim_rigerror(result_code_);
+        }
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        if (result_code_ != SHIM_RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, lock_));
+        }
+    }
+
+    void OnError(const Napi::Error& e) override {
+        deferred_.Reject(Napi::Error::New(Env(), error_message_).Value());
+    }
+
+private:
+    int lock_;
+};
+
+Napi::Value NodeHamLib::SetLockMode(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsNumber()) {
+    Napi::TypeError::New(env, "Expected lock mode as number").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int lock = info[0].As<Napi::Number>().Int32Value();
+
+  SetLockModeAsyncWorker* asyncWorker = new SetLockModeAsyncWorker(env, this, lock);
+  asyncWorker->Queue();
+  return asyncWorker->GetPromise();
+}
+
+Napi::Value NodeHamLib::GetLockMode(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  GetLockModeAsyncWorker* asyncWorker = new GetLockModeAsyncWorker(env, this);
+  asyncWorker->Queue();
+  return asyncWorker->GetPromise();
+}
+
+// ===== Clock (Hamlib >= 4.7.0) =====
+
+class SetClockAsyncWorker : public HamLibAsyncWorker {
+public:
+    SetClockAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance,
+                        int year, int month, int day,
+                        int hour, int min, int sec, double msec, int utc_offset)
+        : HamLibAsyncWorker(env, hamlib_instance),
+          year_(year), month_(month), day_(day),
+          hour_(hour), min_(min), sec_(sec), msec_(msec), utc_offset_(utc_offset) {}
+
+    void Execute() override {
+        CHECK_RIG_VALID();
+        result_code_ = shim_rig_set_clock(hamlib_instance_->my_rig,
+                                           year_, month_, day_,
+                                           hour_, min_, sec_, msec_, utc_offset_);
+        if (result_code_ != SHIM_RIG_OK) {
+            error_message_ = shim_rigerror(result_code_);
+        }
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        if (result_code_ != SHIM_RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
+    }
+
+    void OnError(const Napi::Error& e) override {
+        deferred_.Reject(Napi::Error::New(Env(), error_message_).Value());
+    }
+
+private:
+    int year_, month_, day_, hour_, min_, sec_;
+    double msec_;
+    int utc_offset_;
+};
+
+class GetClockAsyncWorker : public HamLibAsyncWorker {
+public:
+    GetClockAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance)
+        : HamLibAsyncWorker(env, hamlib_instance),
+          year_(0), month_(0), day_(0),
+          hour_(0), min_(0), sec_(0), msec_(0.0), utc_offset_(0) {}
+
+    void Execute() override {
+        CHECK_RIG_VALID();
+        result_code_ = shim_rig_get_clock(hamlib_instance_->my_rig,
+                                           &year_, &month_, &day_,
+                                           &hour_, &min_, &sec_, &msec_, &utc_offset_);
+        if (result_code_ != SHIM_RIG_OK) {
+            error_message_ = shim_rigerror(result_code_);
+        }
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        if (result_code_ != SHIM_RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            obj.Set("year", Napi::Number::New(env, year_));
+            obj.Set("month", Napi::Number::New(env, month_));
+            obj.Set("day", Napi::Number::New(env, day_));
+            obj.Set("hour", Napi::Number::New(env, hour_));
+            obj.Set("min", Napi::Number::New(env, min_));
+            obj.Set("sec", Napi::Number::New(env, sec_));
+            obj.Set("msec", Napi::Number::New(env, msec_));
+            obj.Set("utcOffset", Napi::Number::New(env, utc_offset_));
+            deferred_.Resolve(obj);
+        }
+    }
+
+    void OnError(const Napi::Error& e) override {
+        deferred_.Reject(Napi::Error::New(Env(), error_message_).Value());
+    }
+
+private:
+    int year_, month_, day_, hour_, min_, sec_;
+    double msec_;
+    int utc_offset_;
+};
+
+Napi::Value NodeHamLib::SetClock(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsObject()) {
+    Napi::TypeError::New(env, "Expected clock object with year, month, day, hour, min, sec, msec, utcOffset").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object obj = info[0].As<Napi::Object>();
+
+  auto getInt = [&](const char* key, int defaultVal) -> int {
+    if (obj.Has(key) && obj.Get(key).IsNumber()) {
+      return obj.Get(key).As<Napi::Number>().Int32Value();
+    }
+    return defaultVal;
+  };
+  auto getDouble = [&](const char* key, double defaultVal) -> double {
+    if (obj.Has(key) && obj.Get(key).IsNumber()) {
+      return obj.Get(key).As<Napi::Number>().DoubleValue();
+    }
+    return defaultVal;
+  };
+
+  int year = getInt("year", 0);
+  int month = getInt("month", 0);
+  int day = getInt("day", 0);
+  int hour = getInt("hour", 0);
+  int min = getInt("min", 0);
+  int sec = getInt("sec", 0);
+  double msec = getDouble("msec", 0.0);
+  int utcOffset = getInt("utcOffset", 0);
+
+  SetClockAsyncWorker* asyncWorker = new SetClockAsyncWorker(env, this,
+      year, month, day, hour, min, sec, msec, utcOffset);
+  asyncWorker->Queue();
+  return asyncWorker->GetPromise();
+}
+
+Napi::Value NodeHamLib::GetClock(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  GetClockAsyncWorker* asyncWorker = new GetClockAsyncWorker(env, this);
+  asyncWorker->Queue();
+  return asyncWorker->GetPromise();
+}
+
+// ===== VFO Info (Hamlib >= 4.7.0) =====
+
+class GetVfoInfoAsyncWorker : public HamLibAsyncWorker {
+public:
+    GetVfoInfoAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance, int vfo)
+        : HamLibAsyncWorker(env, hamlib_instance),
+          vfo_(vfo), freq_(0.0), mode_(0), width_(0), split_(0), satmode_(0) {}
+
+    void Execute() override {
+        CHECK_RIG_VALID();
+        result_code_ = shim_rig_get_vfo_info(hamlib_instance_->my_rig, vfo_,
+                                              &freq_, &mode_, &width_, &split_, &satmode_);
+        if (result_code_ != SHIM_RIG_OK) {
+            error_message_ = shim_rigerror(result_code_);
+        }
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        if (result_code_ != SHIM_RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            obj.Set("frequency", Napi::Number::New(env, freq_));
+            obj.Set("mode", Napi::String::New(env, shim_rig_strrmode(static_cast<int>(mode_))));
+            obj.Set("bandwidth", Napi::Number::New(env, static_cast<double>(width_)));
+            obj.Set("split", Napi::Boolean::New(env, split_ != 0));
+            obj.Set("satMode", Napi::Boolean::New(env, satmode_ != 0));
+            deferred_.Resolve(obj);
+        }
+    }
+
+    void OnError(const Napi::Error& e) override {
+        deferred_.Reject(Napi::Error::New(Env(), error_message_).Value());
+    }
+
+private:
+    int vfo_;
+    double freq_;
+    uint64_t mode_;
+    long width_;
+    int split_;
+    int satmode_;
+};
+
+Napi::Value NodeHamLib::GetVfoInfo(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  int vfo = parseVfoParameter(info, 0, SHIM_RIG_VFO_CURR);
+
+  GetVfoInfoAsyncWorker* asyncWorker = new GetVfoInfoAsyncWorker(env, this, vfo);
+  asyncWorker->Queue();
+  return asyncWorker->GetPromise();
+}
+
+// ===== GetInfo (async) =====
+
+class GetInfoAsyncWorker : public HamLibAsyncWorker {
+public:
+    GetInfoAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance)
+        : HamLibAsyncWorker(env, hamlib_instance) {}
+
+    void Execute() override {
+        CHECK_RIG_VALID();
+        const char* info = shim_rig_get_info(hamlib_instance_->my_rig);
+        info_str_ = info ? info : "";
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        deferred_.Resolve(Napi::String::New(env, info_str_));
+    }
+
+    void OnError(const Napi::Error& e) override {
+        deferred_.Reject(Napi::Error::New(Env(), error_message_).Value());
+    }
+
+private:
+    std::string info_str_;
+};
+
+Napi::Value NodeHamLib::GetInfo(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (!rig_is_open) {
+    Napi::TypeError::New(env, "Rig is not open!").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  GetInfoAsyncWorker* asyncWorker = new GetInfoAsyncWorker(env, this);
+  asyncWorker->Queue();
+  return asyncWorker->GetPromise();
+}
+
+// ===== SendRaw (async) =====
+
+class SendRawAsyncWorker : public HamLibAsyncWorker {
+public:
+    SendRawAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance,
+                       std::vector<unsigned char> send_data, int reply_max_len,
+                       std::vector<unsigned char> terminator, bool has_terminator)
+        : HamLibAsyncWorker(env, hamlib_instance),
+          send_data_(std::move(send_data)), reply_max_len_(reply_max_len),
+          terminator_(std::move(terminator)), has_terminator_(has_terminator),
+          reply_len_(0) {
+        reply_buf_.resize(reply_max_len > 0 ? reply_max_len : 1);
+    }
+
+    void Execute() override {
+        CHECK_RIG_VALID();
+        const unsigned char* term = has_terminator_ ? terminator_.data() : nullptr;
+        result_code_ = shim_rig_send_raw(hamlib_instance_->my_rig,
+            send_data_.data(), (int)send_data_.size(),
+            reply_buf_.data(), reply_max_len_, term);
+        if (result_code_ < 0) {
+            error_message_ = shim_rigerror(result_code_);
+        } else {
+            reply_len_ = result_code_;
+            result_code_ = SHIM_RIG_OK;
+        }
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        if (!error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Buffer<unsigned char>::Copy(env, reply_buf_.data(), reply_len_));
+        }
+    }
+
+    void OnError(const Napi::Error& e) override {
+        deferred_.Reject(Napi::Error::New(Env(), error_message_).Value());
+    }
+
+private:
+    std::vector<unsigned char> send_data_;
+    int reply_max_len_;
+    std::vector<unsigned char> terminator_;
+    bool has_terminator_;
+    std::vector<unsigned char> reply_buf_;
+    int reply_len_;
+};
+
+Napi::Value NodeHamLib::SendRaw(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (!rig_is_open) {
+    Napi::TypeError::New(env, "Rig is not open!").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (info.Length() < 2 || !info[0].IsBuffer() || !info[1].IsNumber()) {
+    Napi::TypeError::New(env, "Expected (data: Buffer, replyMaxLen: number, terminator?: Buffer)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Buffer<unsigned char> dataBuf = info[0].As<Napi::Buffer<unsigned char>>();
+  std::vector<unsigned char> send_data(dataBuf.Data(), dataBuf.Data() + dataBuf.Length());
+  int replyMaxLen = info[1].As<Napi::Number>().Int32Value();
+
+  std::vector<unsigned char> terminator;
+  bool has_terminator = false;
+  if (info.Length() >= 3 && info[2].IsBuffer()) {
+    Napi::Buffer<unsigned char> termBuf = info[2].As<Napi::Buffer<unsigned char>>();
+    terminator.assign(termBuf.Data(), termBuf.Data() + termBuf.Length());
+    has_terminator = true;
+  }
+
+  SendRawAsyncWorker* asyncWorker = new SendRawAsyncWorker(env, this, std::move(send_data), replyMaxLen, std::move(terminator), has_terminator);
+  asyncWorker->Queue();
+  return asyncWorker->GetPromise();
+}
+
+// ===== SetConf (async) =====
+
+class SetConfAsyncWorker : public HamLibAsyncWorker {
+public:
+    SetConfAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance,
+                       std::string name, std::string value)
+        : HamLibAsyncWorker(env, hamlib_instance),
+          name_(std::move(name)), value_(std::move(value)) {}
+
+    void Execute() override {
+        CHECK_RIG_VALID();
+        result_code_ = shim_rig_set_conf(hamlib_instance_->my_rig, name_.c_str(), value_.c_str());
+        if (result_code_ != SHIM_RIG_OK) {
+            error_message_ = shim_rigerror(result_code_);
+        }
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        if (result_code_ != SHIM_RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
+    }
+
+    void OnError(const Napi::Error& e) override {
+        deferred_.Reject(Napi::Error::New(Env(), error_message_).Value());
+    }
+
+private:
+    std::string name_;
+    std::string value_;
+};
+
+Napi::Value NodeHamLib::SetConf(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (!rig_is_open) {
+    Napi::TypeError::New(env, "Rig is not open!").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (info.Length() < 2 || !info[0].IsString() || !info[1].IsString()) {
+    Napi::TypeError::New(env, "Expected (name: string, value: string)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+  std::string value = info[1].As<Napi::String>().Utf8Value();
+
+  SetConfAsyncWorker* asyncWorker = new SetConfAsyncWorker(env, this, std::move(name), std::move(value));
+  asyncWorker->Queue();
+  return asyncWorker->GetPromise();
+}
+
+// ===== GetConf (async) =====
+
+class GetConfAsyncWorker : public HamLibAsyncWorker {
+public:
+    GetConfAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance, std::string name)
+        : HamLibAsyncWorker(env, hamlib_instance), name_(std::move(name)) {
+        memset(buf_, 0, sizeof(buf_));
+    }
+
+    void Execute() override {
+        CHECK_RIG_VALID();
+        result_code_ = shim_rig_get_conf(hamlib_instance_->my_rig, name_.c_str(), buf_, sizeof(buf_));
+        if (result_code_ != SHIM_RIG_OK) {
+            error_message_ = shim_rigerror(result_code_);
+        }
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        if (result_code_ != SHIM_RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::String::New(env, buf_));
+        }
+    }
+
+    void OnError(const Napi::Error& e) override {
+        deferred_.Reject(Napi::Error::New(Env(), error_message_).Value());
+    }
+
+private:
+    std::string name_;
+    char buf_[256];
+};
+
+Napi::Value NodeHamLib::GetConf(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (!rig_is_open) {
+    Napi::TypeError::New(env, "Rig is not open!").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Expected (name: string)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+
+  GetConfAsyncWorker* asyncWorker = new GetConfAsyncWorker(env, this, std::move(name));
+  asyncWorker->Queue();
+  return asyncWorker->GetPromise();
+}
+
+// ===== Passband methods (sync) =====
+
+Napi::Value NodeHamLib::GetPassbandNormal(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Expected (mode: string)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string modeStr = info[0].As<Napi::String>().Utf8Value();
+  int mode = shim_rig_parse_mode(modeStr.c_str());
+  int pb = shim_rig_passband_normal(my_rig, mode);
+  return Napi::Number::New(env, pb);
+}
+
+Napi::Value NodeHamLib::GetPassbandNarrow(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Expected (mode: string)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string modeStr = info[0].As<Napi::String>().Utf8Value();
+  int mode = shim_rig_parse_mode(modeStr.c_str());
+  int pb = shim_rig_passband_narrow(my_rig, mode);
+  return Napi::Number::New(env, pb);
+}
+
+Napi::Value NodeHamLib::GetPassbandWide(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Expected (mode: string)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string modeStr = info[0].As<Napi::String>().Utf8Value();
+  int mode = shim_rig_parse_mode(modeStr.c_str());
+  int pb = shim_rig_passband_wide(my_rig, mode);
+  return Napi::Number::New(env, pb);
+}
+
+// ===== Resolution (sync) =====
+
+Napi::Value NodeHamLib::GetResolution(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Expected (mode: string)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string modeStr = info[0].As<Napi::String>().Utf8Value();
+  int mode = shim_rig_parse_mode(modeStr.c_str());
+  int res = shim_rig_get_resolution(my_rig, mode);
+  return Napi::Number::New(env, res);
+}
+
+// ===== getSupportedParms (sync) =====
+
+Napi::Value NodeHamLib::GetSupportedParms(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  uint64_t parms = shim_rig_get_caps_has_get_parm(my_rig) | shim_rig_get_caps_has_set_parm(my_rig);
+  Napi::Array parmArray = Napi::Array::New(env);
+  uint32_t index = 0;
+
+  if (parms & SHIM_RIG_PARM_ANN) parmArray[index++] = Napi::String::New(env, "ANN");
+  if (parms & SHIM_RIG_PARM_APO) parmArray[index++] = Napi::String::New(env, "APO");
+  if (parms & SHIM_RIG_PARM_BACKLIGHT) parmArray[index++] = Napi::String::New(env, "BACKLIGHT");
+  if (parms & SHIM_RIG_PARM_BEEP) parmArray[index++] = Napi::String::New(env, "BEEP");
+  if (parms & SHIM_RIG_PARM_TIME) parmArray[index++] = Napi::String::New(env, "TIME");
+  if (parms & SHIM_RIG_PARM_BAT) parmArray[index++] = Napi::String::New(env, "BAT");
+  if (parms & SHIM_RIG_PARM_KEYLIGHT) parmArray[index++] = Napi::String::New(env, "KEYLIGHT");
+  if (parms & SHIM_RIG_PARM_SCREENSAVER) parmArray[index++] = Napi::String::New(env, "SCREENSAVER");
+
+  return parmArray;
+}
+
+// ===== getSupportedVfoOps (sync) =====
+
+Napi::Value NodeHamLib::GetSupportedVfoOps(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  int ops = shim_rig_get_caps_vfo_ops(my_rig);
+  Napi::Array opsArray = Napi::Array::New(env);
+  uint32_t index = 0;
+
+  if (ops & SHIM_RIG_OP_CPY) opsArray[index++] = Napi::String::New(env, "CPY");
+  if (ops & SHIM_RIG_OP_XCHG) opsArray[index++] = Napi::String::New(env, "XCHG");
+  if (ops & SHIM_RIG_OP_FROM_VFO) opsArray[index++] = Napi::String::New(env, "FROM_VFO");
+  if (ops & SHIM_RIG_OP_TO_VFO) opsArray[index++] = Napi::String::New(env, "TO_VFO");
+  if (ops & SHIM_RIG_OP_MCL) opsArray[index++] = Napi::String::New(env, "MCL");
+  if (ops & SHIM_RIG_OP_UP) opsArray[index++] = Napi::String::New(env, "UP");
+  if (ops & SHIM_RIG_OP_DOWN) opsArray[index++] = Napi::String::New(env, "DOWN");
+  if (ops & SHIM_RIG_OP_BAND_UP) opsArray[index++] = Napi::String::New(env, "BAND_UP");
+  if (ops & SHIM_RIG_OP_BAND_DOWN) opsArray[index++] = Napi::String::New(env, "BAND_DOWN");
+  if (ops & SHIM_RIG_OP_LEFT) opsArray[index++] = Napi::String::New(env, "LEFT");
+  if (ops & SHIM_RIG_OP_RIGHT) opsArray[index++] = Napi::String::New(env, "RIGHT");
+  if (ops & SHIM_RIG_OP_TUNE) opsArray[index++] = Napi::String::New(env, "TUNE");
+  if (ops & SHIM_RIG_OP_TOGGLE) opsArray[index++] = Napi::String::New(env, "TOGGLE");
+
+  return opsArray;
+}
+
+// ===== getSupportedScanTypes (sync) =====
+
+Napi::Value NodeHamLib::GetSupportedScanTypes(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  int scan = shim_rig_get_caps_has_scan(my_rig);
+  Napi::Array scanArray = Napi::Array::New(env);
+  uint32_t index = 0;
+
+  if (scan & SHIM_RIG_SCAN_MEM) scanArray[index++] = Napi::String::New(env, "MEM");
+  if (scan & SHIM_RIG_SCAN_VFO) scanArray[index++] = Napi::String::New(env, "VFO");
+  if (scan & SHIM_RIG_SCAN_PROG) scanArray[index++] = Napi::String::New(env, "PROG");
+  if (scan & SHIM_RIG_SCAN_DELTA) scanArray[index++] = Napi::String::New(env, "DELTA");
+  if (scan & SHIM_RIG_SCAN_PRIO) scanArray[index++] = Napi::String::New(env, "PRIO");
+
+  return scanArray;
+}
+
+// ===== Capability Query Batch 2 (sync) =====
+
+// Helper: convert mode bitmask to array of mode strings
+static Napi::Array ModeBitmaskToArray(Napi::Env env, uint64_t modes) {
+  Napi::Array arr = Napi::Array::New(env);
+  uint32_t idx = 0;
+  for (unsigned int i = 0; i < SHIM_HAMLIB_MAX_MODES; i++) {
+    uint64_t bit = modes & (1ULL << i);
+    if (bit) {
+      const char* name = shim_rig_strrmode(bit);
+      if (name && name[0] != '\0') {
+        arr[idx++] = Napi::String::New(env, name);
+      }
+    }
+  }
+  return arr;
+}
+
+Napi::Value NodeHamLib::GetPreampValues(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int buf[SHIM_HAMLIB_MAX_MODES];
+  int count = shim_rig_get_caps_preamp(my_rig, buf, SHIM_HAMLIB_MAX_MODES);
+  Napi::Array arr = Napi::Array::New(env, count);
+  for (int i = 0; i < count; i++) {
+    arr[(uint32_t)i] = Napi::Number::New(env, buf[i]);
+  }
+  return arr;
+}
+
+Napi::Value NodeHamLib::GetAttenuatorValues(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int buf[SHIM_HAMLIB_MAX_MODES];
+  int count = shim_rig_get_caps_attenuator(my_rig, buf, SHIM_HAMLIB_MAX_MODES);
+  Napi::Array arr = Napi::Array::New(env, count);
+  for (int i = 0; i < count; i++) {
+    arr[(uint32_t)i] = Napi::Number::New(env, buf[i]);
+  }
+  return arr;
+}
+
+Napi::Value NodeHamLib::GetMaxRit(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(info.Env(), (double)shim_rig_get_caps_max_rit(my_rig));
+}
+
+Napi::Value NodeHamLib::GetMaxXit(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(info.Env(), (double)shim_rig_get_caps_max_xit(my_rig));
+}
+
+Napi::Value NodeHamLib::GetMaxIfShift(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(info.Env(), (double)shim_rig_get_caps_max_ifshift(my_rig));
+}
+
+Napi::Value NodeHamLib::GetAvailableCtcssTones(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  unsigned int buf[256];
+  int count = shim_rig_get_caps_ctcss_list(my_rig, buf, 256);
+  Napi::Array arr = Napi::Array::New(env, count);
+  for (int i = 0; i < count; i++) {
+    // CTCSS tones stored as tenths of Hz, convert to Hz
+    arr[(uint32_t)i] = Napi::Number::New(env, buf[i] / 10.0);
+  }
+  return arr;
+}
+
+Napi::Value NodeHamLib::GetAvailableDcsCodes(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  unsigned int buf[256];
+  int count = shim_rig_get_caps_dcs_list(my_rig, buf, 256);
+  Napi::Array arr = Napi::Array::New(env, count);
+  for (int i = 0; i < count; i++) {
+    arr[(uint32_t)i] = Napi::Number::New(env, buf[i]);
+  }
+  return arr;
+}
+
+Napi::Value NodeHamLib::GetFrequencyRanges(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  shim_freq_range_t rx_buf[30];
+  shim_freq_range_t tx_buf[30];
+  int rx_count = shim_rig_get_caps_rx_range(my_rig, rx_buf, 30);
+  int tx_count = shim_rig_get_caps_tx_range(my_rig, tx_buf, 30);
+
+  auto buildArray = [&](shim_freq_range_t* buf, int count) -> Napi::Array {
+    Napi::Array arr = Napi::Array::New(env, count);
+    for (int i = 0; i < count; i++) {
+      Napi::Object obj = Napi::Object::New(env);
+      obj.Set("startFreq", Napi::Number::New(env, buf[i].start_freq));
+      obj.Set("endFreq", Napi::Number::New(env, buf[i].end_freq));
+      obj.Set("modes", ModeBitmaskToArray(env, buf[i].modes));
+      obj.Set("lowPower", Napi::Number::New(env, buf[i].low_power));
+      obj.Set("highPower", Napi::Number::New(env, buf[i].high_power));
+      obj.Set("vfo", Napi::Number::New(env, buf[i].vfo));
+      obj.Set("antenna", Napi::Number::New(env, buf[i].ant));
+      arr[(uint32_t)i] = obj;
+    }
+    return arr;
+  };
+
+  Napi::Object result = Napi::Object::New(env);
+  result.Set("rx", buildArray(rx_buf, rx_count));
+  result.Set("tx", buildArray(tx_buf, tx_count));
+  return result;
+}
+
+Napi::Value NodeHamLib::GetTuningSteps(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  shim_mode_value_t buf[20];
+  int count = shim_rig_get_caps_tuning_steps(my_rig, buf, 20);
+  Napi::Array arr = Napi::Array::New(env, count);
+  for (int i = 0; i < count; i++) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("modes", ModeBitmaskToArray(env, buf[i].modes));
+    obj.Set("stepHz", Napi::Number::New(env, buf[i].value));
+    arr[(uint32_t)i] = obj;
+  }
+  return arr;
+}
+
+Napi::Value NodeHamLib::GetFilterList(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  shim_mode_value_t buf[60];
+  int count = shim_rig_get_caps_filters(my_rig, buf, 60);
+  Napi::Array arr = Napi::Array::New(env, count);
+  for (int i = 0; i < count; i++) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("modes", ModeBitmaskToArray(env, buf[i].modes));
+    obj.Set("width", Napi::Number::New(env, buf[i].value));
+    arr[(uint32_t)i] = obj;
+  }
+  return arr;
+}
+
+// ===== Static: getCopyright / getLicense =====
+
+Napi::Value NodeHamLib::GetCopyright(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::String::New(env, shim_rig_copyright());
+}
+
+Napi::Value NodeHamLib::GetLicense(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::String::New(env, shim_rig_license());
+}