hamlib 0.1.2

package/binding.gyp

@@ -0,0 +1,152 @@
+{
+  "targets": [
+    {
+      "target_name": "hamlib",
+      "sources": [ 
+        "src/hamlib.cpp",
+        "src/decoder.cpp",
+        "src/addon.cpp"
+      ],
+      "include_dirs": [
+        "include",
+        "<!@(node -p \"require('node-addon-api').include\")"
+      ],
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').gyp\")"
+      ],
+      "defines": [ 
+        "NAPI_DISABLE_CPP_EXCEPTIONS"
+      ],
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "conditions": [
+        # Linux configuration
+        ["OS==\"linux\"", {
+          "include_dirs": [
+            "/usr/include",
+            "/usr/local/include"
+          ],
+          "libraries": [
+            "-L/usr/lib",
+            "-L/usr/local/lib",
+            "-lhamlib"
+          ]
+        }],
+        # macOS configuration
+        ["OS==\"mac\"", {
+          "include_dirs": [
+            "/usr/local/include",
+            "/opt/homebrew/include"
+          ],
+          "libraries": [
+            "-L/usr/local/lib",
+            "-L/opt/homebrew/lib",
+            "-lhamlib"
+          ],
+          "xcode_settings": {
+            "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+            "CLANG_CXX_LIBRARY": "libc++",
+            "MACOSX_DEPLOYMENT_TARGET": "10.15"
+          }
+        }],
+        # Windows configuration
+        ["OS==\"win\"", {
+          "defines": [
+            "WIN32_LEAN_AND_MEAN",
+            "_WIN32_WINNT=0x0600"
+          ],
+          "conditions": [
+            ["target_arch==\"x64\"", {
+              "conditions": [
+                # Check if we're in MinGW environment (HAMLIB_ROOT is set to /mingw64)
+                ["\"<!(node -e \"console.log(process.env.HAMLIB_ROOT || '')\")\"==\"/mingw64\"", {
+                  "include_dirs": [
+                    "/mingw64/include"
+                  ],
+                  "library_dirs": [
+                    "/mingw64/lib"
+                  ],
+                  "libraries": [
+                    "-lhamlib",
+                    "-lws2_32",
+                    "-lwinmm"
+                  ],
+                  "cflags": [
+                    "-I/mingw64/include"
+                  ],
+                  "ldflags": [
+                    "-L/mingw64/lib",
+                    "-static-libgcc",
+                    "-static-libstdc++"
+                  ]
+                }, {
+                  # Traditional Windows build with Visual C++
+                  "include_dirs": [
+                    # Try environment variable in different formats
+                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/include')\")",
+                    # Fallback paths
+                    "C:/hamlib/include",
+                    "C:/Program Files/Hamlib/include", 
+                    "C:/Program Files (x86)/Hamlib/include"
+                  ],
+                  "library_dirs": [
+                    # Try environment variable paths
+                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/bin')\")",
+                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/lib')\")",
+                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/lib/x64')\")",
+                    "<!(node -e \"console.log((process.env.HAMLIB_ROOT || 'C:/hamlib') + '/lib/msvc')\")",
+                    # Fallback paths
+                    "C:/hamlib/bin",
+                    "C:/hamlib/lib",
+                    "C:/hamlib/lib/x64",
+                    "C:/hamlib/lib/Release",
+                    "C:/Program Files/Hamlib/bin",
+                    "C:/Program Files/Hamlib/lib",
+                    "C:/Program Files (x86)/Hamlib/bin",
+                    "C:/Program Files (x86)/Hamlib/lib"
+                  ],
+                  "libraries": [
+                    # Try to link against the DLL import library
+                    "libhamlib-4.dll.a",
+                    "hamlib-4.dll.a", 
+                    "libhamlib.dll.a",
+                    "hamlib.dll.a",
+                    # Fallback to static libraries if available
+                    "libhamlib-4.lib",
+                    "hamlib-4.lib",
+                    "libhamlib.lib",
+                    "hamlib.lib"
+                  ],
+                  "conditions": [
+                    # Add pthread paths only if PTHREAD_ROOT is set
+                    ["\"<!(node -e \"console.log(process.env.PTHREAD_ROOT || '')\")\"!=\"\"", {
+                      "include_dirs": [
+                        "<!(node -e \"console.log((process.env.PTHREAD_ROOT || 'C:/pthread-win32'))\")"
+                      ],
+                      "library_dirs": [
+                        "<!(node -e \"console.log((process.env.PTHREAD_ROOT || 'C:/pthread-win32') + '/lib')\")",
+                        "<!(node -e \"console.log((process.env.PTHREAD_ROOT || 'C:/pthread-win32') + '/lib/x64')\")"
+                      ],
+                      "libraries": [
+                        "pthreadVC2.lib",
+                        "pthreadVCE2.lib",
+                        "pthreadVSE2.lib",
+                        "pthread.lib"
+                      ]
+                    }]
+                  ],
+                  "msvs_settings": {
+                    "VCCLCompilerTool": {
+                      "ExceptionHandling": 1,
+                      "AdditionalOptions": ["/std:c++14"]
+                    }
+                  }
+                }]
+              ]
+            }]
+          ]
+        }]
+      ]
+    }
+  ]
+}

