fix: add fallback for getLevel on rigs with VFO switching issues

rig_get_level() fails on ICOM serial rigs (e.g. IC-705) because
Hamlib's VFO resolution triggers icom_set_vfo which returns
"unsupported VFO".

The shim layer now tries the standard rig_get_level() first, and
if it fails with RIG_EINVAL (-1), falls back to calling the backend's
get_level() directly, bypassing VFO switching.

Also adds optional VFO parameter to getLevel() JS API.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: boybook

index.d.ts

@@ -542,9 +542,10 @@ declare class HamLib {
   /**
    * Get radio level
    * @param levelType Level type ('AF', 'RF', 'SQL', 'STRENGTH', etc.)
+   * @param vfo Optional VFO ('VFO-A', 'VFO-B', 'currVFO'). Defaults to currVFO.
    * @returns Level value
    */
-  getLevel(levelType: LevelType): Promise<number>;
+  getLevel(levelType: LevelType, vfo?: string): Promise<number>;
 
   /**
    * Get list of supported level types

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Node.js wrapper for hamlib radio control library",
   "main": "index.js",
   "module": "lib/index.mjs",

src/hamlib.cpp

@@ -280,7 +280,7 @@ class SetLevelAsyncWorker : public HamLibAsyncWorker {
     void Execute() override {
         CHECK_RIG_VALID();
 
-        result_code_ = shim_rig_set_level_f(hamlib_instance_->my_rig, SHIM_RIG_VFO_NONE, level_type_, value_);
+        result_code_ = shim_rig_set_level_f(hamlib_instance_->my_rig, SHIM_RIG_VFO_CURR, level_type_, value_);
         if (result_code_ != SHIM_RIG_OK) {
             error_message_ = shim_rigerror(result_code_);
         }
@@ -307,15 +307,13 @@ class SetLevelAsyncWorker : public HamLibAsyncWorker {
 
 class GetLevelAsyncWorker : public HamLibAsyncWorker {
 public:
-    GetLevelAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance, uint64_t level_type)
-        : HamLibAsyncWorker(env, hamlib_instance), level_type_(level_type), value_(0.0f) {}
+    GetLevelAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance, uint64_t level_type, int vfo = SHIM_RIG_VFO_CURR)
+        : HamLibAsyncWorker(env, hamlib_instance), level_type_(level_type), vfo_(vfo), value_(0.0f) {}
 
     void Execute() override {
         CHECK_RIG_VALID();
 
-        // Use RIG_VFO_NONE to avoid unnecessary VFO switching that fails on
-        // ICOM rigs (e.g. IC-705) where icom_set_vfo returns "unsupported VFO"
-        result_code_ = shim_rig_get_level_f(hamlib_instance_->my_rig, SHIM_RIG_VFO_NONE, level_type_, &value_);
+        result_code_ = shim_rig_get_level_f(hamlib_instance_->my_rig, vfo_, level_type_, &value_);
         if (result_code_ != SHIM_RIG_OK) {
             error_message_ = shim_rigerror(result_code_);
         }
@@ -337,6 +335,7 @@ class GetLevelAsyncWorker : public HamLibAsyncWorker {
 
 private:
     uint64_t level_type_;
+    int vfo_;
     float value_;
 };
 
@@ -2974,9 +2973,20 @@ Napi::Value NodeHamLib::GetLevel(const Napi::CallbackInfo & info) {
     return env.Null();
   }
 
-  GetLevelAsyncWorker* worker = new GetLevelAsyncWorker(env, this, levelType);
+  // Optional second parameter: VFO string ('VFO-A', 'VFO-B', 'currVFO')
+  int vfo = SHIM_RIG_VFO_CURR;
+  if (info.Length() >= 2 && info[1].IsString()) {
+    std::string vfoStr = info[1].As<Napi::String>().Utf8Value();
+    if (vfoStr == "VFO-A") {
+      vfo = SHIM_RIG_VFO_A;
+    } else if (vfoStr == "VFO-B") {
+      vfo = SHIM_RIG_VFO_B;
+    }
+  }
+
+  GetLevelAsyncWorker* worker = new GetLevelAsyncWorker(env, this, levelType, vfo);
   worker->Queue();
-  
+
   return worker->GetPromise();
 }
 

src/shim/hamlib_shim.c

@@ -345,18 +345,35 @@ SHIM_API int shim_rig_set_level_i(hamlib_shim_handle_t h, int vfo, uint64_t leve
     return rig_set_level((RIG*)h, (vfo_t)vfo, (setting_t)level, val);
 }
 
+/*
+ * get_level with automatic fallback:
+ * 1. Try standard rig_get_level() (with VFO handling, locking, caching)
+ * 2. If it fails with RIG_EINVAL (-1), fall back to direct backend call
+ *    to bypass VFO switching issues (e.g. ICOM serial rigs where
+ *    icom_set_vfo fails with "unsupported VFO")
+ */
+static int shim_get_level_with_fallback(hamlib_shim_handle_t h, int vfo, uint64_t level, value_t* val) {
+    RIG* rig = (RIG*)h;
+    int ret = rig_get_level(rig, (vfo_t)vfo, (setting_t)level, val);
+    if (ret == -1 && rig->caps->get_level) {
+        /* RIG_EINVAL: VFO switching failed, try direct backend call */
+        ret = rig->caps->get_level(rig, (vfo_t)vfo, (setting_t)level, val);
+    }
+    return ret;
+}
+
 SHIM_API int shim_rig_get_level_f(hamlib_shim_handle_t h, int vfo, uint64_t level, float* value) {
     value_t val;
     val.f = 0.0f;
-    int ret = rig_get_level((RIG*)h, (vfo_t)vfo, (setting_t)level, &val);
+    int ret = shim_get_level_with_fallback(h, vfo, level, &val);
     if (value) *value = val.f;
     return ret;
 }
 
 SHIM_API int shim_rig_get_level_i(hamlib_shim_handle_t h, int vfo, uint64_t level, int* value) {
     value_t val;
     val.i = 0;
-    int ret = rig_get_level((RIG*)h, (vfo_t)vfo, (setting_t)level, &val);
+    int ret = shim_get_level_with_fallback(h, vfo, level, &val);
     if (value) *value = val.i;
     return ret;
 }