package/index.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Connection information interface
+ */
+interface ConnectionInfo {
+  /** Connection type: serial or network */
+  connectionType: 'serial' | 'network';
+  /** Port path or network address */
+  portPath: string;
+  /** Connection status */
+  connected: boolean;
+  /** Original model number */
+  originalModel: number;
+  /** Actual model number used */
+  actualModel: number;
+}
+
+/**
+ * Radio mode information interface
+ */
+interface ModeInfo {
+  /** Radio mode character */
+  mode: string;
+  /** Bandwidth width */
+  width: number;
+}
+
+/**
+ * VFO type
+ */
+type VFO = 'VFO-A' | 'VFO-B';
+
+/**
+ * Radio mode type
+ */
+type RadioMode = 'USB' | 'LSB' | 'FM' | 'PKTFM' | 'AM' | 'CW' | 'RTTY' | 'DIG' | string;
+
+/**
+ * HamLib class - for controlling amateur radio devices
+ */
+declare class HamLib {
+  /**
+   * Constructor
+   * @param model Radio model number (execute rigctl -l to find your device model number)
+   * @param port Optional port path
+   *   - Serial connection: '/dev/ttyUSB0' (Linux default), '/dev/cu.usbserial-XXXX' (macOS), 'COM1' (Windows)
+   *   - Network connection: 'localhost:4532' or '192.168.1.100:4532' (automatically switches to NETRIGCTL mode)
+   * 
+   * @example
+   * // Use default serial port
+   * const rig = new HamLib(1035);
+   * 
+   * // Use custom serial port
+   * const rig = new HamLib(1035, '/dev/ttyUSB1');
+   * 
+   * // Network connection to rigctld
+   * const rig = new HamLib(1035, 'localhost:4532');
+   */
+  constructor(model: number, port?: string);
+
+  /**
+   * Open connection to device
+   * Must be called before other operations
+   * @throws Throws error when connection fails
+   */
+  open(): void;
+
+  /**
+   * Set VFO (Variable Frequency Oscillator)
+   * @param vfo VFO identifier, typically 'VFO-A' or 'VFO-B'
+   * @throws Throws error when device doesn't support or operation fails
+   */
+  setVfo(vfo: VFO): void;
+
+  /**
+   * Set frequency
+   * @param frequency Frequency value in hertz
+   * @param vfo Optional VFO to set frequency on ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @example
+   * rig.setFrequency(144390000); // Set to 144.39MHz on current VFO
+   * rig.setFrequency(144390000, 'VFO-A'); // Set to 144.39MHz on VFO-A
+   * rig.setFrequency(144390000, 'VFO-B'); // Set to 144.39MHz on VFO-B
+   */
+  setFrequency(frequency: number, vfo?: VFO): void;
+
+  /**
+   * Set radio mode
+   * @param mode Radio mode (such as 'USB', 'LSB', 'FM', 'PKTFM')
+   * @param bandwidth Optional bandwidth setting ('narrow', 'wide', or default)
+   * @note Operates on the current VFO (RIG_VFO_CURR)
+   * @example
+   * rig.setMode('USB');
+   * rig.setMode('FM', 'narrow');
+   */
+  setMode(mode: RadioMode, bandwidth?: 'narrow' | 'wide'): void;
+
+  /**
+   * Set PTT (Push-to-Talk) status
+   * @param state true to enable PTT, false to disable PTT
+   * @note Operates on the current VFO (RIG_VFO_CURR)
+   */
+  setPtt(state: boolean): void;
+
+  /**
+   * Get current VFO
+   * @returns Current VFO identifier
+   */
+  getVfo(): string;
+
+  /**
+   * Get current frequency
+   * @param vfo Optional VFO to get frequency from ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @returns Current frequency value in hertz
+   * @example
+   * rig.getFrequency(); // Get frequency from current VFO
+   * rig.getFrequency('VFO-A'); // Get frequency from VFO-A
+   * rig.getFrequency('VFO-B'); // Get frequency from VFO-B
+   */
+  getFrequency(vfo?: VFO): number;
+
+  /**
+   * Get current radio mode
+   * @returns Object containing mode and bandwidth information
+   * @note Operates on the current VFO (RIG_VFO_CURR)
+   */
+  getMode(): ModeInfo;
+
+  /**
+   * Get current signal strength
+   * @returns Signal strength value
+   * @note Operates on the current VFO (RIG_VFO_CURR)
+   */
+  getStrength(): number;
+
+  /**
+   * Close connection to device
+   * Does not destroy object, can re-establish connection by calling open()
+   */
+  close(): void;
+
+  /**
+   * Destroy connection to device
+   * Should delete object reference after calling to enable garbage collection
+   */
+  destroy(): void;
+
+  /**
+   * Get connection information
+   * @returns Object containing connection type, port path, connection status, and model numbers
+   */
+  getConnectionInfo(): ConnectionInfo;
+}
+
+/**
+ * node-hamlib module export object
+ */
+declare const nodeHamlib: {
+  HamLib: typeof HamLib;
+};
+
+// Export types for use elsewhere
+export { ConnectionInfo, ModeInfo, VFO, RadioMode, HamLib };
+
+// Support both CommonJS and ES module exports
+export = nodeHamlib;
+export default nodeHamlib; 

package/index.js

@@ -0,0 +1,5 @@
+// Main entry point for the node-hamlib package
+// This file provides compatibility for different module systems
+
+// Export the main library from lib/index.js
+module.exports = require('./lib/index.js'); 

package/lib/binary-loader.js

@@ -0,0 +1,95 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Get the platform-specific binary file name
+ * @returns {string} Platform-specific binary file name
+ */
+function getPlatformBinaryPath() {
+  const platform = os.platform();
+  const arch = os.arch();
+  
+  let platformTarget;
+  
+  switch (platform) {
+    case 'win32':
+      platformTarget = `win32-${arch}`;
+      break;
+    case 'darwin':
+      platformTarget = `darwin-${arch}`;
+      break;
+    case 'linux':
+      platformTarget = `linux-${arch}`;
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}-${arch}`);
+  }
+  
+  return path.join(__dirname, '..', 'prebuilds', platformTarget, 'hamlib.node');
+}
+
+/**
+ * Find and load the native hamlib module
+ * @returns {Object} Native hamlib module
+ */
+function loadNativeModule() {
+  const possiblePaths = [
+    // First try prebuilt binary
+    getPlatformBinaryPath(),
+    // Fallback to locally compiled binary
+    path.join(__dirname, '..', 'build', 'Release', 'hamlib.node'),
+    path.join(__dirname, '..', 'build', 'Debug', 'hamlib.node'),
+    // Try different possible locations
+    path.join(__dirname, '..', 'hamlib.node'),
+    path.join(process.cwd(), 'hamlib.node'),
+    path.join(process.cwd(), 'build', 'Release', 'hamlib.node'),
+    path.join(process.cwd(), 'build', 'Debug', 'hamlib.node')
+  ];
+  
+  let lastError;
+  
+  for (const binaryPath of possiblePaths) {
+    try {
+      if (fs.existsSync(binaryPath)) {
+        console.log(`Loading hamlib native module from: ${binaryPath}`);
+        return require(binaryPath);
+      }
+    } catch (error) {
+      lastError = error;
+      console.warn(`Failed to load hamlib from ${binaryPath}: ${error.message}`);
+    }
+  }
+  
+  // If we get here, we couldn't find any working binary
+  const errorMessage = [
+    'Failed to load hamlib native module.',
+    'Tried the following paths:',
+    ...possiblePaths.map(p => `  - ${p}`),
+    '',
+    'This may be due to one of the following reasons:',
+    '1. The prebuilt binary is not available for your platform',
+    '2. The module needs to be compiled from source',
+    '3. Missing system dependencies (libhamlib)',
+    '',
+    'To compile from source, run:',
+    '  npm run build',
+    '',
+    'To install system dependencies:',
+    '  Linux: sudo apt-get install libhamlib-dev',
+    '  macOS: brew install hamlib',
+    '  Windows: Install hamlib via vcpkg or from source'
+  ].join('\n');
+  
+  const error = new Error(errorMessage);
+  if (lastError) {
+    error.originalError = lastError;
+  }
+  
+  throw error;
+}
+
+module.exports = {
+  loadNativeModule,
+  getPlatformBinaryPath
+}; 

package/lib/index.js

@@ -0,0 +1,138 @@
+const { loadNativeModule } = require('./binary-loader');
+
+// Load the native module
+const nativeModule = loadNativeModule();
+
+/**
+ * HamLib class for controlling amateur radio devices
+ * 
+ * This is a wrapper around the native hamlib module that provides
+ * a consistent interface for controlling amateur radio devices.
+ */
+class HamLib {
+  /**
+   * Create a new HamLib instance
+   * @param {number} model - Radio model number (run `rigctl -l` to find your device model)
+   * @param {string} [port] - Optional port path or network address
+   *   - Serial: '/dev/ttyUSB0' (Linux), '/dev/cu.usbserial-XXXX' (macOS), 'COM1' (Windows)
+   *   - Network: 'localhost:4532' or '192.168.1.100:4532' (auto-switches to NETRIGCTL mode)
+   */
+  constructor(model, port) {
+    this._nativeInstance = new nativeModule.HamLib(model, port);
+  }
+
+  /**
+   * Open connection to the radio device
+   * Must be called before other operations
+   * @throws {Error} Throws error when connection fails
+   */
+  open() {
+    return this._nativeInstance.open();
+  }
+
+  /**
+   * Set VFO (Variable Frequency Oscillator)
+   * @param {string} vfo - VFO identifier ('VFO-A' or 'VFO-B')
+   * @throws {Error} Throws error when device doesn't support or operation fails
+   */
+  setVfo(vfo) {
+    return this._nativeInstance.setVfo(vfo);
+  }
+
+  /**
+   * Set frequency
+   * @param {number} frequency - Frequency in hertz
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  setFrequency(frequency, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setFrequency(frequency, vfo);
+    }
+    return this._nativeInstance.setFrequency(frequency);
+  }
+
+  /**
+   * Set radio mode
+   * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', 'PKTFM', etc.)
+   * @param {string} [bandwidth] - Optional bandwidth ('narrow', 'wide')
+   */
+  setMode(mode, bandwidth) {
+    if (bandwidth) {
+      return this._nativeInstance.setMode(mode, bandwidth);
+    }
+    return this._nativeInstance.setMode(mode);
+  }
+
+  /**
+   * Set PTT (Push-to-Talk) status
+   * @param {boolean} state - true to enable PTT, false to disable
+   */
+  setPtt(state) {
+    return this._nativeInstance.setPtt(state);
+  }
+
+  /**
+   * Get current VFO
+   * @returns {string} Current VFO identifier
+   */
+  getVfo() {
+    return this._nativeInstance.getVfo();
+  }
+
+  /**
+   * Get current frequency
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {number} Current frequency in hertz
+   */
+  getFrequency(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getFrequency(vfo);
+    }
+    return this._nativeInstance.getFrequency();
+  }
+
+  /**
+   * Get current radio mode
+   * @returns {Object} Object containing mode and bandwidth information
+   */
+  getMode() {
+    return this._nativeInstance.getMode();
+  }
+
+  /**
+   * Get current signal strength
+   * @returns {number} Signal strength value
+   */
+  getStrength() {
+    return this._nativeInstance.getStrength();
+  }
+
+  /**
+   * Close connection to device
+   * Connection can be re-established by calling open()
+   */
+  close() {
+    return this._nativeInstance.close();
+  }
+
+  /**
+   * Destroy connection to device
+   * Object reference should be deleted after calling this
+   */
+  destroy() {
+    return this._nativeInstance.destroy();
+  }
+
+  /**
+   * Get connection information
+   * @returns {Object} Connection info including type, port, status, and model numbers
+   */
+  getConnectionInfo() {
+    return this._nativeInstance.getConnectionInfo();
+  }
+}
+
+// Export for CommonJS
+module.exports = { HamLib };
+module.exports.HamLib = HamLib;
+module.exports.default = { HamLib }; 

package/lib/index.mjs

@@ -0,0 +1,14 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+
+// Import the CommonJS module
+const { HamLib } = require('./index.js');
+
+// Export for ES modules
+export { HamLib };
+export default { HamLib }; 

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "hamlib",
+  "version": "0.1.2",
+  "description": "Node.js wrapper for hamlib radio control library",
+  "main": "index.js",
+  "module": "lib/index.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    }
+  },
+  "gypfile": true,
+  "license": "LGPL",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/boybook/node-hamlib.git"
+  },
+  "keywords": [
+    "ham",
+    "radio",
+    "hamlib",
+    "amateur-radio",
+    "transceiver",
+    "rig-control"
+  ],
+  "files": [
+    "lib/",
+    "prebuilds/",
+    "src/",
+    "index.js",
+    "index.d.ts",
+    "binding.gyp",
+    "COPYING",
+    "Readme.md"
+  ],
+  "scripts": {
+    "build": "node-gyp configure && node-gyp build",
+    "rebuild": "node-gyp rebuild",
+    "clean": "node-gyp clean",
+    "test": "node test/test_loader.js",
+    "test:network": "node test/test_network.js",
+    "install": "node scripts/install.js",
+    "postinstall": "node scripts/install.js",
+    "prepare": "npm run build",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "node-addon-api": "^4.3.0"
+  },
+  "devDependencies": {
+    "node-gyp": "^9.4.0"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}

package/src/addon.cpp

@@ -0,0 +1,17 @@
+#include <napi.h>
+#include "hamlib.h"
+#include "decoder.h"
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+
+  Napi::String name = Napi::String::New(env, "HamLib");
+  exports.Set(name, NodeHamLib::GetClass(env));
+
+
+  // Napi::String decoder_name = Napi::String::New(env, "Decoder");
+  // exports.Set(decoder_name, Decoder::GetClass(env));
+
+  return exports;
+}
+
+NODE_API_MODULE(radio, Init)